From 18f748fc6681250f531593f25cf2aa4f7058a4ba Mon Sep 17 00:00:00 2001 From: Augustin Mauroy <97875033+AugustinMauroy@users.noreply.github.com> Date: Tue, 25 Feb 2025 22:53:19 +0100 Subject: [PATCH] generated --- .../src/generated/node_factory.rs | 174 +++++ .../src/generated/syntax_factory.rs | 198 ++++++ .../src/generated/kind.rs | 6 + .../src/generated/macros.rs | 24 + .../src/generated/nodes.rs | 612 ++++++++++++++++++ .../src/generated/nodes_mut.rs | 120 ++++ 6 files changed, 1134 insertions(+) diff --git a/crates/biome_markdown_factory/src/generated/node_factory.rs b/crates/biome_markdown_factory/src/generated/node_factory.rs index 42d59769621c..f5f9a028ea5e 100644 --- a/crates/biome_markdown_factory/src/generated/node_factory.rs +++ b/crates/biome_markdown_factory/src/generated/node_factory.rs @@ -87,6 +87,180 @@ impl MdHeaderBuilder { )) } } +pub fn md_header1(before: MdHashList, after: MdHashList) -> MdHeader1Builder { + MdHeader1Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader1Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader1Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader1 { + MdHeader1::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER1, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} +pub fn md_header2(before: MdHashList, after: MdHashList) -> MdHeader2Builder { + MdHeader2Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader2Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader2Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader2 { + MdHeader2::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER2, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} +pub fn md_header3(before: MdHashList, after: MdHashList) -> MdHeader3Builder { + MdHeader3Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader3Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader3Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader3 { + MdHeader3::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER3, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} +pub fn md_header4(before: MdHashList, after: MdHashList) -> MdHeader4Builder { + MdHeader4Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader4Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader4Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader4 { + MdHeader4::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER4, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} +pub fn md_header5(before: MdHashList, after: MdHashList) -> MdHeader5Builder { + MdHeader5Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader5Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader5Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader5 { + MdHeader5::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER5, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} +pub fn md_header6(before: MdHashList, after: MdHashList) -> MdHeader6Builder { + MdHeader6Builder { + before, + after, + md_paragraph: None, + } +} +pub struct MdHeader6Builder { + before: MdHashList, + after: MdHashList, + md_paragraph: Option, +} +impl MdHeader6Builder { + pub fn with_md_paragraph(mut self, md_paragraph: MdParagraph) -> Self { + self.md_paragraph = Some(md_paragraph); + self + } + pub fn build(self) -> MdHeader6 { + MdHeader6::unwrap_cast(SyntaxNode::new_detached( + MarkdownSyntaxKind::MD_HEADER6, + [ + Some(SyntaxElement::Node(self.before.into_syntax())), + self.md_paragraph + .map(|token| SyntaxElement::Node(token.into_syntax())), + Some(SyntaxElement::Node(self.after.into_syntax())), + ], + )) + } +} pub fn md_html_block(md_textual: MdTextual) -> MdHtmlBlock { MdHtmlBlock::unwrap_cast(SyntaxNode::new_detached( MarkdownSyntaxKind::MD_HTML_BLOCK, diff --git a/crates/biome_markdown_factory/src/generated/syntax_factory.rs b/crates/biome_markdown_factory/src/generated/syntax_factory.rs index c112b6bc4428..ca911fcef1f6 100644 --- a/crates/biome_markdown_factory/src/generated/syntax_factory.rs +++ b/crates/biome_markdown_factory/src/generated/syntax_factory.rs @@ -154,6 +154,204 @@ impl SyntaxFactory for MarkdownSyntaxFactory { } slots.into_node(MD_HEADER, children) } + MD_HEADER1 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER1.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER1, children) + } + MD_HEADER2 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER2.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER2, children) + } + MD_HEADER3 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER3.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER3, children) + } + MD_HEADER4 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER4.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER4, children) + } + MD_HEADER5 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER5.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER5, children) + } + MD_HEADER6 => { + let mut elements = (&children).into_iter(); + let mut slots: RawNodeSlots<3usize> = RawNodeSlots::default(); + let mut current_element = elements.next(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdParagraph::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if let Some(element) = ¤t_element { + if MdHashList::can_cast(element.kind()) { + slots.mark_present(); + current_element = elements.next(); + } + } + slots.next_slot(); + if current_element.is_some() { + return RawSyntaxNode::new( + MD_HEADER6.to_bogus(), + children.into_iter().map(Some), + ); + } + slots.into_node(MD_HEADER6, children) + } MD_HTML_BLOCK => { 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 824489e68e5f..0b1ef1dde743 100644 --- a/crates/biome_markdown_syntax/src/generated/kind.rs +++ b/crates/biome_markdown_syntax/src/generated/kind.rs @@ -47,6 +47,12 @@ pub enum MarkdownSyntaxKind { MD_HASH_LIST, MD_HASH, MD_HEADER, + MD_HEADER1, + MD_HEADER2, + MD_HEADER3, + MD_HEADER4, + MD_HEADER5, + MD_HEADER6, MD_INDENT_CODE_BLOCK, MD_FENCED_CODE_BLOCK, MD_HTML_BLOCK, diff --git a/crates/biome_markdown_syntax/src/generated/macros.rs b/crates/biome_markdown_syntax/src/generated/macros.rs index fc61b8759e44..9b9887953503 100644 --- a/crates/biome_markdown_syntax/src/generated/macros.rs +++ b/crates/biome_markdown_syntax/src/generated/macros.rs @@ -40,6 +40,30 @@ macro_rules! map_syntax_node { let $pattern = unsafe { $crate::MdHeader::new_unchecked(node) }; $body } + $crate::MarkdownSyntaxKind::MD_HEADER1 => { + let $pattern = unsafe { $crate::MdHeader1::new_unchecked(node) }; + $body + } + $crate::MarkdownSyntaxKind::MD_HEADER2 => { + let $pattern = unsafe { $crate::MdHeader2::new_unchecked(node) }; + $body + } + $crate::MarkdownSyntaxKind::MD_HEADER3 => { + let $pattern = unsafe { $crate::MdHeader3::new_unchecked(node) }; + $body + } + $crate::MarkdownSyntaxKind::MD_HEADER4 => { + let $pattern = unsafe { $crate::MdHeader4::new_unchecked(node) }; + $body + } + $crate::MarkdownSyntaxKind::MD_HEADER5 => { + let $pattern = unsafe { $crate::MdHeader5::new_unchecked(node) }; + $body + } + $crate::MarkdownSyntaxKind::MD_HEADER6 => { + let $pattern = unsafe { $crate::MdHeader6::new_unchecked(node) }; + $body + } $crate::MarkdownSyntaxKind::MD_HTML_BLOCK => { let $pattern = unsafe { $crate::MdHtmlBlock::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 01fdaa87e57f..7cf0d89763d3 100644 --- a/crates/biome_markdown_syntax/src/generated/nodes.rs +++ b/crates/biome_markdown_syntax/src/generated/nodes.rs @@ -251,6 +251,276 @@ pub struct MdHeaderFields { pub after: MdHashList, } #[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader1 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader1 { + #[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) -> MdHeader1Fields { + MdHeader1Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader1 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader1Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader2 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader2 { + #[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) -> MdHeader2Fields { + MdHeader2Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader2 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader2Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader3 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader3 { + #[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) -> MdHeader3Fields { + MdHeader3Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader3 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader3Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader4 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader4 { + #[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) -> MdHeader4Fields { + MdHeader4Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader4 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader4Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader5 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader5 { + #[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) -> MdHeader5Fields { + MdHeader5Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader5 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader5Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] +pub struct MdHeader6 { + pub(crate) syntax: SyntaxNode, +} +impl MdHeader6 { + #[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) -> MdHeader6Fields { + MdHeader6Fields { + before: self.before(), + md_paragraph: self.md_paragraph(), + after: self.after(), + } + } + pub fn before(&self) -> MdHashList { + support::list(&self.syntax, 0usize) + } + pub fn md_paragraph(&self) -> Option { + support::node(&self.syntax, 1usize) + } + pub fn after(&self) -> MdHashList { + support::list(&self.syntax, 2usize) + } +} +impl Serialize for MdHeader6 { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.as_fields().serialize(serializer) + } +} +#[derive(Serialize)] +pub struct MdHeader6Fields { + pub before: MdHashList, + pub md_paragraph: Option, + pub after: MdHashList, +} +#[derive(Clone, PartialEq, Eq, Hash)] pub struct MdHtmlBlock { pub(crate) syntax: SyntaxNode, } @@ -1279,6 +1549,318 @@ impl From for SyntaxElement { n.syntax.into() } } +impl AstNode for MdHeader1 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER1 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER1 + } + 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 MdHeader1 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader1") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader1").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader1) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader1) -> SyntaxElement { + n.syntax.into() + } +} +impl AstNode for MdHeader2 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER2 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER2 + } + 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 MdHeader2 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader2") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader2").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader2) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader2) -> SyntaxElement { + n.syntax.into() + } +} +impl AstNode for MdHeader3 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER3 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER3 + } + 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 MdHeader3 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader3") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader3").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader3) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader3) -> SyntaxElement { + n.syntax.into() + } +} +impl AstNode for MdHeader4 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER4 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER4 + } + 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 MdHeader4 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader4") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader4").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader4) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader4) -> SyntaxElement { + n.syntax.into() + } +} +impl AstNode for MdHeader5 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER5 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER5 + } + 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 MdHeader5 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader5") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader5").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader5) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader5) -> SyntaxElement { + n.syntax.into() + } +} +impl AstNode for MdHeader6 { + type Language = Language; + const KIND_SET: SyntaxKindSet = + SyntaxKindSet::from_raw(RawSyntaxKind(MD_HEADER6 as u16)); + fn can_cast(kind: SyntaxKind) -> bool { + kind == MD_HEADER6 + } + 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 MdHeader6 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + thread_local! { static DEPTH : std :: cell :: Cell < u8 > = const { std :: cell :: Cell :: new (0) } }; + let current_depth = DEPTH.get(); + let result = if current_depth < 16 { + DEPTH.set(current_depth + 1); + f.debug_struct("MdHeader6") + .field("before", &self.before()) + .field( + "md_paragraph", + &support::DebugOptionalElement(self.md_paragraph()), + ) + .field("after", &self.after()) + .finish() + } else { + f.debug_struct("MdHeader6").finish() + }; + DEPTH.set(current_depth); + result + } +} +impl From for SyntaxNode { + fn from(n: MdHeader6) -> SyntaxNode { + n.syntax + } +} +impl From for SyntaxElement { + fn from(n: MdHeader6) -> SyntaxElement { + n.syntax.into() + } +} impl AstNode for MdHtmlBlock { type Language = Language; const KIND_SET: SyntaxKindSet = @@ -2513,6 +3095,36 @@ impl std::fmt::Display for MdHeader { std::fmt::Display::fmt(self.syntax(), f) } } +impl std::fmt::Display for MdHeader1 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MdHeader2 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MdHeader3 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MdHeader4 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MdHeader5 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl std::fmt::Display for MdHeader6 { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} impl std::fmt::Display for MdHtmlBlock { 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 af745f54bf30..433fcdc4e597 100644 --- a/crates/biome_markdown_syntax/src/generated/nodes_mut.rs +++ b/crates/biome_markdown_syntax/src/generated/nodes_mut.rs @@ -75,6 +75,126 @@ impl MdHeader { ) } } +impl MdHeader1 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} +impl MdHeader2 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} +impl MdHeader3 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} +impl MdHeader4 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} +impl MdHeader5 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} +impl MdHeader6 { + pub fn with_before(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(0usize..=0usize, once(Some(element.into_syntax().into()))), + ) + } + pub fn with_md_paragraph(self, element: Option) -> Self { + Self::unwrap_cast(self.syntax.splice_slots( + 1usize..=1usize, + once(element.map(|element| element.into_syntax().into())), + )) + } + pub fn with_after(self, element: MdHashList) -> Self { + Self::unwrap_cast( + self.syntax + .splice_slots(2usize..=2usize, once(Some(element.into_syntax().into()))), + ) + } +} impl MdHtmlBlock { pub fn with_md_textual(self, element: MdTextual) -> Self { Self::unwrap_cast(