refactor(format): use specialised tokens

crates/biome_css_formatter/src/css/value/number.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 use biome_css_syntax::CssNumber;
-use biome_formatter::token::number::{NumberFormatOptions, format_number_token};
+use biome_formatter::token::number::NumberFormatOptions;
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatCssNumber;

crates/biome_css_formatter/src/css/value/regular_dimension.rs

@@ -1,9 +1,6 @@
 use crate::{prelude::*, utils::string_utils::FormatTokenAsLowercase};
 use biome_css_syntax::{CssRegularDimension, CssRegularDimensionFields};
-use biome_formatter::{
-    token::number::{NumberFormatOptions, format_number_token},
-    write,
-};
+use biome_formatter::{token::number::NumberFormatOptions, write};
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatCssRegularDimension;

crates/biome_css_formatter/src/lib.rs

@@ -7,6 +7,7 @@ mod cst;
 mod generated;
 mod prelude;
 mod separated;
+mod trivia;
 mod utils;
 mod verbatim;
 
@@ -17,13 +18,14 @@ pub(crate) use crate::context::CssFormatContext;
 use crate::context::CssFormatOptions;
 use crate::cst::FormatCssSyntaxNode;
 use crate::prelude::{format_bogus_node, format_suppressed_node};
+pub(crate) use crate::trivia::*;
 use biome_css_syntax::{
     AnyCssDeclarationBlock, AnyCssRule, AnyCssRuleBlock, AnyCssValue, CssLanguage, CssSyntaxKind,
     CssSyntaxNode, CssSyntaxToken,
 };
 use biome_formatter::comments::Comments;
 use biome_formatter::prelude::*;
-use biome_formatter::trivia::format_skipped_token_trivia;
+use biome_formatter::trivia::{FormatToken, format_skipped_token_trivia};
 use biome_formatter::{
     CstFormatContext, FormatContext, FormatLanguage, FormatOwnedWithRule, FormatRefWithRule,
     TransformSourceMap, write,
@@ -306,23 +308,33 @@ impl FormatRule<CssSyntaxToken> for FormatCssSyntaxToken {
     fn fmt(&self, token: &CssSyntaxToken, f: &mut Formatter<Self::Context>) -> FormatResult<()> {
         f.state_mut().track_token(token);
 
-        write!(f, [format_skipped_token_trivia(token)])?;
+        self.format_skipped_token_trivia(token, f)?;
 
         if token.kind().is_contextual_keyword() {
             let original = token.text_trimmed();
             match original.to_ascii_lowercase_cow() {
-                Cow::Borrowed(_) => write!(f, [format_trimmed_token(token)]),
+                Cow::Borrowed(_) => self.format_trimmed_token_trivia(token, f),
                 Cow::Owned(lowercase) => write!(
                     f,
                     [dynamic_text(&lowercase, token.text_trimmed_range().start())]
                 ),
             }
         } else {
-            write!(f, [format_trimmed_token(token)])
+            self.format_trimmed_token_trivia(token, f)
         }
     }
 }
 
+impl FormatToken<CssLanguage, CssFormatContext> for FormatCssSyntaxToken {
+    fn format_skipped_token_trivia(
+        &self,
+        token: &CssSyntaxToken,
+        f: &mut Formatter<CssFormatContext>,
+    ) -> FormatResult<()> {
+        format_skipped_token_trivia(token).fmt(f)
+    }
+}
+
 impl AsFormat<CssFormatContext> for CssSyntaxToken {
     type Format<'a> = FormatRefWithRule<'a, Self, FormatCssSyntaxToken>;
 

crates/biome_css_formatter/src/prelude.rs

@@ -5,7 +5,7 @@
 pub(crate) use crate::separated::FormatAstSeparatedListExtension;
 pub(crate) use crate::{
     AsFormat, CssFormatContext, CssFormatter, FormatNodeRule, FormattedIterExt as _, IntoFormat,
-    verbatim::*,
+    format_number_token, format_removed, format_replaced, on_removed, on_skipped, verbatim::*,
 };
 pub(crate) use biome_formatter::prelude::*;
 pub(crate) use biome_rowan::{

crates/biome_css_formatter/src/separated.rs

@@ -30,10 +30,11 @@ where
     }
 }
 
-type CssFormatSeparatedIter<Node> = FormatSeparatedIter<
+type CssFormatSeparatedIter<Node, C> = FormatSeparatedIter<
     AstSeparatedListElementsIterator<CssLanguage, Node>,
     Node,
     CssFormatSeparatedElementRule<Node>,
+    C,
 >;
 
 /// AST Separated list formatting extension methods
@@ -46,11 +47,16 @@ pub(crate) trait FormatAstSeparatedListExtension:
     /// calling the `separator_factory` function. The last trailing separator
     /// will not be printed by default. Use `with_trailing_separator` to add it
     /// in where necessary.
-    fn format_separated(&self, separator: &'static str) -> CssFormatSeparatedIter<Self::Node> {
+    fn format_separated(
+        &self,
+        separator: &'static str,
+    ) -> CssFormatSeparatedIter<Self::Node, CssFormatContext> {
         CssFormatSeparatedIter::new(
             self.elements(),
             separator,
             CssFormatSeparatedElementRule { node: PhantomData },
+            on_skipped,
+            on_removed,
         )
         .with_trailing_separator(TrailingSeparator::Disallowed)
     }
@@ -94,10 +100,11 @@ where
     }
 }
 
-type CssFormatSeparatedIterWithOptions<Node, Options> = FormatSeparatedIter<
+type CssFormatSeparatedIterWithOptions<Node, Options, C> = FormatSeparatedIter<
     AstSeparatedListElementsIterator<CssLanguage, Node>,
     Node,
     CssFormatSeparatedElementRuleWithOptions<Node, Options>,
+    C,
 >;
 
 /// AST Separated list formatting extension methods with options
@@ -115,11 +122,13 @@ pub(crate) trait FormatAstSeparatedListWithOptionsExtension<O>:
         &self,
         separator: &'static str,
         options: O,
-    ) -> CssFormatSeparatedIterWithOptions<Self::Node, O> {
+    ) -> CssFormatSeparatedIterWithOptions<Self::Node, O, CssFormatContext> {
         FormatSeparatedIter::new(
             self.elements(),
             separator,
             CssFormatSeparatedElementRuleWithOptions::new(options),
+            on_skipped,
+            on_removed,
         )
         .with_trailing_separator(TrailingSeparator::Disallowed)
     }

crates/biome_css_formatter/src/trivia.rs

@@ -0,0 +1,78 @@
+use crate::prelude::CssFormatContext;
+use crate::{CssFormatter, FormatCssSyntaxToken};
+use biome_css_syntax::CssSyntaxToken;
+use biome_formatter::formatter::Formatter;
+use biome_formatter::prelude::{
+    NumberFormatOptions, format_trimmed_number, syntax_token_cow_slice,
+};
+use biome_formatter::trivia::FormatToken;
+use biome_formatter::{Argument, Format, FormatResult};
+
+pub(crate) struct FormatRemoved<'a> {
+    token: &'a CssSyntaxToken,
+}
+
+pub(crate) fn format_removed(token: &CssSyntaxToken) -> FormatRemoved {
+    FormatRemoved { token }
+}
+
+impl<'a> Format<CssFormatContext> for FormatRemoved<'a> {
+    fn fmt(&self, f: &mut Formatter<CssFormatContext>) -> FormatResult<()> {
+        FormatCssSyntaxToken.format_removed(self.token, f)
+    }
+}
+
+pub(crate) struct FormatReplaced<'a> {
+    token: &'a CssSyntaxToken,
+    content: Argument<'a, CssFormatContext>,
+}
+
+pub(crate) fn format_replaced<'a>(
+    token: &'a CssSyntaxToken,
+    content: &'a impl Format<CssFormatContext>,
+) -> FormatReplaced<'a> {
+    FormatReplaced {
+        token,
+        content: Argument::new(content),
+    }
+}
+
+impl<'a> Format<CssFormatContext> for FormatReplaced<'a> {
+    fn fmt(&self, f: &mut Formatter<CssFormatContext>) -> FormatResult<()> {
+        FormatCssSyntaxToken.format_replaced(self.token, &self.content, f)
+    }
+}
+
+pub fn format_number_token(
+    token: &CssSyntaxToken,
+    options: NumberFormatOptions,
+) -> CleanedNumberLiteralText<'_> {
+    CleanedNumberLiteralText { token, options }
+}
+
+pub(crate) struct CleanedNumberLiteralText<'a> {
+    token: &'a CssSyntaxToken,
+    options: NumberFormatOptions,
+}
+
+impl Format<CssFormatContext> for CleanedNumberLiteralText<'_> {
+    fn fmt(&self, f: &mut CssFormatter) -> FormatResult<()> {
+        format_replaced(
+            self.token,
+            &syntax_token_cow_slice(
+                format_trimmed_number(self.token.text_trimmed(), self.options),
+                self.token,
+                self.token.text_trimmed_range().start(),
+            ),
+        )
+        .fmt(f)
+    }
+}
+
+pub(crate) fn on_skipped(token: &CssSyntaxToken, f: &mut CssFormatter) -> FormatResult<()> {
+    FormatCssSyntaxToken.format_skipped_token_trivia(token, f)
+}
+
+pub(crate) fn on_removed(token: &CssSyntaxToken, f: &mut CssFormatter) -> FormatResult<()> {
+    FormatCssSyntaxToken.format_removed(token, f)
+}

crates/biome_css_formatter/src/utils/string_utils.rs

@@ -10,7 +10,6 @@ use biome_formatter::token::string::normalize_string;
 use biome_formatter::{
     Format, FormatResult,
     prelude::{dynamic_text, write},
-    trivia::format_replaced,
 };
 use biome_rowan::SyntaxToken;
 use biome_string_case::StrLikeExtension;

crates/biome_formatter/src/comments.rs

@@ -158,19 +158,19 @@ impl CommentKind {
 #[derive(Debug, Clone)]
 pub struct SourceComment<L: Language> {
     /// The number of lines appearing before this comment
-    pub(crate) lines_before: u32,
+    pub lines_before: u32,
 
-    pub(crate) lines_after: u32,
+    pub lines_after: u32,
 
     /// The comment piece
-    pub(crate) piece: SyntaxTriviaPieceComments<L>,
+    pub piece: SyntaxTriviaPieceComments<L>,
 
     /// The kind of the comment.
-    pub(crate) kind: CommentKind,
+    pub kind: CommentKind,
 
     /// Whether the comment has been formatted or not.
     #[cfg(debug_assertions)]
-    pub(crate) formatted: Cell<bool>,
+    pub formatted: Cell<bool>,
 }
 
 impl<L: Language> SourceComment<L> {

crates/biome_formatter/src/lib.rs

@@ -54,7 +54,6 @@ use crate::format_element::document::Document;
 #[cfg(debug_assertions)]
 use crate::printed_tokens::PrintedTokens;
 use crate::printer::{Printer, PrinterOptions};
-use crate::trivia::{format_skipped_token_trivia, format_trimmed_token};
 pub use arguments::{Argument, Arguments};
 use biome_console::markup;
 use biome_deserialize::{
@@ -75,7 +74,6 @@ pub use builders::BestFitting;
 pub use format_element::{FormatElement, LINE_TERMINATORS, normalize_newlines};
 pub use group_id::GroupId;
 pub use source_map::{TransformSourceMap, TransformSourceMapBuilder};
-use std::marker::PhantomData;
 use std::num::ParseIntError;
 use std::str::FromStr;
 use token::string::Quote;
@@ -1131,43 +1129,6 @@ pub trait FormatRule<T> {
     fn fmt(&self, item: &T, f: &mut Formatter<Self::Context>) -> FormatResult<()>;
 }
 
-/// Default implementation for formatting a token
-pub struct FormatToken<C> {
-    context: PhantomData<C>,
-}
-
-impl<C> Default for FormatToken<C> {
-    fn default() -> Self {
-        Self {
-            context: PhantomData,
-        }
-    }
-}
-
-impl<C> FormatRule<SyntaxToken<C::Language>> for FormatToken<C>
-where
-    C: CstFormatContext,
-    C::Language: 'static,
-{
-    type Context = C;
-
-    fn fmt(
-        &self,
-        token: &SyntaxToken<C::Language>,
-        f: &mut Formatter<Self::Context>,
-    ) -> FormatResult<()> {
-        f.state_mut().track_token(token);
-
-        crate::write!(
-            f,
-            [
-                format_skipped_token_trivia(token),
-                format_trimmed_token(token),
-            ]
-        )
-    }
-}
-
 /// Rule that supports customizing how it formats an object of type `T`.
 pub trait FormatRuleWithOptions<T>: FormatRule<T> {
     type Options;

crates/biome_formatter/src/prelude.rs

@@ -4,13 +4,14 @@ pub use crate::format_extensions::{MemoizeFormat, Memoized};
 pub use crate::formatter::Formatter;
 pub use crate::printer::PrinterOptions;
 pub use crate::trivia::{
-    format_dangling_comments, format_leading_comments, format_only_if_breaks, format_removed,
-    format_replaced, format_trailing_comments, format_trimmed_token,
+    format_dangling_comments, format_leading_comments, format_only_if_breaks,
+    format_trailing_comments, should_nestle_adjacent_doc_comments,
 };
 
 pub use crate::diagnostics::FormatError;
 pub use crate::format_element::document::Document;
 pub use crate::format_element::tag::{LabelId, Tag, TagKind};
+pub use crate::token::number::{NumberFormatOptions, format_trimmed_number};
 
 pub use crate::{
     Buffer as _, BufferExtensions, Format, Format as _, FormatResult, FormatRule,