perf(es/parser): Optimize byte_search! (#11323)

**Description:**

Align the implementation to oxc. In terms of swc, this pr reduces the calls of `bump_bytes`.

Author: CPunisher

.changeset/perfect-kids-sleep.md

@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_parser: patch
+---
+
+perf(es/parser): Optimize `byte_search!`

crates/swc_ecma_parser/src/lexer/mod.rs

@@ -754,6 +754,7 @@ impl<'a> Lexer<'a> {
         let slice_start = self.cur_pos();
 
         let had_line_break_before_last = self.had_line_break_before_last();
+        let mut had_line_break = false;
 
         byte_search! {
             lexer: self,
@@ -768,8 +769,8 @@ impl<'a> Lexer<'a> {
                             let bytes = current_slice.as_bytes();
                             let next2 = [bytes[byte_pos + 1], bytes[byte_pos + 2]];
                             if next2 == LS_BYTES_2_AND_3 || next2 == PS_BYTES_2_AND_3 {
-                                self.state_mut().mark_had_line_break();
-                                self.input_mut().bump_bytes(2);
+                                had_line_break = true;
+                                pos_offset += 2;
                             }
                         }
                         true
@@ -818,13 +819,16 @@ impl<'a> Lexer<'a> {
                                 }
                             }
 
+                            if had_line_break {
+                                self.state_mut().mark_had_line_break();
+                            }
                             return;
                         }
 
                         true
                     }
                     _ => {
-                        self.state_mut().mark_had_line_break();
+                        had_line_break = true;
                         true
                     },
                 }
@@ -836,6 +840,10 @@ impl<'a> Lexer<'a> {
                 return;
             }
         };
+
+        if had_line_break {
+            self.state_mut().mark_had_line_break();
+        }
     }
 
     /// Ensure that ident cannot directly follow numbers.

crates/swc_ecma_parser/src/lexer/search.rs

@@ -81,60 +81,66 @@ macro_rules! byte_search {
         handle_eof: $eof_handler:expr $(,)?
     ) => {{
         $table.use_table();
-        loop {
-            // Open a new scope so the immutable borrow (slice/bytes) ends before we
-            // call `bump_bytes`, which requires `&mut`.
-            let (found_idx, $byte) = {
-                let slice = $lexer.input().as_str();
-                if slice.is_empty() {
-                    $eof_handler
-                }
-                let bytes = slice.as_bytes();
-                let mut idx = 0usize;
-                let len = bytes.len();
-                let mut found: Option<(usize, u8)> = None;
-                while idx < len {
-                    let end = (idx + $crate::lexer::search::SEARCH_BATCH_SIZE).min(len);
-                    let mut i = idx;
-                    while i < end {
-                        let b = bytes[i];
-                        if $table.matches(b) {
-                            found = Some((i, b));
-                            break;
+        let mut $pos = 0;
+        let bytes = $lexer.input().as_str().as_bytes();
+        let len = bytes.len();
+        let bytes = bytes.as_ptr();
+
+        let $byte = 'outer: loop {
+            let batch_end = $pos + $crate::lexer::search::SEARCH_BATCH_SIZE;
+            let $byte = if batch_end < len {
+                // Safety: `batch_end < len`
+                let batch = unsafe {
+                    std::slice::from_raw_parts(
+                        bytes.add($pos),
+                        $crate::lexer::search::SEARCH_BATCH_SIZE,
+                    )
+                };
+                'inner: loop {
+                    for (i, &byte) in batch.iter().enumerate() {
+                        if $table.matches(byte) {
+                            // We find a matched byte, jump out to check with continue_if
+                            $pos += i;
+                            break 'inner byte;
                         }
-                        i += 1;
-                    }
-                    if found.is_some() {
-                        break;
                     }
-                    idx = end;
-                }
-                match found {
-                    Some((i, b)) => (Some(i), b),
-                    None => (None, 0),
-                }
-            }; // immutable borrow ends here
 
-            match found_idx {
-                Some(i) => {
-                    // Check if we should continue searching
-                    let $pos = i; // Index within current slice
-                    if $should_continue {
-                        // Continue searching from next position
-                        $lexer.input_mut().bump_bytes(i + 1);
-                        continue;
-                    } else {
-                        $lexer.input_mut().bump_bytes(i);
-                        break $byte;
-                    }
+                    // We don't find a matched byte in this batch,
+                    // So continue to try the next batch/remaining
+                    $pos = batch_end;
+                    continue 'outer;
                 }
-                None => {
-                    // Consume remainder then run handler.
-                    let len = $lexer.input().as_str().len();
+            } else {
+                'inner: loop {
+                    // The remaining is shorter than batch size.
+                    let remaining =
+                        unsafe { std::slice::from_raw_parts(bytes.add($pos), len - $pos) };
+                    for (i, &byte) in remaining.iter().enumerate() {
+                        if $table.matches(byte) {
+                            // We find a matched byte, jump out to check with continue_if
+                            $pos += i;
+                            break 'inner byte;
+                        }
+                    }
+
+                    // We don't find a matched byte in the remaining,
+                    // which also means we have reached the end of the input.
                     $lexer.input_mut().bump_bytes(len);
                     $eof_handler
                 }
+            };
+
+            // Check if we should continue searching
+            if $should_continue {
+                // Continue searching from next position
+                $pos += 1;
+                continue;
             }
-        }
+
+            break $byte;
+        };
+
+        $lexer.input_mut().bump_bytes($pos);
+        $byte
     }};
 }