From 4682d040b05b9bc2954f41481bd83e2b7bbcd152 Mon Sep 17 00:00:00 2001 From: suxin2017 Date: Wed, 18 Sep 2024 11:41:45 +0800 Subject: [PATCH] lint --- .../src/generated/node_factory.rs | 14 +- .../src/generated/syntax_factory.rs | 38 ++-- .../src/generated/kind.rs | 3 +- .../src/generated/macros.rs | 8 +- .../src/generated/nodes.rs | 210 +++++++++--------- .../src/generated/nodes_mut.rs | 16 +- xtask/codegen/markdown.ungram | 4 +- xtask/codegen/src/markdown_kinds_src.rs | 3 +- 8 files changed, 146 insertions(+), 150 deletions(-) diff --git a/crates/biome_markdown_factory/src/generated/node_factory.rs b/crates/biome_markdown_factory/src/generated/node_factory.rs index 22001152522b..1f5faff07ed8 100644 --- a/crates/biome_markdown_factory/src/generated/node_factory.rs +++ b/crates/biome_markdown_factory/src/generated/node_factory.rs @@ -7,14 +7,6 @@ use biome_markdown_syntax::{ MarkdownSyntaxToken as SyntaxToken, *, }; use biome_rowan::AstNode; -pub fn any_markdown_setext_header( - markdown_paragraph: MarkdownParagraph, -) -> AnyMarkdownSetextHeader { - AnyMarkdownSetextHeader::unwrap_cast(SyntaxNode::new_detached( - MarkdownSyntaxKind::ANY_MARKDOWN_SETEXT_HEADER, - [Some(SyntaxElement::Node(markdown_paragraph.into_syntax()))], - )) -} pub fn markdown_break_block(value_token: SyntaxToken) -> MarkdownBreakBlock { MarkdownBreakBlock::unwrap_cast(SyntaxNode::new_detached( MarkdownSyntaxKind::MARKDOWN_BREAK_BLOCK, @@ -259,6 +251,12 @@ pub fn markdown_quote(any_markdown_block: AnyMarkdownBlock) -> MarkdownQuote { [Some(SyntaxElement::Node(any_markdown_block.into_syntax()))], )) } +pub fn markdown_setext_header(markdown_paragraph: MarkdownParagraph) -> MarkdownSetextHeader { + MarkdownSetextHeader::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MARKDOWN_SETEXT_HEADER, + [Some(SyntaxElement::Node(markdown_paragraph.into_syntax()))], + )) +} pub fn markdown_soft_break(value_token: SyntaxToken) -> MarkdownSoftBreak { MarkdownSoftBreak::unwrap_cast(SyntaxNode::new_detached( MarkdownSyntaxKind::MARKDOWN_SOFT_BREAK, diff --git a/crates/biome_markdown_factory/src/generated/syntax_factory.rs b/crates/biome_markdown_factory/src/generated/syntax_factory.rs index a28596676e30..0a1b19d1aa50 100644 --- a/crates/biome_markdown_factory/src/generated/syntax_factory.rs +++ b/crates/biome_markdown_factory/src/generated/syntax_factory.rs @@ -15,25 +15,6 @@ impl SyntaxFactory for MarkdownSyntaxFactory { ) -> RawSyntaxNode { match kind { MARKDOWN_BOGUS => RawSyntaxNode::new(kind, children.into_iter().map(Some)), - ANY_MARKDOWN_SETEXT_HEADER => { - let mut elements = (&children).into_iter(); - let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default(); - let mut current_element = elements.next(); - if let Some(element) = ¤t_element { - if MarkdownParagraph::can_cast(element.kind()) { - slots.mark_present(); - current_element = elements.next(); - } - } - slots.next_slot(); - if current_element.is_some() { - return RawSyntaxNode::new( - ANY_MARKDOWN_SETEXT_HEADER.to_bogus(), - children.into_iter().map(Some), - ); - } - slots.into_node(ANY_MARKDOWN_SETEXT_HEADER, children) - } MARKDOWN_BREAK_BLOCK => { let mut elements = (&children).into_iter(); let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default(); @@ -446,6 +427,25 @@ impl SyntaxFactory for MarkdownSyntaxFactory { } slots.into_node(MARKDOWN_QUOTE, children) } + MARKDOWN_SETEXT_HEADER => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MarkdownParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MARKDOWN_SETEXT_HEADER.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MARKDOWN_SETEXT_HEADER, children) + } MARKDOWN_SOFT_BREAK => { let mut elements = (&children).into_iter(); let mut slots: RawNodeSlots<1usize> = RawNodeSlots::default(); diff --git a/crates/biome_markdown_syntax/src/generated/kind.rs b/crates/biome_markdown_syntax/src/generated/kind.rs index cd08b3b7d8df..daa86205cc97 100644 --- a/crates/biome_markdown_syntax/src/generated/kind.rs +++ b/crates/biome_markdown_syntax/src/generated/kind.rs @@ -46,8 +46,6 @@ pub enum MarkdownSyntaxKind { MARKDOWN_HASH_LIST, MARKDOWN_HASH, MARKDOWN_HEADER, - MARKDOWN_SETEXT_H1, - MARKDOWN_SETEXT_H2, MARKDOWN_INDENT_CODE_BLOCK, MARKDOWN_FENCED_CODE_BLOCK, MARKDOWN_HTML_BLOCK, @@ -66,6 +64,7 @@ pub enum MarkdownSyntaxKind { MARKDOWN_HARD_LINE, MARKDOWN_SOFT_BREAK, MARKDOWN_TEXTUAL, + MARKDOWN_SETEXT_HEADER, MARKDOWN_STRING, MARKDOWN_INDENT, MARKDOWN_BREAK_BLOCK, diff --git a/crates/biome_markdown_syntax/src/generated/macros.rs b/crates/biome_markdown_syntax/src/generated/macros.rs index 6727bd6d5ce4..e4e449f341af 100644 --- a/crates/biome_markdown_syntax/src/generated/macros.rs +++ b/crates/biome_markdown_syntax/src/generated/macros.rs @@ -16,10 +16,6 @@ macro_rules! map_syntax_node { ($ node : expr , $ pattern : pat => $ body : expr) => { match $node { node => match $crate::MarkdownSyntaxNode::kind(&node) { - $crate::MarkdownSyntaxKind::ANY_MARKDOWN_SETEXT_HEADER => { - let $pattern = unsafe { $crate::AnyMarkdownSetextHeader::new_unchecked(node) }; - $body - } $crate::MarkdownSyntaxKind::MARKDOWN_BREAK_BLOCK => { let $pattern = unsafe { $crate::MarkdownBreakBlock::new_unchecked(node) }; $body @@ -92,6 +88,10 @@ macro_rules! map_syntax_node { let $pattern = unsafe { $crate::MarkdownQuote::new_unchecked(node) }; $body } + $crate::MarkdownSyntaxKind::MARKDOWN_SETEXT_HEADER => { + let $pattern = unsafe { $crate::MarkdownSetextHeader::new_unchecked(node) }; + $body + } $crate::MarkdownSyntaxKind::MARKDOWN_SOFT_BREAK => { let $pattern = unsafe { $crate::MarkdownSoftBreak::new_unchecked(node) }; $body diff --git a/crates/biome_markdown_syntax/src/generated/nodes.rs b/crates/biome_markdown_syntax/src/generated/nodes.rs index 8538f5775f17..bd2e9199227a 100644 --- a/crates/biome_markdown_syntax/src/generated/nodes.rs +++ b/crates/biome_markdown_syntax/src/generated/nodes.rs @@ -24,41 +24,6 @@ use std::fmt::{Debug, Formatter}; #[allow(dead_code)] pub(crate) const SLOT_MAP_EMPTY_VALUE: u8 = u8::MAX; #[derive(Clone, PartialEq, Eq, Hash)] -pub struct AnyMarkdownSetextHeader { - pub(crate) syntax: SyntaxNode, -} -impl AnyMarkdownSetextHeader { - #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"] - #[doc = r""] - #[doc = r" # Safety"] - #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"] - #[doc = r" or a match on [SyntaxNode::kind]"] - #[inline] - pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self { - Self { syntax } - } - pub fn as_fields(&self) -> AnyMarkdownSetextHeaderFields { - AnyMarkdownSetextHeaderFields { - markdown_paragraph: self.markdown_paragraph(), - } - } - pub fn markdown_paragraph(&self) -> SyntaxResult { - support::required_node(&self.syntax, 0usize) - } -} -impl Serialize for AnyMarkdownSetextHeader { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.as_fields().serialize(serializer) - } -} -#[derive(Serialize)] -pub struct AnyMarkdownSetextHeaderFields { - pub markdown_paragraph: SyntaxResult, -} -#[derive(Clone, PartialEq, Eq, Hash)] pub struct MarkdownBreakBlock { pub(crate) syntax: SyntaxNode, } @@ -739,6 +704,41 @@ pub struct MarkdownQuoteFields { pub any_markdown_block: SyntaxResult, } #[derive(Clone, PartialEq, Eq, Hash)] +pub struct MarkdownSetextHeader { + pub(crate) syntax: SyntaxNode, +} +impl MarkdownSetextHeader { + #[doc = r" Create an AstNode from a SyntaxNode without checking its kind"] + #[doc = r""] + #[doc = r" # Safety"] + #[doc = r" This function must be guarded with a call to [AstNode::can_cast]"] + #[doc = r" or a match on [SyntaxNode::kind]"] + #[inline] + pub const unsafe fn new_unchecked(syntax: SyntaxNode) -> Self { + Self { syntax } + } + pub fn as_fields(&self) -> MarkdownSetextHeaderFields { + MarkdownSetextHeaderFields { + markdown_paragraph: self.markdown_paragraph(), + } + } + pub fn markdown_paragraph(&self) -> SyntaxResult { + support::required_node(&self.syntax, 0usize) + } +} +impl Serialize for MarkdownSetextHeader { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MarkdownSetextHeaderFields { + pub markdown_paragraph: SyntaxResult, +} +#[derive(Clone, PartialEq, Eq, Hash)] pub struct MarkdownSoftBreak { pub(crate) syntax: SyntaxNode, } @@ -856,12 +856,12 @@ impl AnyContainerBlock { #[derive(Clone, PartialEq, Eq, Hash, Serialize)] pub enum AnyLeafBlock { AnyCodeBlock(AnyCodeBlock), - AnyMarkdownSetextHeader(AnyMarkdownSetextHeader), MarkdownBreakBlock(MarkdownBreakBlock), MarkdownHeader(MarkdownHeader), MarkdownHtmlBlock(MarkdownHtmlBlock), MarkdownLinkBlock(MarkdownLinkBlock), MarkdownParagraph(MarkdownParagraph), + MarkdownSetextHeader(MarkdownSetextHeader), } impl AnyLeafBlock { pub fn as_any_code_block(&self) -> Option<&AnyCodeBlock> { @@ -870,12 +870,6 @@ impl AnyLeafBlock { _ => None, } } - pub fn as_any_markdown_setext_header(&self) -> Option<&AnyMarkdownSetextHeader> { - match &self { - AnyLeafBlock::AnyMarkdownSetextHeader(item) => Some(item), - _ => None, - } - } pub fn as_markdown_break_block(&self) -> Option<&MarkdownBreakBlock> { match &self { AnyLeafBlock::MarkdownBreakBlock(item) => Some(item), @@ -906,6 +900,12 @@ impl AnyLeafBlock { _ => None, } } + pub fn as_markdown_setext_header(&self) -> Option<&MarkdownSetextHeader> { + match &self { + AnyLeafBlock::MarkdownSetextHeader(item) => Some(item), + _ => None, + } + } } #[derive(Clone, PartialEq, Eq, Hash, Serialize)] pub enum AnyMarkdownBlock { @@ -987,47 +987,6 @@ impl AnyMarkdownInline { } } } -impl AstNode for AnyMarkdownSetextHeader { - type Language = Language; - const KIND_SET: SyntaxKindSet = - SyntaxKindSet::from_raw(RawSyntaxKind(ANY_MARKDOWN_SETEXT_HEADER as u16)); - fn can_cast(kind: SyntaxKind) -> bool { - kind == ANY_MARKDOWN_SETEXT_HEADER - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } - fn into_syntax(self) -> SyntaxNode { - self.syntax - } -} -impl std::fmt::Debug for AnyMarkdownSetextHeader { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("AnyMarkdownSetextHeader") - .field( - "markdown_paragraph", - &support::DebugSyntaxResult(self.markdown_paragraph()), - ) - .finish() - } -} -impl From for SyntaxNode { - fn from(n: AnyMarkdownSetextHeader) -> SyntaxNode { - n.syntax - } -} -impl From for SyntaxElement { - fn from(n: AnyMarkdownSetextHeader) -> SyntaxElement { - n.syntax.into() - } -} impl AstNode for MarkdownBreakBlock { type Language = Language; const KIND_SET: SyntaxKindSet = @@ -1758,6 +1717,47 @@ impl From for SyntaxElement { n.syntax.into() } } +impl AstNode for MarkdownSetextHeader { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MARKDOWN_SETEXT_HEADER as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MARKDOWN_SETEXT_HEADER + } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl std::fmt::Debug for MarkdownSetextHeader { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("MarkdownSetextHeader") + .field( + "markdown_paragraph", + &support::DebugSyntaxResult(self.markdown_paragraph()), + ) + .finish() + } +} +impl From for SyntaxNode { + fn from(n: MarkdownSetextHeader) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MarkdownSetextHeader) -> SyntaxElement { + n.syntax.into() + } +} impl AstNode for MarkdownSoftBreak { type Language = Language; const KIND_SET: SyntaxKindSet = @@ -1985,11 +1985,6 @@ impl From for SyntaxElement { node.into() } } -impl From for AnyLeafBlock { - fn from(node: AnyMarkdownSetextHeader) -> AnyLeafBlock { - AnyLeafBlock::AnyMarkdownSetextHeader(node) - } -} impl From for AnyLeafBlock { fn from(node: MarkdownBreakBlock) -> AnyLeafBlock { AnyLeafBlock::MarkdownBreakBlock(node) @@ -2015,37 +2010,42 @@ impl From for AnyLeafBlock { AnyLeafBlock::MarkdownParagraph(node) } } +impl From for AnyLeafBlock { + fn from(node: MarkdownSetextHeader) -> AnyLeafBlock { + AnyLeafBlock::MarkdownSetextHeader(node) + } +} impl AstNode for AnyLeafBlock { type Language = Language; const KIND_SET: SyntaxKindSet = AnyCodeBlock::KIND_SET - .union(AnyMarkdownSetextHeader::KIND_SET) .union(MarkdownBreakBlock::KIND_SET) .union(MarkdownHeader::KIND_SET) .union(MarkdownHtmlBlock::KIND_SET) .union(MarkdownLinkBlock::KIND_SET) - .union(MarkdownParagraph::KIND_SET); + .union(MarkdownParagraph::KIND_SET) + .union(MarkdownSetextHeader::KIND_SET); fn can_cast(kind: SyntaxKind) -> bool { match kind { - ANY_MARKDOWN_SETEXT_HEADER - | MARKDOWN_BREAK_BLOCK + MARKDOWN_BREAK_BLOCK | MARKDOWN_HEADER | MARKDOWN_HTML_BLOCK | MARKDOWN_LINK_BLOCK - | MARKDOWN_PARAGRAPH => true, + | MARKDOWN_PARAGRAPH + | MARKDOWN_SETEXT_HEADER => true, k if AnyCodeBlock::can_cast(k) => true, _ => false, } } fn cast(syntax: SyntaxNode) -> Option { let res = match syntax.kind() { - ANY_MARKDOWN_SETEXT_HEADER => { - AnyLeafBlock::AnyMarkdownSetextHeader(AnyMarkdownSetextHeader { syntax }) - } MARKDOWN_BREAK_BLOCK => AnyLeafBlock::MarkdownBreakBlock(MarkdownBreakBlock { syntax }), MARKDOWN_HEADER => AnyLeafBlock::MarkdownHeader(MarkdownHeader { syntax }), MARKDOWN_HTML_BLOCK => AnyLeafBlock::MarkdownHtmlBlock(MarkdownHtmlBlock { syntax }), MARKDOWN_LINK_BLOCK => AnyLeafBlock::MarkdownLinkBlock(MarkdownLinkBlock { syntax }), MARKDOWN_PARAGRAPH => AnyLeafBlock::MarkdownParagraph(MarkdownParagraph { syntax }), + MARKDOWN_SETEXT_HEADER => { + AnyLeafBlock::MarkdownSetextHeader(MarkdownSetextHeader { syntax }) + } _ => { if let Some(any_code_block) = AnyCodeBlock::cast(syntax) { return Some(AnyLeafBlock::AnyCodeBlock(any_code_block)); @@ -2057,23 +2057,23 @@ impl AstNode for AnyLeafBlock { } fn syntax(&self) -> &SyntaxNode { match self { - AnyLeafBlock::AnyMarkdownSetextHeader(it) => &it.syntax, AnyLeafBlock::MarkdownBreakBlock(it) => &it.syntax, AnyLeafBlock::MarkdownHeader(it) => &it.syntax, AnyLeafBlock::MarkdownHtmlBlock(it) => &it.syntax, AnyLeafBlock::MarkdownLinkBlock(it) => &it.syntax, AnyLeafBlock::MarkdownParagraph(it) => &it.syntax, + AnyLeafBlock::MarkdownSetextHeader(it) => &it.syntax, AnyLeafBlock::AnyCodeBlock(it) => it.syntax(), } } fn into_syntax(self) -> SyntaxNode { match self { - AnyLeafBlock::AnyMarkdownSetextHeader(it) => it.syntax, AnyLeafBlock::MarkdownBreakBlock(it) => it.syntax, AnyLeafBlock::MarkdownHeader(it) => it.syntax, AnyLeafBlock::MarkdownHtmlBlock(it) => it.syntax, AnyLeafBlock::MarkdownLinkBlock(it) => it.syntax, AnyLeafBlock::MarkdownParagraph(it) => it.syntax, + AnyLeafBlock::MarkdownSetextHeader(it) => it.syntax, AnyLeafBlock::AnyCodeBlock(it) => it.into_syntax(), } } @@ -2082,12 +2082,12 @@ impl std::fmt::Debug for AnyLeafBlock { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { AnyLeafBlock::AnyCodeBlock(it) => std::fmt::Debug::fmt(it, f), - AnyLeafBlock::AnyMarkdownSetextHeader(it) => std::fmt::Debug::fmt(it, f), AnyLeafBlock::MarkdownBreakBlock(it) => std::fmt::Debug::fmt(it, f), AnyLeafBlock::MarkdownHeader(it) => std::fmt::Debug::fmt(it, f), AnyLeafBlock::MarkdownHtmlBlock(it) => std::fmt::Debug::fmt(it, f), AnyLeafBlock::MarkdownLinkBlock(it) => std::fmt::Debug::fmt(it, f), AnyLeafBlock::MarkdownParagraph(it) => std::fmt::Debug::fmt(it, f), + AnyLeafBlock::MarkdownSetextHeader(it) => std::fmt::Debug::fmt(it, f), } } } @@ -2095,12 +2095,12 @@ impl From for SyntaxNode { fn from(n: AnyLeafBlock) -> SyntaxNode { match n { AnyLeafBlock::AnyCodeBlock(it) => it.into(), - AnyLeafBlock::AnyMarkdownSetextHeader(it) => it.into(), AnyLeafBlock::MarkdownBreakBlock(it) => it.into(), AnyLeafBlock::MarkdownHeader(it) => it.into(), AnyLeafBlock::MarkdownHtmlBlock(it) => it.into(), AnyLeafBlock::MarkdownLinkBlock(it) => it.into(), AnyLeafBlock::MarkdownParagraph(it) => it.into(), + AnyLeafBlock::MarkdownSetextHeader(it) => it.into(), } } } @@ -2341,11 +2341,6 @@ impl std::fmt::Display for AnyMarkdownInline { std::fmt::Display::fmt(self.syntax(), f) } } -impl std::fmt::Display for AnyMarkdownSetextHeader { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} impl std::fmt::Display for MarkdownBreakBlock { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) @@ -2436,6 +2431,11 @@ impl std::fmt::Display for MarkdownQuote { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for MarkdownSetextHeader { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for MarkdownSoftBreak { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { std::fmt::Display::fmt(self.syntax(), f) diff --git a/crates/biome_markdown_syntax/src/generated/nodes_mut.rs b/crates/biome_markdown_syntax/src/generated/nodes_mut.rs index 9653ecd2d1b3..c6b3cea23b8a 100644 --- a/crates/biome_markdown_syntax/src/generated/nodes_mut.rs +++ b/crates/biome_markdown_syntax/src/generated/nodes_mut.rs @@ -3,14 +3,6 @@ use crate::{generated::nodes::*, MarkdownSyntaxToken as SyntaxToken}; use biome_rowan::AstNode; use std::iter::once; -impl AnyMarkdownSetextHeader { - pub fn with_markdown_paragraph(self, element: MarkdownParagraph) -> Self { - Self::unwrap_cast( - self.syntax - .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), - ) - } -} impl MarkdownBreakBlock { pub fn with_value_token(self, element: SyntaxToken) -> Self { Self::unwrap_cast( @@ -215,6 +207,14 @@ impl MarkdownQuote { ) } } +impl MarkdownSetextHeader { + pub fn with_markdown_paragraph(self, element: MarkdownParagraph) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } +} impl MarkdownSoftBreak { pub fn with_value_token(self, element: SyntaxToken) -> Self { Self::unwrap_cast( diff --git a/xtask/codegen/markdown.ungram b/xtask/codegen/markdown.ungram index cb3abdb6cd4a..2bad3f2a348f 100644 --- a/xtask/codegen/markdown.ungram +++ b/xtask/codegen/markdown.ungram @@ -48,7 +48,7 @@ MarkdownBlockList = AnyMarkdownBlock* AnyMarkdownBlock = AnyLeafBlock | AnyContainerBlock -AnyLeafBlock = MarkdownBreakBlock | MarkdownHeader | AnyMarkdownSetextHeader +AnyLeafBlock = MarkdownBreakBlock | MarkdownHeader | MarkdownSetextHeader | AnyCodeBlock | MarkdownHtmlBlock | MarkdownLinkBlock | MarkdownParagraph AnyContainerBlock = MarkdownQuote | MarkdownBulletListItem | MarkdownOrderListItem @@ -68,7 +68,7 @@ MarkdownHash = '#' // === // bar // --- -AnyMarkdownSetextHeader = MarkdownParagraph +MarkdownSetextHeader = MarkdownParagraph // indented code blocks & fenced code blocks AnyCodeBlock = MarkdownIndentCodeBlock | MarkdownFencedCodeBlock diff --git a/xtask/codegen/src/markdown_kinds_src.rs b/xtask/codegen/src/markdown_kinds_src.rs index c9a98fddc5c6..af99e83527ae 100644 --- a/xtask/codegen/src/markdown_kinds_src.rs +++ b/xtask/codegen/src/markdown_kinds_src.rs @@ -40,8 +40,6 @@ pub const MARKDOWN_KINDS_SRC: KindsSrc = KindsSrc { "MARKDOWN_HASH_LIST", "MARKDOWN_HASH", "MARKDOWN_HEADER", - "MARKDOWN_SETEXT_H1", - "MARKDOWN_SETEXT_H2", "MARKDOWN_INDENT_CODE_BLOCK", "MARKDOWN_FENCED_CODE_BLOCK", "MARKDOWN_HTML_BLOCK", @@ -60,6 +58,7 @@ pub const MARKDOWN_KINDS_SRC: KindsSrc = KindsSrc { "MARKDOWN_HARD_LINE", "MARKDOWN_SOFT_BREAK", "MARKDOWN_TEXTUAL", + "MARKDOWN_SETEXT_HEADER", "MARKDOWN_STRING", "MARKDOWN_INDENT", "MARKDOWN_BREAK_BLOCK",