refactor(rome_formatter): Comments all in one

crates/rome_formatter/Cargo.toml

@@ -16,6 +16,11 @@ cfg-if = "1.0.0"
 indexmap = "1.8.2"
 schemars = { version = "0.8.10", optional = true }
 rustc-hash = "1.1.0"
+countme = "3.0.1"
+
+[dev-dependencies]
+rome_js_parser = { path = "../rome_js_parser"}
+rome_js_syntax = { path = "../rome_js_syntax" }
 
 [features]
 serde = ["dep:serde", "schemars", "rome_rowan/serde"]

crates/rome_formatter/src/builders.rs

@@ -1,15 +1,11 @@
 use crate::prelude::*;
-use crate::{
-    format_element, write, Argument, Arguments, BufferSnapshot, FormatState, GroupId, TextRange,
-    TextSize,
-};
+use crate::{format_element, write, Argument, Arguments, GroupId, TextRange, TextSize};
 use crate::{Buffer, VecBuffer};
 use rome_rowan::{Language, SyntaxNode, SyntaxToken, SyntaxTokenText, TextLen};
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::marker::PhantomData;
 use std::num::NonZeroU8;
-use std::ops::Deref;
 
 /// A line break that only gets printed if the enclosing `Group` doesn't fit on a single line.
 /// It's omitted if the enclosing `Group` fits on a single line.
@@ -457,73 +453,6 @@ impl<Context> Format<Context> for LineSuffixBoundary {
     }
 }
 
-/// Marks some content as a comment trivia.
-///
-/// This does not directly influence how this content will be printed, but some
-/// parts of the formatter may chose to handle this element in a specific way
-///
-/// ## Examples
-///
-/// ```
-/// use rome_formatter::{format, write, format_args};
-/// use rome_formatter::prelude::*;
-///
-/// let elements = format!(
-///     SimpleFormatContext::default(),
-///     [
-///         group(&format_args![
-///             comment(&format_args![text("// test"), hard_line_break()]),
-///             format_with(|f| {
-///                 write!(f, [
-///                     comment(&format_args![text("/* inline */"), hard_line_break()]).memoized(),
-///                     text("a"),
-///                     soft_line_break_or_space(),
-///                 ])
-///             }).memoized(),
-///             text("b"),
-///             soft_line_break_or_space(),
-///             text("c")
-///         ])
-///     ]
-/// ).unwrap();
-///
-/// assert_eq!(
-///     "// test\n/* inline */\na b c",
-///     elements.print().as_code()
-/// );
-/// ```
-#[inline]
-pub fn comment<Content, Context>(content: &Content) -> FormatComment<Context>
-where
-    Content: Format<Context>,
-{
-    FormatComment {
-        content: Argument::new(content),
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct FormatComment<'a, Context> {
-    content: Argument<'a, Context>,
-}
-
-impl<Context> Format<Context> for FormatComment<'_, Context> {
-    fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        let mut buffer = VecBuffer::new(f.state_mut());
-
-        buffer.write_fmt(Arguments::from(&self.content))?;
-        let content = buffer.into_vec();
-
-        f.write_element(FormatElement::Comment(content.into_boxed_slice()))
-    }
-}
-
-impl<Context> std::fmt::Debug for FormatComment<'_, Context> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Comment").field(&"{{content}}").finish()
-    }
-}
-
 /// Marks some content with a label.
 ///
 /// This does not directly influence how this content will be printed, but some
@@ -1307,7 +1236,7 @@ impl<Context> Format<Context> for Group<'_, Context> {
             return f.write_fmt(Arguments::from(&self.content));
         }
 
-        let mut buffer = GroupBuffer::new(f);
+        let mut buffer = VecBuffer::new(f.state_mut());
 
         buffer.write_fmt(Arguments::from(&self.content))?;
 
@@ -1322,9 +1251,7 @@ impl<Context> Format<Context> for Group<'_, Context> {
 
         let group = format_element::Group::new(content).with_id(self.group_id);
 
-        f.write_element(FormatElement::Group(group))?;
-
-        Ok(())
+        f.write_element(FormatElement::Group(group))
     }
 }
 
@@ -1338,154 +1265,6 @@ impl<Context> std::fmt::Debug for Group<'_, Context> {
     }
 }
 
-/// Custom buffer implementation for `GroupElements` that moves the leading comments out of the group
-/// to prevent that a leading line comment expands the token's enclosing group.
-///
-/// # Examples
-///
-/// ```javascript
-/// /* a comment */
-/// [1]
-/// ```
-///
-/// The `/* a comment */` belongs to the `[` group token that is part of a group wrapping the whole
-/// `[1]` expression. It's important that the comment `/* a comment */` gets moved out of the group element
-/// to avoid that the `[1]` group expands because of the line break inserted by the comment.
-struct GroupBuffer<'inner, Context> {
-    inner: &'inner mut dyn Buffer<Context = Context>,
-
-    /// The group inner content
-    content: Vec<FormatElement>,
-}
-
-impl<'inner, Context> GroupBuffer<'inner, Context> {
-    fn new(inner: &'inner mut dyn Buffer<Context = Context>) -> Self {
-        Self {
-            inner,
-            content: Vec::new(),
-        }
-    }
-
-    fn into_vec(self) -> Vec<FormatElement> {
-        self.content
-    }
-
-    fn write_interned(&mut self, interned: Interned) -> FormatResult<()> {
-        debug_assert!(self.content.is_empty());
-
-        match interned.deref() {
-            FormatElement::Comment(_) => {
-                self.inner.write_element(FormatElement::Interned(interned))
-            }
-            FormatElement::List(list) => {
-                let mut content_start = 0;
-
-                for element in list.iter() {
-                    match element {
-                        element @ FormatElement::Comment(_) => {
-                            content_start += 1;
-                            // Cloning comments should be alright as they are rarely nested
-                            // and the case where all elements of an interned data structure are comments
-                            // are rare
-                            self.inner.write_element(element.clone())?;
-                        }
-                        FormatElement::Interned(interned) => {
-                            self.write_interned(interned.clone())?;
-                            content_start += 1;
-
-                            if !self.content.is_empty() {
-                                // Interned struct contained non-comment
-                                break;
-                            }
-                        }
-                        _ => {
-                            // Found the first non-comment / nested interned element
-                            break;
-                        }
-                    }
-                }
-
-                // No leading comments, this group has no comments
-                if content_start == 0 {
-                    self.content.push(FormatElement::Interned(interned));
-                    return Ok(());
-                }
-
-                let content = &list[content_start..];
-
-                // It is necessary to mutate the interned elements, write cloned elements
-                self.write_elements(content.iter().cloned())
-            }
-            FormatElement::Interned(interned) => self.write_interned(interned.clone()),
-            _ => {
-                self.content.push(FormatElement::Interned(interned));
-                Ok(())
-            }
-        }
-    }
-}
-
-impl<Context> Buffer for GroupBuffer<'_, Context> {
-    type Context = Context;
-
-    fn write_element(&mut self, element: FormatElement) -> FormatResult<()> {
-        if self.content.is_empty() {
-            match element {
-                FormatElement::List(list) => {
-                    self.write_elements(list.into_vec())?;
-                }
-                FormatElement::Interned(interned) => match Interned::try_unwrap(interned) {
-                    Ok(owned) => self.write_element(owned)?,
-                    Err(interned) => self.write_interned(interned)?,
-                },
-                comment @ FormatElement::Comment { .. } => {
-                    self.inner.write_element(comment)?;
-                }
-                element => self.content.push(element),
-            }
-        } else {
-            match element {
-                FormatElement::List(list) => {
-                    self.content.extend(list.into_vec());
-                }
-                element => self.content.push(element),
-            }
-        }
-
-        Ok(())
-    }
-
-    fn elements(&self) -> &[FormatElement] {
-        &self.content
-    }
-
-    fn state(&self) -> &FormatState<Self::Context> {
-        self.inner.state()
-    }
-
-    fn state_mut(&mut self) -> &mut FormatState<Self::Context> {
-        self.inner.state_mut()
-    }
-
-    fn snapshot(&self) -> BufferSnapshot {
-        BufferSnapshot::Any(Box::new(GroupElementsBufferSnapshot {
-            inner: self.inner.snapshot(),
-            content_len: self.content.len(),
-        }))
-    }
-
-    fn restore_snapshot(&mut self, snapshot: BufferSnapshot) {
-        let snapshot = snapshot.unwrap_any::<GroupElementsBufferSnapshot>();
-        self.inner.restore_snapshot(snapshot.inner);
-        self.content.truncate(snapshot.content_len);
-    }
-}
-
-struct GroupElementsBufferSnapshot {
-    inner: BufferSnapshot,
-    content_len: usize,
-}
-
 /// IR element that forces the parent group to print in expanded mode.
 ///
 /// Has no effect if used outside of a group or element that introduce implicit groups (fill element).
@@ -2213,9 +1992,9 @@ pub fn get_lines_before<L: Language>(next_node: &SyntaxNode<L>) -> usize {
         leading_trivia
             .pieces()
             .take_while(|piece| {
-                // Stop at the first comment piece, the comment printer
+                // Stop at the first comment or skipped piece, the comment printer
                 // will handle newlines between the comment and the node
-                !piece.is_comments()
+                !(piece.is_comments() || piece.is_skipped())
             })
             .filter(|piece| piece.is_newline())
             .count()