feat(format/html): implement suppression comments

Author: dyc3

crates/biome_html_factory/src/generated/node_factory.rs

@@ -189,44 +189,6 @@ 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<'_> {
-        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 {
-        FormatOwnedWithRule::new(
-            self,
-            crate::html::auxiliary::comment::FormatHtmlComment::default(),
-        )
-    }
-}
 impl FormatRule<biome_html_syntax::HtmlContent>
     for crate::html::auxiliary::content::FormatHtmlContent
 {

crates/biome_html_factory/src/generated/syntax_factory.rs

@@ -10,7 +10,6 @@ impl FormatRule<AnyHtmlElement> for FormatAnyHtmlElement {
         match node {
             AnyHtmlElement::HtmlBogusElement(node) => node.format().fmt(f),
             AnyHtmlElement::HtmlCdataSection(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/generated.rs

@@ -5,7 +5,6 @@ pub(crate) mod attribute_initializer_clause;
 pub(crate) mod attribute_name;
 pub(crate) mod cdata_section;
 pub(crate) mod closing_element;
-pub(crate) mod comment;
 pub(crate) mod content;
 pub(crate) mod directive;
 pub(crate) mod element;

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

@@ -181,6 +181,11 @@ impl FormatHtmlElementList {
                             Some(WordSeparator::BetweenWords)
                         }
 
+                        Some(HtmlChild::Comment(_)) => {
+                            // FIXME: probably not correct behavior here
+                            Some(WordSeparator::Lines(0))
+                        }
+
                         // Last word or last word before an element without any whitespace in between
                         Some(HtmlChild::NonText(next_child)) => Some(WordSeparator::EndOfText {
                             is_soft_line_break: !matches!(
@@ -210,6 +215,12 @@ impl FormatHtmlElementList {
                     }
                 }
 
+                HtmlChild::Comment(comment) => {
+                    // FIXME: definitely wrong behavior
+                    flat.write(&format_args![comment], f);
+                    multiline.write_content(comment, f);
+                }
+
                 // * Whitespace after the opening tag and before a meaningful text: `<div> a`
                 // * Whitespace before the closing tag: `a </div>`
                 // * Whitespace before an opening tag: `a <div>`
@@ -315,6 +326,11 @@ impl FormatHtmlElementList {
                             }
                         }
 
+                        Some(HtmlChild::Comment(_)) => {
+                            // FIXME: definitely wrong behavior here.
+                            Some(LineMode::Hard)
+                        }
+
                         // Add a hard line break if what comes after the element is not a text or is all whitespace
                         Some(HtmlChild::NonText(next_non_text)) => {
                             // In the case of the formatter using the multiline layout, we want to treat inline elements like we do words.
@@ -426,7 +442,7 @@ impl FormatHtmlElementList {
     /// Tracks the tokens of [HtmlContent] nodes to be formatted and
     /// asserts that the suppression comments are checked (they get ignored).
     ///
-    /// This is necessary because the formatting of [HtmlContentList] bypasses the node formatting for
+    /// This is necessary because the formatting of [HtmlElementList] bypasses the node formatting for
     /// [HtmlContent] and instead, formats the nodes itself.
     #[cfg(debug_assertions)]
     fn disarm_debug_assertions(&self, node: &HtmlElementList, f: &mut HtmlFormatter) {
@@ -524,6 +540,9 @@ enum WordSeparator {
     /// `a b`
     BetweenWords,
 
+    /// Seperator between 2 lines. Creates hard line breaks.
+    Lines(usize),
+
     /// A separator of a word at the end of a [HtmlText] element. Either because it is the last
     /// child in its parent OR it is right before the start of another child (element, expression, ...).
     ///
@@ -571,6 +590,11 @@ impl Format<HtmlFormatContext> for WordSeparator {
     fn fmt(&self, f: &mut Formatter<HtmlFormatContext>) -> FormatResult<()> {
         match self {
             WordSeparator::BetweenWords => soft_line_break_or_space().fmt(f),
+            WordSeparator::Lines(count) => match count {
+                0 => Ok(()),
+                1 => hard_line_break().fmt(f),
+                _ => empty_line().fmt(f),
+            },
             WordSeparator::EndOfText {
                 is_soft_line_break,
                 is_next_element_whitespace_sensitive,

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

@@ -6,7 +6,7 @@ use std::{
 use biome_formatter::{
     Buffer, Format, FormatElement, FormatResult, format_args, prelude::*, write,
 };
-use biome_html_syntax::AnyHtmlElement;
+use biome_html_syntax::{AnyHtmlElement, HtmlSyntaxNode};
 use biome_rowan::{SyntaxResult, TextLen, TextRange, TextSize, TokenText};
 
 use crate::{HtmlFormatter, comments::HtmlComments, context::HtmlFormatContext};
@@ -75,6 +75,11 @@ pub(crate) enum HtmlChild {
     /// A Single word in a HTML text. For example, the words for `a b\nc` are `[a, b, c]`
     Word(HtmlWord),
 
+    /// A comment in a HTML text.
+    ///
+    /// This is considered a seperate kind of "word" here because we must preserve whitespace between text and comments.
+    Comment(HtmlWord),
+
     /// A ` ` whitespace
     ///
     /// ```html
@@ -164,7 +169,7 @@ impl Format<HtmlFormatContext> for HtmlRawSpace {
 
 pub(crate) fn html_split_children<I>(
     children: I,
-    _comments: &HtmlComments,
+    comments: &HtmlComments,
 ) -> SyntaxResult<Vec<HtmlChild>>
 where
     I: IntoIterator<Item = AnyHtmlElement>,
@@ -179,6 +184,11 @@ where
                 // Keep track if there's any leading/trailing empty line, new line or whitespace
 
                 let value_token = text.value_token()?;
+                let node = HtmlSyntaxNode::from(text);
+                for comment in comments.leading_dangling_trailing_comments(&node) {
+                    // Manually mark these comments as formatted because they are. Because we override the formatting of text content in here, the formatter does not seem to recognize them as formatted.
+                    comment.mark_formatted();
+                }
                 let mut chunks = HtmlSplitChunksIterator::new(value_token.text()).peekable();
 
                 // Text starting with a whitespace
@@ -216,15 +226,41 @@ where
                     }
                 }
 
+                let mut prev_was_comment = false;
                 while let Some(chunk) = chunks.next() {
                     match chunk {
                         (_, HtmlTextChunk::Whitespace(whitespace)) => {
                             // Only handle trailing whitespace. Words must always be joined by new lines
-                            if chunks.peek().is_none() {
-                                if whitespace.contains('\n') {
-                                    builder.entry(HtmlChild::Newline);
-                                } else {
-                                    builder.entry(HtmlChild::Whitespace)
+                            let newlines = whitespace.chars().filter(|b| *b == '\n').count();
+                            match chunks.peek() {
+                                Some(&(_, HtmlTextChunk::Comment(_))) => {
+                                    // if the next chunk is a comment, preserve the whitespace
+                                    if newlines >= 2 {
+                                        builder.entry(HtmlChild::EmptyLine)
+                                    } else if newlines == 1 {
+                                        builder.entry(HtmlChild::Newline)
+                                    } else {
+                                        builder.entry(HtmlChild::Whitespace)
+                                    }
+                                }
+                                None => {
+                                    if newlines >= 1 {
+                                        builder.entry(HtmlChild::Newline)
+                                    } else {
+                                        builder.entry(HtmlChild::Whitespace)
+                                    }
+                                }
+                                _ => {
+                                    // if the previous chunk was a comment, we need to preserve the whitespace before the next chunk (which will never be whitespace).
+                                    if prev_was_comment {
+                                        if newlines >= 2 {
+                                            builder.entry(HtmlChild::EmptyLine)
+                                        } else if newlines == 1 {
+                                            builder.entry(HtmlChild::Newline)
+                                        } else {
+                                            builder.entry(HtmlChild::Whitespace)
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -237,7 +273,16 @@ where
 
                             builder.entry(HtmlChild::Word(HtmlWord::new(text, source_position)));
                         }
+                        (relative_start, HtmlTextChunk::Comment(word)) => {
+                            let text = value_token
+                                .token_text()
+                                .slice(TextRange::at(relative_start, word.text_len()));
+                            let source_position = value_token.text_range().start() + relative_start;
+
+                            builder.entry(HtmlChild::Comment(HtmlWord::new(text, source_position)));
+                        }
                     }
+                    prev_was_comment = matches!(chunk, (_, HtmlTextChunk::Comment(_)));
                 }
                 prev_was_content = true;
             }
@@ -321,6 +366,7 @@ impl HtmlSplitChildrenBuilder {
 enum HtmlTextChunk<'a> {
     Whitespace(&'a str),
     Word(&'a str),
+    Comment(&'a str),
 }
 
 /// Splits a text into whitespace only and non-whitespace chunks.
@@ -352,23 +398,54 @@ impl<'a> Iterator for HtmlSplitChunksIterator<'a> {
         self.position += char.text_len();
 
         let is_whitespace = matches!(char, ' ' | '\n' | '\t' | '\r');
+        let mut maybe_comment = char == '<';
+        let mut definitely_comment = false;
+        let mut seen_end_comment_chars = 0;
 
         while let Some(next) = self.chars.peek() {
-            let next_is_whitespace = matches!(next, ' ' | '\n' | '\t' | '\r');
+            if maybe_comment && !definitely_comment {
+                match (self.position - start, next) {
+                    (idx, '!') if idx == 1.into() => {}
+                    (idx, '-') if idx == 2.into() || idx == 3.into() => {}
+                    (idx, _) if idx == 4.into() => {
+                        definitely_comment = true;
+                    }
+                    _ => {
+                        maybe_comment = false;
+                    }
+                }
+            }
 
-            if is_whitespace != next_is_whitespace {
-                break;
+            if definitely_comment {
+                match (seen_end_comment_chars, next) {
+                    (0, '-') => seen_end_comment_chars += 1,
+                    (1, '-') => seen_end_comment_chars += 1,
+                    (2, '>') => seen_end_comment_chars += 1,
+                    _ => seen_end_comment_chars = 0,
+                }
+            } else {
+                let next_is_whitespace = matches!(next, ' ' | '\n' | '\t' | '\r');
+
+                if is_whitespace != next_is_whitespace {
+                    break;
+                }
             }
 
             self.position += next.text_len();
             self.chars.next();
+
+            if seen_end_comment_chars == 3 {
+                break;
+            }
         }
 
         let range = TextRange::new(start, self.position);
         let slice = &self.text[range];
 
         let chunk = if is_whitespace {
             HtmlTextChunk::Whitespace(slice)
+        } else if definitely_comment {
+            HtmlTextChunk::Comment(slice)
         } else {
             HtmlTextChunk::Word(slice)
         };

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

@@ -0,0 +1,5 @@
+<div>
+  Foo
+
+  <!-- Bar -->
+</div>

crates/biome_html_formatter/src/html/lists/element_list.rs

@@ -0,0 +1,3 @@
+Foo
+
+<!-- Bar -->

crates/biome_html_formatter/src/utils/children.rs

@@ -0,0 +1,5 @@
+<div>
+  <!-- Foo -->
+
+  Bar
+</div>

crates/biome_html_formatter/tests/specs/html/comments/after-text-inside-div.html

@@ -0,0 +1,3 @@
+<!-- Foo -->
+
+Bar