perf(es/fast-lexer): Optimize SIMD vector initialization with initialing u8x16 once. (#10183)

**Description:**

Improves performance and reduces repeated allocations by initialing `u8x16` in global to ensure constants u8x16 initial once.
    
- Simplifies SIMD vector creation using `u8x16::new()`
- Maintains the previous performance optimizations for lexer vector handling

Author: GiveMe-A-Name

crates/swc_ecma_fast_parser/src/lexer/cursor.rs

@@ -91,22 +91,22 @@ impl<'a> Cursor<'a> {
 
     /// Advance until the predicate returns false or EOF is reached
     #[inline]
-    pub fn advance_while<F>(&mut self, mut predicate: F) -> u32
+    pub fn advance_while<F>(&mut self, predicate: F) -> u32
     where
-        F: FnMut(u8) -> bool,
+        F: Fn(u8) -> bool,
     {
         let start = self.pos;
 
-        self.advance_while_scalar(&mut predicate);
+        self.advance_while_scalar(&predicate);
 
         self.pos - start
     }
 
     /// Scalar (non-SIMD) implementation of advance_while
     #[inline]
-    fn advance_while_scalar<F>(&mut self, predicate: &mut F)
+    fn advance_while_scalar<F>(&mut self, predicate: &F)
     where
-        F: FnMut(u8) -> bool,
+        F: Fn(u8) -> bool,
     {
         // Warning: Do not scalarize if we do not use SIMD
         // const BATCH_SIZE: u32 = 32;

crates/swc_ecma_fast_parser/src/lexer/mod.rs

@@ -104,6 +104,12 @@ const CHAR_HEX_DIGIT: u8 = 0b0010_0000;
 const CHAR_OPERATOR: u8 = 0b0100_0000;
 const CHAR_SPECIAL: u8 = 0b1000_0000;
 
+// SIMD vectors for common whitespace characters
+static SPACE_SIMD_VEC: u8x16 = u8x16::new([b' '; 16]);
+static TAB_SIMD_VEC: u8x16 = u8x16::new([b'\t'; 16]);
+static FORM_FEED_SMID_VEC: u8x16 = u8x16::new([0x0c; 16]);
+static VECR_TAB_SMID_VEC: u8x16 = u8x16::new([0x0b; 16]);
+
 // Extended lookup table for faster character checks (ASCII only)
 static ASCII_LOOKUP: [u8; 256] = {
     let mut table = [0u8; 256];
@@ -564,18 +570,12 @@ impl<'a> Lexer<'a> {
             _ => {}
         }
 
-        // Create SIMD vectors for common whitespace characters
-        let space_vec = u8x16::splat(b' ');
-        let tab_vec = u8x16::splat(b'\t');
-        let form_feed_vec = u8x16::splat(0x0c); // Form feed
-        let vert_tab_vec = u8x16::splat(0x0b); // Vertical tab
-
         // Fast path for regular whitespace (space, tab, form feed, vertical tab)
         // Compare with our whitespace vectors
-        let is_space = data.cmp_eq(space_vec);
-        let is_tab = data.cmp_eq(tab_vec);
-        let is_ff = data.cmp_eq(form_feed_vec);
-        let is_vt = data.cmp_eq(vert_tab_vec);
+        let is_space = data.cmp_eq(SPACE_SIMD_VEC);
+        let is_tab = data.cmp_eq(TAB_SIMD_VEC);
+        let is_ff = data.cmp_eq(FORM_FEED_SMID_VEC);
+        let is_vt = data.cmp_eq(VECR_TAB_SMID_VEC);
 
         // Combine masks for regular whitespace
         let is_basic_ws = is_space | is_tab | is_ff | is_vt;

crates/swc_ecma_fast_parser/src/lexer/string.rs

@@ -29,6 +29,11 @@ static ESCAPE_LOOKUP: [u8; 128] = {
     table
 };
 
+// SIMD vectors for common string end characters
+static BACKSLASH_SMID_VEC: u8x16 = u8x16::new([b'\\'; 16]);
+static NEWLINE_SMID_VEC: u8x16 = u8x16::new([b'\n'; 16]);
+static CARRIAGE_SMID_VEC: u8x16 = u8x16::new([b'\r'; 16]);
+
 // Buffer for string construction - using thread_local to avoid allocation
 thread_local! {
     static STRING_BUFFER: std::cell::RefCell<Vec<u8>> = std::cell::RefCell::new(Vec::with_capacity(1024));
@@ -220,6 +225,9 @@ impl Lexer<'_> {
 
         let mut pos = start_pos;
 
+        // Create vectors for quick comparison
+        let quote_vec = u8x16::splat(quote);
+
         // Process in chunks of 16 bytes using SIMD
         while pos + 16 <= rest.len() as u32 {
             // Load 16 bytes
@@ -228,18 +236,11 @@ impl Lexer<'_> {
             bytes.copy_from_slice(chunk_bytes);
             let chunk = u8x16::new(bytes);
 
-            // Create vectors for quick comparison
-            let quote_vec = u8x16::splat(quote);
-            let backslash_vec = u8x16::splat(b'\\');
-            let newline_vec = u8x16::splat(b'\n');
-            let carriage_vec = u8x16::splat(b'\r');
-
             // Check for presence of special characters with a single combined mask
             let quote_mask = chunk.cmp_eq(quote_vec);
-            let backslash_mask = chunk.cmp_eq(backslash_vec);
-            let newline_mask = chunk.cmp_eq(newline_vec);
-            let carriage_mask = chunk.cmp_eq(carriage_vec);
-
+            let backslash_mask = chunk.cmp_eq(BACKSLASH_SMID_VEC);
+            let newline_mask = chunk.cmp_eq(NEWLINE_SMID_VEC);
+            let carriage_mask = chunk.cmp_eq(CARRIAGE_SMID_VEC);
             // Combine all masks with OR operation
             let combined_mask = quote_mask | backslash_mask | newline_mask | carriage_mask;