feat(formatter): remove FormatElement::LocatedTokenText (#15367)

The last usage has been removed in #15366, and it is no longer useful to us, so remove it.

The performance gains from the `FormatElement` enum, as its size has been reduced from `40` to `24`.

Author: Dunqing

crates/oxc_formatter/src/formatter/builders.rs

@@ -10,7 +10,7 @@ use oxc_span::{GetSpan, Span};
 use oxc_syntax::identifier::{is_line_terminator, is_white_space_single_line};
 
 use super::{
-    Argument, Arguments, Buffer, Comments, GroupId, TextSize, TokenText, VecBuffer,
+    Argument, Arguments, Buffer, Comments, GroupId, TextSize, VecBuffer,
     format_element::{
         self,
         tag::{Condition, Tag},
@@ -361,33 +361,6 @@ impl std::fmt::Debug for SyntaxTokenCowSlice<'_> {
     }
 }
 
-/// Copies a source text 1:1 into the output text.
-pub fn located_token_text(span: Span, source_text: &str) -> LocatedTokenText {
-    let slice = span.source_text(source_text);
-    debug_assert_no_newlines(slice);
-    LocatedTokenText { text: TokenText::new(slice.to_string(), span), source_position: span.start }
-}
-
-pub struct LocatedTokenText {
-    text: TokenText,
-    source_position: TextSize,
-}
-
-impl Format<'_> for LocatedTokenText {
-    fn fmt(&self, f: &mut Formatter) -> FormatResult<()> {
-        f.write_element(FormatElement::LocatedTokenText {
-            slice: self.text.clone(),
-            source_position: self.source_position,
-        })
-    }
-}
-
-impl std::fmt::Debug for LocatedTokenText {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::write!(f, "LocatedTokenText({})", self.text)
-    }
-}
-
 #[track_caller]
 fn debug_assert_no_newlines(text: &str) {
     debug_assert!(

crates/oxc_formatter/src/formatter/format_element/document.rs

@@ -120,7 +120,6 @@ impl Document<'_> {
                     }
                     // `FormatElement::Token` cannot contain line breaks
                     FormatElement::Text { text, .. } => text.contains('\n'),
-                    FormatElement::LocatedTokenText { slice, .. } => slice.contains('\n'),
                     FormatElement::ExpandParent
                     | FormatElement::Line(LineMode::Hard | LineMode::Empty) => true,
                     _ => false,
@@ -195,8 +194,7 @@ impl<'a> Format<'a> for &[FormatElement<'a>] {
                 element @ (FormatElement::Space
                 | FormatElement::HardSpace
                 | FormatElement::Token { .. }
-                | FormatElement::Text { .. }
-                | FormatElement::LocatedTokenText { .. }) => {
+                | FormatElement::Text { .. }) => {
                     if !in_text {
                         write!(f, [token("\"")])?;
                     }
@@ -218,12 +216,6 @@ impl<'a> Format<'a> for &[FormatElement<'a>] {
                                         text: f.context().allocator().alloc_str(&text),
                                     }
                                 }
-                                FormatElement::LocatedTokenText { slice, source_position } => {
-                                    let text = slice.cow_replace('"', "\\\"");
-                                    FormatElement::Text {
-                                        text: f.context().allocator().alloc_str(&text),
-                                    }
-                                }
                                 _ => unreachable!(),
                             };
                             f.write_element(new_element)?;

crates/oxc_formatter/src/formatter/format_element/mod.rs

@@ -1,17 +1,32 @@
 pub mod document;
 pub mod tag;
 
-// use biome_rowan::TokenText;
 // #[cfg(target_pointer_width = "64")]
 // use biome_rowan::static_assert;
 use std::hash::{Hash, Hasher};
 use std::{borrow::Cow, ops::Deref, rc::Rc};
 
 use super::{
-    TagKind, TextSize, TokenText,
+    TagKind, TextSize,
     format_element::tag::{LabelId, Tag},
 };
 
+#[cfg(debug_assertions)]
+const _: () = {
+    assert!(
+        std::mem::size_of::<FormatElement>() == 40,
+        "`FormatElement` size exceeds 40 bytes, expected 40 bytes"
+    );
+};
+
+#[cfg(not(debug_assertions))]
+const _: () = {
+    assert!(
+        std::mem::size_of::<FormatElement>() == 24,
+        "`FormatElement` size exceeds 24 bytes, expected 24 bytes"
+    );
+};
+
 /// Language agnostic IR for formatting source code.
 ///
 /// Use the helper functions like [crate::builders::space], [crate::builders::soft_line_break] etc. defined in this file to create elements.
@@ -36,15 +51,6 @@ pub enum FormatElement<'a> {
         text: &'a str,
     },
 
-    /// A token for a text that is taken as is from the source code (input text and formatted representation are identical).
-    /// Implementing by taking a slice from a `SyntaxToken` to avoid allocating a new string.
-    LocatedTokenText {
-        /// The start position of the token in the unformatted source code
-        source_position: TextSize,
-        /// The token text
-        slice: TokenText,
-    },
-
     /// Prevents that line suffixes move past this boundary. Forces the printer to print any pending
     /// line suffixes, potentially by inserting a hard line break.
     LineSuffixBoundary,
@@ -69,9 +75,6 @@ impl std::fmt::Debug for FormatElement<'_> {
             FormatElement::ExpandParent => fmt.write_str("ExpandParent"),
             FormatElement::Token { text } => fmt.debug_tuple("Token").field(text).finish(),
             FormatElement::Text { text, .. } => fmt.debug_tuple("Text").field(text).finish(),
-            FormatElement::LocatedTokenText { slice, .. } => {
-                fmt.debug_tuple("LocatedTokenText").field(slice).finish()
-            }
             FormatElement::LineSuffixBoundary => fmt.write_str("LineSuffixBoundary"),
             FormatElement::BestFitting(best_fitting) => {
                 fmt.debug_tuple("BestFitting").field(&best_fitting).finish()
@@ -217,12 +220,7 @@ impl FormatElement<'_> {
     }
 
     pub const fn is_text(&self) -> bool {
-        matches!(
-            self,
-            FormatElement::LocatedTokenText { .. }
-                | FormatElement::Text { .. }
-                | FormatElement::Token { .. }
-        )
+        matches!(self, FormatElement::Text { .. } | FormatElement::Token { .. })
     }
 
     pub const fn is_space(&self) -> bool {
@@ -241,7 +239,6 @@ impl FormatElements for FormatElement<'_> {
             FormatElement::Tag(Tag::StartGroup(group)) => !group.mode().is_flat(),
             FormatElement::Line(line_mode) => line_mode.will_break(),
             FormatElement::Text { text } => text.contains('\n'),
-            FormatElement::LocatedTokenText { slice, .. } => slice.contains('\n'),
             FormatElement::Interned(interned) => interned.will_break(),
             // Traverse into the most flat version because the content is guaranteed to expand when even
             // the most flat version contains some content that forces a break.

crates/oxc_formatter/src/formatter/mod.rs

@@ -43,7 +43,6 @@ mod text_len;
 mod text_range;
 mod text_size;
 pub mod token;
-mod token_text;
 pub mod trivia;
 mod verbatim;
 
@@ -74,7 +73,6 @@ pub use self::{
     text_len::TextLen,
     text_range::TextRange,
     text_size::TextSize,
-    token_text::TokenText,
 };
 use self::{format_element::document::Document, group_id::UniqueGroupIdBuilder, prelude::TagKind};
 

crates/oxc_formatter/src/formatter/printer/mod.rs

@@ -97,9 +97,6 @@ impl<'a> Printer<'a> {
             FormatElement::Text { text } => {
                 self.print_text(Text::Text(text));
             }
-            FormatElement::LocatedTokenText { slice, source_position } => {
-                self.print_text(Text::Text(slice));
-            }
             FormatElement::Line(line_mode) => {
                 if args.mode().is_flat() {
                     match line_mode {
@@ -1027,9 +1024,6 @@ impl<'a, 'print> FitsMeasurer<'a, 'print> {
             FormatElement::Text { text, .. } => {
                 return Ok(self.fits_text(Text::Text(text)));
             }
-            FormatElement::LocatedTokenText { slice, .. } => {
-                return Ok(self.fits_text(Text::Text(slice)));
-            }
 
             FormatElement::LineSuffixBoundary => {
                 if self.state.has_line_suffix {

crates/oxc_formatter/src/formatter/token_text.rs

@@ -132,7 +132,6 @@ impl SortableImport {
 
         // Strip quotes and params
         let source = match &elements[*source_idx] {
-            FormatElement::LocatedTokenText { slice, .. } => slice,
             FormatElement::Text { text } => *text,
             _ => unreachable!(
                 "`source_idx` must point to either `LocatedTokenText` or `Text` in the `elements`."

crates/oxc_formatter/src/ir_transform/sort_imports/import_unit.rs

@@ -123,8 +123,7 @@ impl SourceLine {
                                     "{" => has_named_specifier = true,
                                     _ => {}
                                 },
-                                FormatElement::LocatedTokenText { .. }
-                                | FormatElement::Text { .. } => {
+                                FormatElement::Text { .. } => {
                                     has_default_specifier = true;
                                 }
                                 _ => {}
@@ -138,7 +137,7 @@ impl SourceLine {
                     }
                     _ => {}
                 },
-                FormatElement::LocatedTokenText { .. } | FormatElement::Text { .. } => {
+                FormatElement::Text { .. } => {
                     if source_idx.is_none() {
                         source_idx = Some(idx);
                     }