perf(es/parser): Use SmartString as the buffer (#7033)

Author: kdy1

bindings/Cargo.lock

@@ -56,7 +56,7 @@ tracing-chrome = "0.5.0"
 tracing-futures = "0.2.5"
 tracing-subscriber = { version = "0.3.9", features = ["env-filter"] }
 
-swc_core = { version = "0.64.5", features = [
+swc_core = { version = "0.65.0", features = [
   "allocator_node",
   "ecma_ast",
   "common_concurrent",

bindings/binding_core_node/Cargo.toml

@@ -23,7 +23,7 @@ plugin = ["swc_core/plugin_transform_host_js"]
 anyhow = "1.0.66"
 serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.4.5"
-swc_core = { version = "0.64.5", features = [
+swc_core = { version = "0.65.0", features = [
   "common_perf",
   "binding_macro_wasm",
   "ecma_transforms",

bindings/binding_core_wasm/Cargo.toml

@@ -27,7 +27,7 @@ relative-path = "1.6.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["unbounded_depth"] }
 sourcemap = "6.2.2"
-swc_core = { version = "0.64.5", features = [
+swc_core = { version = "0.65.0", features = [
   "trace_macro",
   "common_concurrent",
   "base_concurrent",

bindings/swc_cli/Cargo.toml

@@ -834,14 +834,14 @@ fn f64_to_precision(value: f64, precision: usize) -> String {
             // iv, v
             m.push_str(&e.to_string());
 
-            return s + &m;
+            return s + &*m;
         }
     }
 
     // 11
     let e_inc = e + 1;
     if e_inc == p_i32 {
-        return s + &m;
+        return s + &*m;
     }
 
     // 12
@@ -855,7 +855,7 @@ fn f64_to_precision(value: f64, precision: usize) -> String {
     }
 
     // 14
-    s + &m
+    s + &*m
 }
 
 fn flt_str_to_exp(flt: &str) -> i32 {

crates/swc_ecma_minifier/src/compress/pure/evaluate.rs

@@ -707,7 +707,7 @@ impl SyntaxError {
                     token_list.join(" or ")
                 } else {
                     token_list[0..token_list.len() - 1].join(" , ")
-                        + &format!("or {}", token_list[token_list.len() - 1])
+                        + &*format!("or {}", token_list[token_list.len() - 1])
                 };
                 format!("Unexpected token. Did you mean {}?", did_you_mean).into()
             }

crates/swc_ecma_parser/src/error.rs

@@ -4,6 +4,7 @@ use std::{cell::RefCell, char, iter::FusedIterator, rc::Rc};
 
 use either::Either::{Left, Right};
 use smallvec::{smallvec, SmallVec};
+use smartstring::SmartString;
 use swc_atoms::{Atom, AtomGenerator};
 use swc_common::{comments::Comments, input::StringInput, BytePos, Span};
 use swc_ecma_ast::{op, EsVersion};
@@ -1080,7 +1081,7 @@ impl<'a> Lexer<'a> {
                     '\\' => {
                         raw.push(c);
 
-                        let mut wrapped = Raw(Some(String::new()));
+                        let mut wrapped = Raw(Some(Default::default()));
 
                         if let Some(chars) = l.read_escaped_char(&mut wrapped, false)? {
                             for c in chars {
@@ -1200,7 +1201,7 @@ impl<'a> Lexer<'a> {
         let start = self.cur_pos();
 
         let mut cooked = Ok(String::new());
-        let mut raw = String::new();
+        let mut raw = SmartString::new();
 
         while let Some(c) = self.cur() {
             if c == '`' || (c == '$' && self.peek() == Some('{')) {
@@ -1218,7 +1219,7 @@ impl<'a> Lexer<'a> {
                 // TODO: Handle error
                 return Ok(Template {
                     cooked: cooked.map(Atom::from),
-                    raw: Atom::new(raw),
+                    raw: Atom::new(&*raw),
                 });
             }
 

crates/swc_ecma_parser/src/lexer/mod.rs

@@ -6,6 +6,7 @@ use std::{borrow::Cow, fmt::Write};
 
 use either::Either;
 use num_bigint::BigInt as BigIntValue;
+use smartstring::{LazyCompact, SmartString};
 use swc_common::SyntaxContext;
 use tracing::trace;
 
@@ -45,8 +46,8 @@ impl<'a> Lexer<'a> {
         }
 
         let start = self.cur_pos();
-        let mut raw_val = String::new();
-        let mut raw_str = String::new();
+        let mut raw_val = SmartString::<LazyCompact>::new();
+        let mut raw_str = SmartString::<LazyCompact>::new();
 
         let val = if starts_with_dot {
             // first char is '.'
@@ -64,7 +65,7 @@ impl<'a> Lexer<'a> {
 
                 return Ok(Either::Right((
                     Box::new(s.into_value()),
-                    self.atoms.borrow_mut().intern(raw),
+                    self.atoms.borrow_mut().intern(&*raw),
                 )));
             }
 
@@ -85,7 +86,7 @@ impl<'a> Lexer<'a> {
                     if start.0 != self.last_pos().0 - 1 {
                         // `-1` is utf 8 length of `0`
                         return self.make_legacy_octal(start, 0f64).map(|value| {
-                            Either::Left((value, self.atoms.borrow_mut().intern(raw)))
+                            Either::Left((value, self.atoms.borrow_mut().intern(&*raw)))
                         });
                     }
                 } else {
@@ -114,7 +115,7 @@ impl<'a> Lexer<'a> {
                             });
 
                             return self.make_legacy_octal(start, val).map(|value| {
-                                Either::Left((value, self.atoms.borrow_mut().intern(raw)))
+                                Either::Left((value, self.atoms.borrow_mut().intern(&*raw)))
                             });
                         }
                     }
@@ -142,7 +143,7 @@ impl<'a> Lexer<'a> {
                 debug_assert!(self.cur().unwrap().is_ascii_digit());
             }
 
-            let mut raw = Raw(Some(String::new()));
+            let mut raw = Raw(Some(Default::default()));
             // Read numbers after dot
             let dec_val = self.read_int::<10>(0, &mut raw)?;
 
@@ -157,7 +158,7 @@ impl<'a> Lexer<'a> {
                 if raw_val.contains('_') {
                     Cow::Owned(raw_val.replace('_', ""))
                 } else {
-                    Cow::Borrowed(&raw_val)
+                    Cow::Borrowed(&*raw_val)
                 }
                 .parse()
                 .expect("failed to parse float using rust's impl")
@@ -195,7 +196,7 @@ impl<'a> Lexer<'a> {
                     true
                 };
 
-                let mut raw = Raw(Some(String::new()));
+                let mut raw = Raw(Some(Default::default()));
                 let exp = self.read_number_no_dot::<10>(&mut raw)?;
 
                 raw_str.push_str(&raw.0.take().unwrap());
@@ -216,7 +217,7 @@ impl<'a> Lexer<'a> {
                     if raw_val.contains('_') {
                         Cow::Owned(raw_val.replace('_', ""))
                     } else {
-                        Cow::Borrowed(&raw_val)
+                        Cow::Borrowed(&*raw_val)
                     }
                     .parse()
                     .expect("failed to parse float literal")
@@ -227,7 +228,10 @@ impl<'a> Lexer<'a> {
 
         self.ensure_not_ident()?;
 
-        Ok(Either::Left((val, self.atoms.borrow_mut().intern(raw_str))))
+        Ok(Either::Left((
+            val,
+            self.atoms.borrow_mut().intern(&*raw_str),
+        )))
     }
 
     /// Returns `Left(value)` or `Right(BigInt)`
@@ -313,7 +317,7 @@ impl<'a> Lexer<'a> {
     /// Returned bool is `true` is there was `8` or `9`.
     fn read_number_no_dot_as_str<const RADIX: u8, const FORMAT: u128>(
         &mut self,
-    ) -> LexResult<(f64, LazyBigInt<RADIX>, String, bool)> {
+    ) -> LexResult<(f64, LazyBigInt<RADIX>, SmartString<LazyCompact>, bool)> {
         debug_assert!(
             RADIX == 2 || RADIX == 8 || RADIX == 10 || RADIX == 16,
             "radix for read_number_no_dot should be one of 2, 8, 10, 16, but got {}",
@@ -324,7 +328,7 @@ impl<'a> Lexer<'a> {
         let mut non_octal = false;
         let mut read_any = false;
 
-        let mut raw = Raw(Some(String::new()));
+        let mut raw = Raw(Some(Default::default()));
 
         self.read_digits::<_, f64, RADIX>(
             |total, radix, v| {

crates/swc_ecma_parser/src/lexer/number.rs

@@ -4,6 +4,7 @@
 //! [babylon/util/identifier.js]:https://github.com/babel/babel/blob/master/packages/babylon/src/util/identifier.js
 use std::char;
 
+use smartstring::{LazyCompact, SmartString};
 use swc_common::{
     comments::{Comment, CommentKind},
     BytePos, Span, SyntaxContext,
@@ -21,7 +22,7 @@ use crate::{
 /// Collector for raw string.
 ///
 /// Methods of this struct is noop if the value is [None].
-pub(super) struct Raw(pub Option<String>);
+pub(super) struct Raw(pub Option<SmartString<LazyCompact>>);
 
 impl Raw {
     #[inline]