perf(es/lexer): Use string searcher for lexing line comments (#7043)

crates/swc_common/src/input.rs

@@ -9,7 +9,7 @@ pub type SourceFileInput<'a> = StringInput<'a>;
 /// Implementation of [Input].
 #[derive(Clone)]
 pub struct StringInput<'a> {
-    cur_pos: BytePos,
+    start_pos_of_iter: BytePos,
     last_pos: BytePos,
     /// Current cursor
     iter: str::CharIndices<'a>,
@@ -31,13 +31,23 @@ impl<'a> StringInput<'a> {
         assert!(start <= end);
 
         StringInput {
-            cur_pos: start,
+            start_pos_of_iter: start,
             last_pos: start,
             orig: src,
             iter: src.char_indices(),
             orig_start: start,
         }
     }
+
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        self.iter.as_str()
+    }
+
+    #[inline]
+    pub fn bump_bytes(&mut self, n: usize) {
+        self.reset_to(self.last_pos + BytePos(n as u32));
+    }
 }
 
 /// Creates an [Input] from [SourceFile]. This is an alias for
@@ -84,7 +94,7 @@ impl<'a> Input for StringInput<'a> {
     #[inline]
     fn bump(&mut self) {
         if let Some((i, c)) = self.iter.next() {
-            self.last_pos = self.cur_pos + BytePos((i + c.len_utf8()) as u32);
+            self.last_pos = self.start_pos_of_iter + BytePos((i + c.len_utf8()) as u32);
         } else {
             unsafe {
                 debug_unreachable!("bump should not be called when cur() == None");
@@ -120,7 +130,7 @@ impl<'a> Input for StringInput<'a> {
 
         self.iter = s[end_idx..].char_indices();
         self.last_pos = end;
-        self.cur_pos = end;
+        self.start_pos_of_iter = end;
 
         ret
     }
@@ -142,7 +152,7 @@ impl<'a> Input for StringInput<'a> {
         let ret = &s[..last];
 
         self.last_pos = self.last_pos + BytePos(last as _);
-        self.cur_pos = self.last_pos;
+        self.start_pos_of_iter = self.last_pos;
         self.iter = s[last..].char_indices();
 
         ret
@@ -166,7 +176,7 @@ impl<'a> Input for StringInput<'a> {
         }
 
         self.last_pos = self.last_pos + BytePos(last as _);
-        self.cur_pos = self.last_pos;
+        self.start_pos_of_iter = self.last_pos;
         self.iter = s[last..].char_indices();
 
         Some(self.last_pos)
@@ -179,7 +189,7 @@ impl<'a> Input for StringInput<'a> {
 
         let s = &orig[idx..];
         self.iter = s.char_indices();
-        self.cur_pos = to;
+        self.start_pos_of_iter = to;
         self.last_pos = to;
     }
 
@@ -197,7 +207,7 @@ impl<'a> Input for StringInput<'a> {
     fn eat_byte(&mut self, c: u8) -> bool {
         if self.is_byte(c) {
             if let Some((i, _)) = self.iter.next() {
-                self.last_pos = self.cur_pos + BytePos((i + 1) as u32);
+                self.last_pos = self.start_pos_of_iter + BytePos((i + 1) as u32);
             } else {
                 unsafe {
                     debug_unreachable!(
@@ -304,13 +314,13 @@ mod tests {
         with_test_sess("foo/d", |mut i| {
             assert_eq!(i.slice(BytePos(1), BytePos(2)), "f");
             assert_eq!(i.last_pos, BytePos(2));
-            assert_eq!(i.cur_pos, BytePos(2));
+            assert_eq!(i.start_pos_of_iter, BytePos(2));
             assert_eq!(i.cur(), Some('o'));
 
             assert_eq!(i.slice(BytePos(2), BytePos(4)), "oo");
             assert_eq!(i.slice(BytePos(1), BytePos(4)), "foo");
             assert_eq!(i.last_pos, BytePos(4));
-            assert_eq!(i.cur_pos, BytePos(4));
+            assert_eq!(i.start_pos_of_iter, BytePos(4));
             assert_eq!(i.cur(), Some('/'));
         });
     }
@@ -320,13 +330,13 @@ mod tests {
         with_test_sess("load", |mut i| {
             assert_eq!(i.slice(BytePos(1), BytePos(3)), "lo");
             assert_eq!(i.last_pos, BytePos(3));
-            assert_eq!(i.cur_pos, BytePos(3));
+            assert_eq!(i.start_pos_of_iter, BytePos(3));
             assert_eq!(i.cur(), Some('a'));
             i.reset_to(BytePos(1));
 
             assert_eq!(i.cur(), Some('l'));
             assert_eq!(i.last_pos, BytePos(1));
-            assert_eq!(i.cur_pos, BytePos(1));
+            assert_eq!(i.start_pos_of_iter, BytePos(1));
         });
     }
 
@@ -335,12 +345,12 @@ mod tests {
         with_test_sess("foo/d", |mut i| {
             assert_eq!(i.cur_pos(), BytePos(1));
             assert_eq!(i.last_pos, BytePos(1));
-            assert_eq!(i.cur_pos, BytePos(1));
+            assert_eq!(i.start_pos_of_iter, BytePos(1));
             assert_eq!(i.uncons_while(|c| c.is_alphabetic()), "foo");
 
             // assert_eq!(i.cur_pos(), BytePos(4));
             assert_eq!(i.last_pos, BytePos(4));
-            assert_eq!(i.cur_pos, BytePos(4));
+            assert_eq!(i.start_pos_of_iter, BytePos(4));
             assert_eq!(i.cur(), Some('/'));
 
             i.bump();
@@ -358,10 +368,10 @@ mod tests {
         with_test_sess("foo/d", |mut i| {
             assert_eq!(i.cur_pos(), BytePos(1));
             assert_eq!(i.last_pos, BytePos(1));
-            assert_eq!(i.cur_pos, BytePos(1));
+            assert_eq!(i.start_pos_of_iter, BytePos(1));
 
             assert_eq!(i.find(|c| c == '/'), Some(BytePos(5)));
-            assert_eq!(i.cur_pos, BytePos(5));
+            assert_eq!(i.start_pos_of_iter, BytePos(5));
             assert_eq!(i.last_pos, BytePos(5));
             assert_eq!(i.cur(), Some('d'));
         });

crates/swc_ecma_parser/src/lexer/util.rs

@@ -64,38 +64,47 @@ impl<'a> Lexer<'a> {
         }
     }
 
+    #[inline(always)]
     pub(super) fn bump(&mut self) {
         self.input.bump()
     }
 
+    #[inline(always)]
     pub(super) fn is(&mut self, c: u8) -> bool {
         self.input.is_byte(c)
     }
 
+    #[inline(always)]
     pub(super) fn is_str(&self, s: &str) -> bool {
         self.input.is_str(s)
     }
 
+    #[inline(always)]
     pub(super) fn eat(&mut self, c: u8) -> bool {
         self.input.eat_byte(c)
     }
 
+    #[inline(always)]
     pub(super) fn cur(&mut self) -> Option<char> {
         self.input.cur()
     }
 
+    #[inline(always)]
     pub(super) fn peek(&mut self) -> Option<char> {
         self.input.peek()
     }
 
+    #[inline(always)]
     pub(super) fn peek_ahead(&mut self) -> Option<char> {
         self.input.peek_ahead()
     }
 
+    #[inline(always)]
     pub(super) fn cur_pos(&mut self) -> BytePos {
         self.input.cur_pos()
     }
 
+    #[inline(always)]
     pub(super) fn last_pos(&self) -> BytePos {
         self.input.last_pos()
     }
@@ -226,9 +235,7 @@ impl<'a> Lexer<'a> {
 
     pub(super) fn skip_line_comment(&mut self, start_skip: usize) {
         let start = self.cur_pos();
-        for _ in 0..start_skip {
-            self.bump();
-        }
+        self.input.bump_bytes(start_skip);
         let slice_start = self.cur_pos();
 
         // foo // comment for foo
@@ -239,17 +246,18 @@ impl<'a> Lexer<'a> {
         // bar
         //
         let is_for_next = self.state.had_line_break || !self.state.can_have_trailing_line_comment();
-        let mut end = self.cur_pos();
 
-        while let Some(c) = self.cur() {
-            self.bump();
-            if c.is_line_terminator() {
+        let idx = self
+            .input
+            .as_str()
+            .find(['\r', '\n', '\u{2028}', '\u{2029}'])
+            .map_or(self.input.as_str().len(), |v| {
                 self.state.had_line_break = true;
-                break;
-            } else {
-                end = self.cur_pos();
-            }
-        }
+                v
+            });
+
+        self.input.bump_bytes(idx);
+        let end = self.cur_pos();
 
         if let Some(comments) = self.comments_buffer.as_mut() {
             let s = self.input.slice(slice_start, end);
@@ -280,8 +288,7 @@ impl<'a> Lexer<'a> {
         debug_assert_eq!(self.cur(), Some('/'));
         debug_assert_eq!(self.peek(), Some('*'));
 
-        self.bump();
-        self.bump();
+        self.input.bump_bytes(2);
 
         // jsdoc
         let slice_start = self.cur_pos();