feat(format/html): implement suppression comments

Author: dyc3

crates/biome_formatter/src/trivia.rs

@@ -530,6 +530,8 @@ impl<L: Language> FormatSkippedTokenTrivia<'_, L> {
     where
         Context: CstFormatContext<Language = L>,
     {
+        dbg!("FormatSkippedTokenTrivia");
+
         // Lines/spaces before the next token/comment
         let (mut lines, mut spaces) = match self.token.prev_token() {
             Some(token) => {

crates/biome_html_factory/src/generated/node_factory.rs

@@ -8,7 +8,7 @@ use biome_formatter::{
     prelude::*,
     write,
 };
-use biome_html_syntax::HtmlLanguage;
+use biome_html_syntax::{HtmlLanguage, HtmlSyntaxKind};
 use biome_rowan::{SyntaxTriviaPieceComments, TextLen};
 use biome_suppression::parse_suppression_comment;
 
@@ -96,10 +96,29 @@ impl CommentStyle for HtmlCommentStyle {
         CommentKind::Block
     }
 
+    /// This allows us to override which comments are associated with which nodes.
+    ///
+    /// While every comment is directly attached to a **syntax token**, Biome actually builds a map of comments to **syntax nodes** separately. This map lives in [`HtmlComments`]. This is so that we can easily look up comments that are associated with a specific node. It's part of how suppression comments are handled.
+    ///
+    /// This method specifically, however, lets us fine tune which comments are associated with which nodes. This is useful when the default heuristic fails.
     fn place_comment(
         &self,
         comment: DecoratedComment<Self::Language>,
     ) -> CommentPlacement<Self::Language> {
+        // Fix trailing comments that are right before EOF being assigned to the wrong node.
+        //
+        // The issue is demonstrated in the example below.
+        // ```html
+        // Foo
+        //
+        // <!-- This comment gets assigned to the text node, despite it being actually attached to the EOF token. -->
+        // ```
+        if let Some(token) = comment.following_token() {
+            if token.kind() == HtmlSyntaxKind::EOF {
+                return CommentPlacement::trailing(comment.enclosing_node().clone(), comment);
+            }
+        }
+
         CommentPlacement::Default(comment)
     }
 }

crates/biome_html_factory/src/generated/syntax_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_formatter/src/comments.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

@@ -1,24 +1,26 @@
 use crate::prelude::*;
 use biome_formatter::write;
-use biome_html_syntax::HtmlRoot;
+use biome_html_syntax::{HtmlRoot, HtmlRootFields};
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatHtmlRoot;
 impl FormatNodeRule<HtmlRoot> for FormatHtmlRoot {
     fn fmt_fields(&self, node: &HtmlRoot, f: &mut HtmlFormatter) -> FormatResult<()> {
-        if let Some(bom) = node.bom_token() {
-            bom.format().fmt(f)?;
-        }
-        if let Some(directive) = node.directive() {
-            directive.format().fmt(f)?;
-        }
+        let HtmlRootFields {
+            bom_token,
+            directive,
+            html,
+            eof_token,
+        } = node.as_fields();
 
-        node.html().format().fmt(f)?;
-
-        if let Ok(eof) = node.eof_token() {
-            eof.format().fmt(f)?;
-        }
-        write!(f, [hard_line_break()])?;
-
-        Ok(())
+        write!(
+            f,
+            [
+                bom_token.format(),
+                directive.format(),
+                html.format(),
+                hard_line_break(),
+                format_removed(&eof_token?),
+            ]
+        )
     }
 }

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

@@ -62,15 +62,17 @@ impl FormatRule<HtmlElementList> for FormatHtmlElementList {
         let result = self.fmt_children(node, f)?;
         match result {
             FormatChildrenResult::ForceMultiline(format_multiline) => {
-                write!(f, [format_multiline])
+                write!(f, [format_multiline])?;
             }
             FormatChildrenResult::BestFitting {
                 flat_children,
                 expanded_children,
             } => {
-                write!(f, [best_fitting![flat_children, expanded_children]])
+                write!(f, [best_fitting![flat_children, expanded_children]])?;
             }
         }
+
+        Ok(())
     }
 }
 
@@ -113,8 +115,6 @@ impl FormatHtmlElementList {
         list: &HtmlElementList,
         f: &mut HtmlFormatter,
     ) -> FormatResult<FormatChildrenResult> {
-        self.disarm_debug_assertions(list, f);
-
         let borrowed_opening_r_angle = self
             .borrowed_tokens
             .borrowed_opening_r_angle
@@ -147,7 +147,7 @@ impl FormatHtmlElementList {
 
         let mut force_multiline = layout.is_multiline();
 
-        let mut children = html_split_children(list.iter(), f.context().comments())?;
+        let mut children = html_split_children(list.iter(), f)?;
 
         // Trim trailing new lines
         if let Some(HtmlChild::EmptyLine | HtmlChild::Newline) = children.last() {
@@ -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!(
@@ -191,6 +196,8 @@ impl FormatHtmlElementList {
                                 is_element_whitespace_sensitive_from_element(f, next_child),
                         }),
 
+                        Some(HtmlChild::Verbatim(_)) => None,
+
                         Some(HtmlChild::Newline | HtmlChild::Whitespace | HtmlChild::EmptyLine) => {
                             None
                         }
@@ -210,6 +217,20 @@ impl FormatHtmlElementList {
                     }
                 }
 
+                HtmlChild::Comment(comment) => {
+                    // FIXME: definitely wrong behavior
+                    let memoized = comment.memoized();
+                    flat.write(&format_args![memoized], f);
+                    multiline.write_content(&format_args![memoized], f);
+                }
+
+                HtmlChild::Verbatim(element) => {
+                    multiline.write_content(&format_verbatim_skipped(element.syntax()), f);
+                    // we have to force multiline mode because the verbatim element can contain newlines.
+                    // since we are always going to end up in multiline mode, we can also skip writing this element to the `flat` builder.
+                    force_multiline = true;
+                }
+
                 // * 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 +336,10 @@ impl FormatHtmlElementList {
                             }
                         }
 
+                        Some(HtmlChild::Comment(_)) | Some(HtmlChild::Verbatim(_)) => {
+                            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.
@@ -423,36 +448,6 @@ 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
-    /// [HtmlContent] and instead, formats the nodes itself.
-    #[cfg(debug_assertions)]
-    fn disarm_debug_assertions(&self, node: &HtmlElementList, f: &mut HtmlFormatter) {
-        use AnyHtmlElement::*;
-        use biome_formatter::CstFormatContext;
-
-        for child in node {
-            match child {
-                HtmlContent(text) => {
-                    f.state_mut().track_token(&text.value_token().unwrap());
-
-                    // You can't suppress a text node
-                    f.context()
-                        .comments()
-                        .mark_suppression_checked(text.syntax());
-                }
-                _ => {
-                    continue;
-                }
-            }
-        }
-    }
-
-    #[cfg(not(debug_assertions))]
-    fn disarm_debug_assertions(&self, _: &HtmlElementList, _: &mut HtmlFormatter) {}
-
     fn layout(&self, meta: ChildrenMeta) -> HtmlChildListLayout {
         match self.layout {
             HtmlChildListLayout::BestFitting => {
@@ -524,6 +519,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 +569,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,