refactor(parser/html): refactor comments to be nodes in the tree

crates/biome_html_formatter/src/generated.rs

@@ -118,6 +118,46 @@ impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlClosingElement {
         )
     }
 }
+impl FormatRule<biome_html_syntax::HtmlComment>
+    for crate::html::auxiliary::comment::FormatHtmlComment
+{
+    type Context = HtmlFormatContext;
+    #[inline(always)]
+    fn fmt(
+        &self,
+        node: &biome_html_syntax::HtmlComment,
+        f: &mut HtmlFormatter,
+    ) -> FormatResult<()> {
+        FormatNodeRule::<biome_html_syntax::HtmlComment>::fmt(self, node, f)
+    }
+}
+impl AsFormat<HtmlFormatContext> for biome_html_syntax::HtmlComment {
+    type Format<'a> = FormatRefWithRule<
+        'a,
+        biome_html_syntax::HtmlComment,
+        crate::html::auxiliary::comment::FormatHtmlComment,
+    >;
+    fn format(&self) -> Self::Format<'_> {
+        #![allow(clippy::default_constructed_unit_structs)]
+        FormatRefWithRule::new(
+            self,
+            crate::html::auxiliary::comment::FormatHtmlComment::default(),
+        )
+    }
+}
+impl IntoFormat<HtmlFormatContext> for biome_html_syntax::HtmlComment {
+    type Format = FormatOwnedWithRule<
+        biome_html_syntax::HtmlComment,
+        crate::html::auxiliary::comment::FormatHtmlComment,
+    >;
+    fn into_format(self) -> Self::Format {
+        #![allow(clippy::default_constructed_unit_structs)]
+        FormatOwnedWithRule::new(
+            self,
+            crate::html::auxiliary::comment::FormatHtmlComment::default(),
+        )
+    }
+}
 impl FormatRule<biome_html_syntax::HtmlContent>
     for crate::html::auxiliary::content::FormatHtmlContent
 {

crates/biome_html_formatter/src/html/any/element.rs

@@ -9,6 +9,7 @@ impl FormatRule<AnyHtmlElement> for FormatAnyHtmlElement {
     fn fmt(&self, node: &AnyHtmlElement, f: &mut HtmlFormatter) -> FormatResult<()> {
         match node {
             AnyHtmlElement::HtmlBogusElement(node) => node.format().fmt(f),
+            AnyHtmlElement::HtmlComment(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlContent(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlElement(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlSelfClosingElement(node) => node.format().fmt(f),

crates/biome_html_formatter/src/html/auxiliary/comment.rs

@@ -0,0 +1,10 @@
+use crate::prelude::*;
+use biome_html_syntax::HtmlComment;
+use biome_rowan::AstNode;
+#[derive(Debug, Clone, Default)]
+pub(crate) struct FormatHtmlComment;
+impl FormatNodeRule<HtmlComment> for FormatHtmlComment {
+    fn fmt_fields(&self, node: &HtmlComment, f: &mut HtmlFormatter) -> FormatResult<()> {
+        format_verbatim_node(node.syntax()).fmt(f)
+    }
+}

crates/biome_html_formatter/src/html/auxiliary/mod.rs

@@ -3,6 +3,7 @@
 pub(crate) mod attribute;
 pub(crate) mod attribute_initializer_clause;
 pub(crate) mod closing_element;
+pub(crate) mod comment;
 pub(crate) mod content;
 pub(crate) mod directive;
 pub(crate) mod element;

crates/biome_html_parser/src/lexer/mod.rs

@@ -2,8 +2,8 @@ mod tests;
 
 use crate::token_source::{HtmlEmbededLanguage, HtmlLexContext};
 use biome_html_syntax::HtmlSyntaxKind::{
-    COMMENT, DOCTYPE_KW, EOF, ERROR_TOKEN, HTML_KW, HTML_LITERAL, HTML_STRING_LITERAL, NEWLINE,
-    TOMBSTONE, UNICODE_BOM, WHITESPACE,
+    DOCTYPE_KW, EOF, ERROR_TOKEN, HTML_KW, HTML_LITERAL, HTML_STRING_LITERAL, NEWLINE, TOMBSTONE,
+    UNICODE_BOM, WHITESPACE,
 };
 use biome_html_syntax::{HtmlSyntaxKind, TextLen, TextSize, T};
 use biome_parser::diagnostic::ParseDiagnostic;
@@ -137,6 +137,24 @@ impl<'src> HtmlLexer<'src> {
         }
     }
 
+    /// Consume a token in the [HtmlLexContext::Comment] context.
+    fn consume_inside_comment(&mut self, current: u8) -> HtmlSyntaxKind {
+        match current {
+            b'<' if self.at_start_comment() => self.consume_comment_start(),
+            b'-' if self.at_end_comment() => self.consume_comment_end(),
+            _ => {
+                while let Some(char) = self.current_byte() {
+                    if self.at_end_comment() {
+                        // eat -->
+                        break;
+                    }
+                    self.advance_byte_or_char(char);
+                }
+                HTML_LITERAL
+            }
+        }
+    }
+
     /// Bumps the current byte and creates a lexed token of the passed in kind.
     #[inline]
     fn consume_byte(&mut self, tok: HtmlSyntaxKind) -> HtmlSyntaxKind {
@@ -309,28 +327,12 @@ impl<'src> HtmlLexer<'src> {
         self.assert_byte(b'<');
 
         if self.at_start_comment() {
-            self.consume_comment()
+            self.consume_comment_start()
         } else {
             self.consume_byte(T![<])
         }
     }
 
-    fn consume_comment(&mut self) -> HtmlSyntaxKind {
-        // eat <!--
-        self.advance(4);
-
-        while let Some(char) = self.current_byte() {
-            if self.at_end_comment() {
-                // eat -->
-                self.advance(3);
-                return COMMENT;
-            }
-            self.advance_byte_or_char(char);
-        }
-
-        COMMENT
-    }
-
     fn at_start_comment(&mut self) -> bool {
         self.current_byte() == Some(b'<')
             && self.byte_at(1) == Some(b'!')
@@ -344,6 +346,20 @@ impl<'src> HtmlLexer<'src> {
             && self.byte_at(2) == Some(b'>')
     }
 
+    fn consume_comment_start(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_start_comment());
+
+        self.advance(4);
+        T![<!--]
+    }
+
+    fn consume_comment_end(&mut self) -> HtmlSyntaxKind {
+        debug_assert!(self.at_end_comment());
+
+        self.advance(3);
+        T![-->]
+    }
+
     /// Lexes a `\u0000` escape sequence. Assumes that the lexer is positioned at the `u` token.
     ///
     /// A unicode escape sequence must consist of 4 hex characters.
@@ -462,6 +478,7 @@ impl<'src> Lexer<'src> for HtmlLexer<'src> {
                     HtmlLexContext::EmbeddedLanguage(lang) => {
                         self.consume_token_embedded_language(current, lang)
                     }
+                    HtmlLexContext::Comment => self.consume_inside_comment(current),
                 },
                 None => EOF,
             }

crates/biome_html_parser/src/lexer/tests.rs

@@ -289,3 +289,31 @@ fn unquoted_attribute_value_invalid_chars() {
         ERROR_TOKEN: 3,
     }
 }
+
+#[test]
+fn comment_start() {
+    assert_lex! {
+        "<!--",
+        COMMENT_START: 4,
+    }
+}
+
+#[test]
+fn comment_end() {
+    assert_lex! {
+        HtmlLexContext::Comment,
+        "-->",
+        COMMENT_END: 3,
+    }
+}
+
+#[test]
+fn comment_full() {
+    assert_lex! {
+        HtmlLexContext::Comment,
+        "<!-- foo -->",
+        COMMENT_START: 4,
+        HTML_LITERAL: 5,
+        COMMENT_END: 3,
+    }
+}

crates/biome_html_parser/src/syntax/mod.rs

@@ -158,6 +158,7 @@ impl ParseNodeList for ElementList {
 
     fn parse_element(&mut self, p: &mut Self::Parser<'_>) -> ParsedSyntax {
         match p.cur() {
+            T![<!--] => parse_comment(p),
             T![<] => parse_element(p),
             HTML_LITERAL => {
                 let m = p.start();
@@ -263,3 +264,14 @@ fn parse_attribute_initializer(p: &mut HtmlParser) -> ParsedSyntax {
     parse_attribute_string_literal(p).or_add_diagnostic(p, expected_initializer);
     Present(m.complete(p, HTML_ATTRIBUTE_INITIALIZER_CLAUSE))
 }
+
+fn parse_comment(p: &mut HtmlParser) -> ParsedSyntax {
+    if !p.at(T![<!--]) {
+        return Absent;
+    }
+    let m = p.start();
+    p.bump_with_context(T![<!--], HtmlLexContext::Comment);
+    p.bump_with_context(HTML_LITERAL, HtmlLexContext::Comment);
+    p.expect(T![-->]);
+    Present(m.complete(p, HTML_COMMENT))
+}

crates/biome_html_parser/src/token_source.rs

@@ -33,6 +33,8 @@ pub(crate) enum HtmlLexContext {
     Doctype,
     /// Treat everything as text until the closing tag is encountered.
     EmbeddedLanguage(HtmlEmbededLanguage),
+    /// Comments are treated as text until the closing comment tag is encountered.
+    Comment,
 }
 
 #[derive(Copy, Clone, Debug)]

crates/biome_html_parser/tests/html_specs/ok/comment.html.snap

@@ -16,8 +16,14 @@ expression: snapshot
 HtmlRoot {
     bom_token: missing (optional),
     directive: missing (optional),
-    html: HtmlElementList [],
-    eof_token: EOF@0..21 "" [Comments("<!-- Hello World -->"), Newline("\n")] [],
+    html: HtmlElementList [
+        HtmlComment {
+            comment_start_token: COMMENT_START@0..4 "<!--" [] [],
+            content_token: HTML_LITERAL@4..17 " Hello World " [] [],
+            comment_end_token: COMMENT_END@17..20 "-->" [] [],
+        },
+    ],
+    eof_token: EOF@20..21 "" [Newline("\n")] [],
 }
 ```
 
@@ -27,7 +33,11 @@ HtmlRoot {
 0: HTML_ROOT@0..21
   0: (empty)
   1: (empty)
-  2: HTML_ELEMENT_LIST@0..0
-  3: EOF@0..21 "" [Comments("<!-- Hello World -->"), Newline("\n")] []
+  2: HTML_ELEMENT_LIST@0..20
+    0: HTML_COMMENT@0..20
+      0: COMMENT_START@0..4 "<!--" [] []
+      1: HTML_LITERAL@4..17 " Hello World " [] []
+      2: COMMENT_END@17..20 "-->" [] []
+  3: EOF@20..21 "" [Newline("\n")] []
 
 ```