feat(rome_js_formatter): add format element label

crates/rome_formatter/src/builders.rs

@@ -523,6 +523,90 @@ impl<Context> std::fmt::Debug for FormatComment<'_, Context> {
     }
 }
 
+/// Marks some content with a label.
+///
+/// This does not directly influence how this content will be printed, but some
+/// parts of the formatter may inspect the `FormatElement::Label` and chose to handle this element in a specific way
+///
+/// # Example
+///
+/// ```rust
+/// use rome_formatter::prelude::*;
+/// use rome_formatter::{format, write, LabelId};
+///
+/// enum SomeLabelId {}
+///
+/// #[derive(Default)]
+/// struct Labelled;
+///
+/// impl Format<SimpleFormatContext> for Labelled {
+///     fn fmt(&self, f: &mut Formatter<SimpleFormatContext>) -> FormatResult<()> {
+///         let label_id = LabelId::of::<SomeLabelId>();
+///
+///         write!(f, [labelled(label_id, &token("labelled"))])?;
+///         Ok(())
+///     }
+/// }
+///
+/// let content = format_with(|f| {
+///     let mut labelled = Labelled::default().memoized();
+///     let labelled_content = labelled.inspect(f)?;
+///     let label_id = LabelId::of::<SomeLabelId>();
+///
+///     let is_labelled = match labelled_content {
+///         FormatElement::Label(labelled) => labelled.label_id() == label_id,
+///         _ => false,
+///     };
+///
+///     if is_labelled {
+///         write!(f, [token("This is "), &labelled])
+///     } else {
+///         write!(f, [token("This is not "), &labelled])
+///     }
+/// });
+///
+/// let formatted = format!(SimpleFormatContext::default(), [content]).unwrap();
+/// assert_eq!("This is labelled", formatted.print().as_code())
+/// ```
+#[inline]
+pub fn labelled<Content, Context>(label_id: LabelId, content: &Content) -> FormatLabelled<Context>
+where
+    Content: Format<Context>,
+{
+    FormatLabelled {
+        label_id,
+        content: Argument::new(content),
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct FormatLabelled<'a, Context> {
+    label_id: LabelId,
+    content: Argument<'a, Context>,
+}
+
+impl<Context> Format<Context> for FormatLabelled<'_, 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();
+
+        let label = Label::new(self.label_id, content);
+
+        f.write_element(FormatElement::Label(label))
+    }
+}
+
+impl<Context> std::fmt::Debug for FormatLabelled<'_, Context> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Label")
+            .field(&self.label_id)
+            .field(&"{{content}}")
+            .finish()
+    }
+}
+
 /// Inserts a single space. Allows to separate different tokens.
 ///
 /// # Examples

crates/rome_formatter/src/format_element.rs

@@ -2,6 +2,9 @@ use crate::{GroupId, TextSize};
 #[cfg(target_pointer_width = "64")]
 use rome_rowan::static_assert;
 use rome_rowan::SyntaxTokenText;
+#[cfg(debug_assertions)]
+use std::any::type_name;
+use std::any::TypeId;
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
 use std::ops::Deref;
@@ -70,6 +73,11 @@ pub enum FormatElement {
     /// An interned format element. Useful when the same content must be emitted multiple times to avoid
     /// deep cloning the IR when using the `best_fitting!` macro or `if_group_fits_on_line` and `if_group_breaks`.
     Interned(Interned),
+
+    /// Special semantic element marking the content with a label.
+    /// This does not directly influence how the content will be printed.
+    /// See [crate::labelled] for documentation.
+    Label(Label),
 }
 
 #[derive(Clone, Copy, Eq, PartialEq, Debug)]
@@ -150,6 +158,10 @@ impl Debug for FormatElement {
             }
             FormatElement::ExpandParent => write!(fmt, "ExpandParent"),
             FormatElement::Interned(inner) => inner.fmt(fmt),
+            FormatElement::Label(label) => {
+                write!(fmt, "Label")?;
+                label.fmt(fmt)
+            }
         }
     }
 }
@@ -352,6 +364,51 @@ impl Deref for Interned {
     }
 }
 
+#[derive(Eq, PartialEq, Copy, Clone, Debug)]
+pub struct LabelId {
+    id: TypeId,
+    #[cfg(debug_assertions)]
+    label: &'static str,
+}
+
+impl LabelId {
+    pub fn of<T: ?Sized + 'static>() -> Self {
+        Self {
+            id: TypeId::of::<T>(),
+            #[cfg(debug_assertions)]
+            label: type_name::<T>(),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Label {
+    pub(crate) content: Box<[FormatElement]>,
+    label_id: LabelId,
+}
+
+impl Label {
+    pub fn new(label_id: LabelId, content: Vec<FormatElement>) -> Self {
+        Self {
+            content: content.into_boxed_slice(),
+            label_id,
+        }
+    }
+
+    pub fn label_id(&self) -> LabelId {
+        self.label_id
+    }
+}
+
+impl Debug for Label {
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        fmt.debug_struct("")
+            .field("label_id", &self.label_id)
+            .field("content", &self.content)
+            .finish()
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ConditionalGroupContent {
     pub(crate) content: Content,
@@ -513,6 +570,7 @@ impl FormatElement {
             | FormatElement::Comment(content)
             | FormatElement::Fill(Fill { content, .. })
             | FormatElement::Verbatim(Verbatim { content, .. })
+            | FormatElement::Label(Label { content, .. })
             | FormatElement::Indent(content) => content.iter().any(FormatElement::will_break),
             FormatElement::List(list) => list.content.iter().any(FormatElement::will_break),
             FormatElement::Token(token) => token.contains('\n'),

crates/rome_formatter/src/lib.rs

@@ -47,12 +47,14 @@ pub use arguments::{Argument, Arguments};
 pub use buffer::{Buffer, BufferExtensions, BufferSnapshot, Inspect, PreambleBuffer, VecBuffer};
 pub use builders::{
     block_indent, comment, empty_line, get_lines_before, group_elements, hard_line_break,
-    if_group_breaks, if_group_fits_on_line, indent, line_suffix, soft_block_indent,
+    if_group_breaks, if_group_fits_on_line, indent, labelled, line_suffix, soft_block_indent,
     soft_line_break, soft_line_break_or_space, soft_line_indent_or_space, space_token, token,
     BestFitting,
 };
 pub use comments::{CommentContext, CommentKind, SourceComment};
-pub use format_element::{normalize_newlines, FormatElement, Token, Verbatim, LINE_TERMINATORS};
+pub use format_element::{
+    normalize_newlines, FormatElement, LabelId, Token, Verbatim, LINE_TERMINATORS,
+};
 pub use group_id::GroupId;
 use indexmap::IndexSet;
 use rome_rowan::{

crates/rome_formatter/src/printer/mod.rs

@@ -285,6 +285,12 @@ impl<'a> Printer<'a> {
                 }
             }
             FormatElement::Interned(content) => queue.enqueue(PrintElementCall::new(content, args)),
+            FormatElement::Label(label) => queue.extend(
+                label
+                    .content
+                    .iter()
+                    .map(|element| PrintElementCall::new(element, args)),
+            ),
         }
     }
 
@@ -819,6 +825,7 @@ fn fits_element_on_line<'a, 'rest>(
             }
         }
         FormatElement::Interned(content) => queue.enqueue(PrintElementCall::new(content, args)),
+        FormatElement::Label(label) => queue.extend(label.content.iter(), args),
     }
 
     Fits::Maybe