refactor(parser): use StringBuilder instead of String

Author: overlookmotel

crates/oxc_parser/src/lexer/identifier.rs

@@ -1,6 +1,6 @@
 use std::cmp::max;
 
-use oxc_allocator::String;
+use oxc_allocator::StringBuilder;
 use oxc_span::Span;
 use oxc_syntax::identifier::{
     is_identifier_part, is_identifier_part_unicode, is_identifier_start_unicode,
@@ -136,7 +136,7 @@ impl<'a> Lexer<'a> {
     pub fn identifier_backslash_handler(&mut self) -> Kind {
         // Create arena string to hold unescaped identifier.
         // We don't know how long identifier will end up being, so guess.
-        let str = String::with_capacity_in(MIN_ESCAPED_STR_LEN, self.allocator);
+        let str = StringBuilder::with_capacity_in(MIN_ESCAPED_STR_LEN, self.allocator);
 
         // Process escape and get rest of identifier
         let id = self.identifier_on_backslash(str, true);
@@ -153,7 +153,7 @@ impl<'a> Lexer<'a> {
         // will be double what we've seen so far, or `MIN_ESCAPED_STR_LEN` minimum.
         let so_far = self.source.str_from_pos_to_current(start_pos);
         let capacity = max(so_far.len() * 2, MIN_ESCAPED_STR_LEN);
-        let mut str = String::with_capacity_in(capacity, self.allocator);
+        let mut str = StringBuilder::with_capacity_in(capacity, self.allocator);
 
         // Push identifier up this point into `str`
         str.push_str(so_far);
@@ -167,7 +167,11 @@ impl<'a> Lexer<'a> {
     /// `self.source` should be positioned *on* the `\` (i.e. `\` has not been consumed yet).
     /// `str` should contain the identifier up to before the escape.
     /// `is_start` should be `true` if this is first char in the identifier, `false` otherwise.
-    fn identifier_on_backslash(&mut self, mut str: String<'a>, mut is_start: bool) -> &'a str {
+    fn identifier_on_backslash(
+        &mut self,
+        mut str: StringBuilder<'a>,
+        mut is_start: bool,
+    ) -> &'a str {
         'outer: loop {
             // Consume `\`
             self.consume_char();
@@ -201,7 +205,7 @@ impl<'a> Lexer<'a> {
         }
 
         // Convert `str` to arena slice and save to `escaped_strings`
-        let id = str.into_bump_str();
+        let id = str.into_str();
         self.save_string(true, id);
         id
     }

crates/oxc_parser/src/lexer/string.rs

@@ -1,6 +1,6 @@
 use std::cmp::max;
 
-use oxc_allocator::String;
+use oxc_allocator::StringBuilder;
 
 use crate::diagnostics;
 
@@ -107,7 +107,7 @@ macro_rules! handle_string_literal_escape {
         // will be double what we've seen so far, or `MIN_ESCAPED_STR_LEN` minimum.
         let so_far = $lexer.source.str_from_pos_to_current($after_opening_quote);
         let capacity = max(so_far.len() * 2, MIN_ESCAPED_STR_LEN);
-        let mut str = String::with_capacity_in(capacity, $lexer.allocator);
+        let mut str = StringBuilder::with_capacity_in(capacity, $lexer.allocator);
 
         // Push chunk before `\` into `str`.
         str.push_str(so_far);
@@ -193,7 +193,7 @@ macro_rules! handle_string_literal_escape {
         }
 
         // Convert `str` to arena slice and save to `escaped_strings`
-        $lexer.save_string(true, str.into_bump_str());
+        $lexer.save_string(true, str.into_str());
 
         Kind::Str
     }};

crates/oxc_parser/src/lexer/template.rs

@@ -1,6 +1,6 @@
 use std::{cmp::max, str};
 
-use oxc_allocator::String;
+use oxc_allocator::StringBuilder;
 
 use crate::diagnostics;
 
@@ -194,14 +194,14 @@ impl<'a> Lexer<'a> {
     ///
     /// # SAFETY
     /// `pos` must not be before `self.source.position()`
-    unsafe fn template_literal_create_string(&self, pos: SourcePosition<'a>) -> String<'a> {
+    unsafe fn template_literal_create_string(&self, pos: SourcePosition<'a>) -> StringBuilder<'a> {
         // Create arena string to hold modified template literal.
         // We don't know how long template literal will end up being. Take a guess that total length
         // will be double what we've seen so far, or `MIN_ESCAPED_TEMPLATE_LIT_LEN` minimum.
         // SAFETY: Caller guarantees `pos` is not before `self.source.position()`.
         let so_far = unsafe { self.source.str_from_current_to_pos_unchecked(pos) };
         let capacity = max(so_far.len() * 2, MIN_ESCAPED_TEMPLATE_LIT_LEN);
-        let mut str = String::with_capacity_in(capacity, self.allocator);
+        let mut str = StringBuilder::with_capacity_in(capacity, self.allocator);
         str.push_str(so_far);
         str
     }
@@ -212,7 +212,7 @@ impl<'a> Lexer<'a> {
     /// `chunk_start` must not be after `pos`.
     unsafe fn template_literal_escaped(
         &mut self,
-        mut str: String<'a>,
+        mut str: StringBuilder<'a>,
         pos: SourcePosition<'a>,
         mut chunk_start: SourcePosition<'a>,
         mut is_valid_escape_sequence: bool,
@@ -379,7 +379,7 @@ impl<'a> Lexer<'a> {
             },
         };
 
-        self.save_template_string(is_valid_escape_sequence, str.into_bump_str());
+        self.save_template_string(is_valid_escape_sequence, str.into_str());
 
         ret
     }

crates/oxc_parser/src/lexer/unicode.rs

@@ -2,7 +2,7 @@ use std::{borrow::Cow, fmt::Write};
 
 use cow_utils::CowUtils;
 
-use oxc_allocator::String;
+use oxc_allocator::StringBuilder;
 use oxc_syntax::identifier::{
     CR, FF, LF, LS, PS, TAB, VT, is_identifier_part, is_identifier_start,
     is_identifier_start_unicode, is_irregular_line_terminator, is_irregular_whitespace,
@@ -61,7 +61,7 @@ impl<'a> Lexer<'a> {
     ///   \u{ `CodePoint` }
     pub(super) fn identifier_unicode_escape_sequence(
         &mut self,
-        str: &mut String<'a>,
+        str: &mut StringBuilder<'a>,
         check_identifier_start: bool,
     ) {
         let start = self.offset();
@@ -115,7 +115,7 @@ impl<'a> Lexer<'a> {
     ///   \u{ `CodePoint` }
     fn string_unicode_escape_sequence(
         &mut self,
-        text: &mut String<'a>,
+        text: &mut StringBuilder<'a>,
         is_valid_escape_sequence: &mut bool,
     ) {
         let value = match self.peek_byte() {
@@ -153,7 +153,7 @@ impl<'a> Lexer<'a> {
     }
 
     /// Lone surrogate found in string.
-    fn string_lone_surrogate(&mut self, code_point: u32, text: &mut String<'a>) {
+    fn string_lone_surrogate(&mut self, code_point: u32, text: &mut StringBuilder<'a>) {
         debug_assert!(code_point <= 0xFFFF);
 
         if !self.token.lone_surrogates() {
@@ -167,7 +167,7 @@ impl<'a> Lexer<'a> {
             // But strings containing both lone surrogates and lossy replacement characters
             // should be vanishingly rare, so don't bother.
             if let Cow::Owned(replaced) = text.cow_replace("\u{FFFD}", "\u{FFFD}fffd") {
-                *text = String::from_str_in(&replaced, self.allocator);
+                *text = StringBuilder::from_str_in(&replaced, self.allocator);
             }
         }
 
@@ -307,7 +307,7 @@ impl<'a> Lexer<'a> {
     // EscapeSequence ::
     pub(super) fn read_string_escape_sequence(
         &mut self,
-        text: &mut String<'a>,
+        text: &mut StringBuilder<'a>,
         in_template: bool,
         is_valid_escape_sequence: &mut bool,
     ) {
@@ -380,14 +380,14 @@ impl<'a> Lexer<'a> {
                                 // 192-255: `0xC3`, followed by code point value - 64.
                                 let bytes = [0xC0 + first_digit, value & 0b1011_1111];
                                 // SAFETY: `bytes` is a valid 2-byte UTF-8 sequence
-                                unsafe { text.as_mut_vec().extend_from_slice(&bytes) };
+                                unsafe { text.push_bytes_unchecked(&bytes) };
                                 return;
                             }
                         }
                     }
 
                     // SAFETY: `value` is in range 0 to `((1 * 8) + 7) * 8 + 7` (127) i.e. ASCII
-                    unsafe { text.as_mut_vec().push(value) };
+                    unsafe { text.push_byte_unchecked(value) };
                 }
                 '0' if in_template && self.peek_byte().is_some_and(|b| b.is_ascii_digit()) => {
                     self.consume_char();