From 015bf62577adc92f8b5307fdea214793c5ce62d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= <kdy1997.dev@gmail.com>
Date: Mon, 1 Jul 2024 14:09:32 +0900
Subject: [PATCH 1/3] Revert "perf(es/lexer): Use `memchr::memmem` for lexing
 block comments (#9096)"

This reverts commit 1b3672f1e7d38a0039b1ba0ebc136133dd8c907f.
---
 Cargo.lock                                |  1 -
 crates/swc_ecma_parser/Cargo.toml         |  1 -
 crates/swc_ecma_parser/src/lexer/jsx.rs   |  2 +-
 crates/swc_ecma_parser/src/lexer/mod.rs   | 10 +--
 crates/swc_ecma_parser/src/lexer/state.rs | 85 ++++++++++-------------
 crates/swc_ecma_parser/src/lexer/util.rs  | 54 +++++++-------
 6 files changed, 74 insertions(+), 79 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index eec858aeb6a9..4757d4a138ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4510,7 +4510,6 @@ version = "0.146.7"
 dependencies = [
  "criterion",
  "either",
- "memchr",
  "new_debug_unreachable",
  "num-bigint",
  "num-traits",
diff --git a/crates/swc_ecma_parser/Cargo.toml b/crates/swc_ecma_parser/Cargo.toml
index ab606af50574..c9cf0a714467 100644
--- a/crates/swc_ecma_parser/Cargo.toml
+++ b/crates/swc_ecma_parser/Cargo.toml
@@ -26,7 +26,6 @@ verify        = ["swc_ecma_visit"]
 
 [dependencies]
 either      = { workspace = true }
-memchr      = { workspace = true, features = ["use_std"] }
 num-bigint  = { workspace = true }
 num-traits  = { workspace = true }
 serde       = { workspace = true, features = ["derive"] }
diff --git a/crates/swc_ecma_parser/src/lexer/jsx.rs b/crates/swc_ecma_parser/src/lexer/jsx.rs
index 5a35ff9f0344..c85babc51cdc 100644
--- a/crates/swc_ecma_parser/src/lexer/jsx.rs
+++ b/crates/swc_ecma_parser/src/lexer/jsx.rs
@@ -27,7 +27,7 @@ impl<'a> Lexer<'a> {
 
                     self.emit_error_span(span, SyntaxError::TS1185);
                     self.skip_line_comment(6);
-                    self.skip_space::<true>();
+                    self.skip_space::<true>()?;
                     return self.read_token();
                 }
                 '<' | '{' => {
diff --git a/crates/swc_ecma_parser/src/lexer/mod.rs b/crates/swc_ecma_parser/src/lexer/mod.rs
index ba807a39ae92..1c04d9551ccd 100644
--- a/crates/swc_ecma_parser/src/lexer/mod.rs
+++ b/crates/swc_ecma_parser/src/lexer/mod.rs
@@ -379,7 +379,7 @@ impl<'a> Lexer<'a> {
                 let span = fixed_len_span(start, 7);
                 self.emit_error_span(span, SyntaxError::TS1185);
                 self.skip_line_comment(5);
-                self.skip_space::<true>();
+                self.skip_space::<true>()?;
                 return self.error_span(span, SyntaxError::TS1185);
             }
 
@@ -572,7 +572,7 @@ impl<'a> Lexer<'a> {
             if self.state.had_line_break && c == b'-' && self.eat(b'>') {
                 self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
                 self.skip_line_comment(0);
-                self.skip_space::<true>();
+                self.skip_space::<true>()?;
                 return self.read_token();
             }
 
@@ -617,7 +617,7 @@ impl<'a> Lexer<'a> {
                     if had_line_break_before_last && self.is_str("====") {
                         self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
                         self.skip_line_comment(4);
-                        self.skip_space::<true>();
+                        self.skip_space::<true>()?;
                         return self.read_token();
                     }
 
@@ -676,7 +676,7 @@ impl<'a> Lexer<'a> {
         // XML style comment. `<!--`
         if c == '<' && self.is(b'!') && self.peek() == Some('-') && self.peek_ahead() == Some('-') {
             self.skip_line_comment(3);
-            self.skip_space::<true>();
+            self.skip_space::<true>()?;
             self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
 
             return self.read_token();
@@ -732,7 +732,7 @@ impl<'a> Lexer<'a> {
         {
             self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
             self.skip_line_comment(5);
-            self.skip_space::<true>();
+            self.skip_space::<true>()?;
             return self.read_token();
         }
 
diff --git a/crates/swc_ecma_parser/src/lexer/state.rs b/crates/swc_ecma_parser/src/lexer/state.rs
index 58e018f09cdd..3a0f412ff1c2 100644
--- a/crates/swc_ecma_parser/src/lexer/state.rs
+++ b/crates/swc_ecma_parser/src/lexer/state.rs
@@ -194,50 +194,6 @@ impl Tokens for Lexer<'_> {
 }
 
 impl Lexer<'_> {
-    /// Consume pending comments.
-    ///
-    /// This is called when the input is exhausted.
-    #[cold]
-    #[inline(never)]
-    fn consume_pending_comments(&mut self) {
-        if let Some(comments) = self.comments.as_mut() {
-            let comments_buffer = self.comments_buffer.as_mut().unwrap();
-            let last = self.state.prev_hi;
-
-            // move the pending to the leading or trailing
-            for c in comments_buffer.take_pending_leading() {
-                // if the file had no tokens and no shebang, then treat any
-                // comments in the leading comments buffer as leading.
-                // Otherwise treat them as trailing.
-                if last == self.start_pos {
-                    comments_buffer.push(BufferedComment {
-                        kind: BufferedCommentKind::Leading,
-                        pos: last,
-                        comment: c,
-                    });
-                } else {
-                    comments_buffer.push(BufferedComment {
-                        kind: BufferedCommentKind::Trailing,
-                        pos: last,
-                        comment: c,
-                    });
-                }
-            }
-
-            // now fill the user's passed in comments
-            for comment in comments_buffer.take_comments() {
-                match comment.kind {
-                    BufferedCommentKind::Leading => {
-                        comments.add_leading(comment.pos, comment.comment);
-                    }
-                    BufferedCommentKind::Trailing => {
-                        comments.add_trailing(comment.pos, comment.comment);
-                    }
-                }
-            }
-        }
-    }
-
     fn next_token(&mut self, start: &mut BytePos) -> Result<Option<Token>, Error> {
         if let Some(start) = self.state.next_regexp {
             return Ok(Some(self.read_regexp(start)?));
@@ -254,7 +210,7 @@ impl Lexer<'_> {
 
         // skip spaces before getting next character, if we are allowed to.
         if self.state.can_skip_space() {
-            self.skip_space::<true>();
+            self.skip_space::<true>()?;
             *start = self.input.cur_pos();
         };
 
@@ -262,7 +218,42 @@ impl Lexer<'_> {
             Some(..) => {}
             // End of input.
             None => {
-                self.consume_pending_comments();
+                if let Some(comments) = self.comments.as_mut() {
+                    let comments_buffer = self.comments_buffer.as_mut().unwrap();
+                    let last = self.state.prev_hi;
+
+                    // move the pending to the leading or trailing
+                    for c in comments_buffer.take_pending_leading() {
+                        // if the file had no tokens and no shebang, then treat any
+                        // comments in the leading comments buffer as leading.
+                        // Otherwise treat them as trailing.
+                        if last == self.start_pos {
+                            comments_buffer.push(BufferedComment {
+                                kind: BufferedCommentKind::Leading,
+                                pos: last,
+                                comment: c,
+                            });
+                        } else {
+                            comments_buffer.push(BufferedComment {
+                                kind: BufferedCommentKind::Trailing,
+                                pos: last,
+                                comment: c,
+                            });
+                        }
+                    }
+
+                    // now fill the user's passed in comments
+                    for comment in comments_buffer.take_comments() {
+                        match comment.kind {
+                            BufferedCommentKind::Leading => {
+                                comments.add_leading(comment.pos, comment.comment);
+                            }
+                            BufferedCommentKind::Trailing => {
+                                comments.add_trailing(comment.pos, comment.comment);
+                            }
+                        }
+                    }
+                }
 
                 return Ok(None);
             }
@@ -320,7 +311,7 @@ impl Lexer<'_> {
 
                         self.emit_error_span(span, SyntaxError::TS1185);
                         self.skip_line_comment(6);
-                        self.skip_space::<true>();
+                        self.skip_space::<true>()?;
                         return self.read_token();
                     }
 
diff --git a/crates/swc_ecma_parser/src/lexer/util.rs b/crates/swc_ecma_parser/src/lexer/util.rs
index 1e50f8085f11..30ed8b80c751 100644
--- a/crates/swc_ecma_parser/src/lexer/util.rs
+++ b/crates/swc_ecma_parser/src/lexer/util.rs
@@ -4,7 +4,6 @@
 //! [babylon/util/identifier.js]:https://github.com/babel/babel/blob/master/packages/babylon/src/util/identifier.js
 use std::char;
 
-use ::memchr::memmem;
 use swc_common::{
     comments::{Comment, CommentKind},
     BytePos, Span, SyntaxContext,
@@ -161,7 +160,7 @@ impl<'a> Lexer<'a> {
     ///
     /// See https://tc39.github.io/ecma262/#sec-white-space
     #[inline(never)]
-    pub(super) fn skip_space<const LEX_COMMENTS: bool>(&mut self) {
+    pub(super) fn skip_space<const LEX_COMMENTS: bool>(&mut self) -> LexResult<()> {
         loop {
             let (offset, newline) = {
                 let mut skip = SkipWhitespace {
@@ -185,13 +184,15 @@ impl<'a> Lexer<'a> {
                     self.skip_line_comment(2);
                     continue;
                 } else if self.peek() == Some('*') {
-                    self.skip_block_comment();
+                    self.skip_block_comment()?;
                     continue;
                 }
             }
 
             break;
         }
+
+        Ok(())
     }
 
     #[inline(never)]
@@ -251,7 +252,7 @@ impl<'a> Lexer<'a> {
 
     /// Expects current char to be '/' and next char to be '*'.
     #[inline(never)]
-    pub(super) fn skip_block_comment(&mut self) {
+    pub(super) fn skip_block_comment(&mut self) -> LexResult<()> {
         let start = self.cur_pos();
 
         debug_assert_eq!(self.cur(), Some('/'));
@@ -261,36 +262,41 @@ impl<'a> Lexer<'a> {
 
         // jsdoc
         let slice_start = self.cur_pos();
+        let mut was_star = if self.input.is_byte(b'*') {
+            self.bump();
+            true
+        } else {
+            false
+        };
 
         let mut is_for_next = self.state.had_line_break || !self.state.can_have_trailing_comment();
 
-        if let Some(idx) = memmem::find(self.input.as_str().as_bytes(), b"*/") {
-            if !self.state.had_line_break {
-                self.state.had_line_break = self.input.as_str()[0..idx]
-                    .chars()
-                    .any(|c| c.is_line_terminator());
-            }
+        while let Some(c) = self.cur() {
+            if was_star && c == '/' {
+                debug_assert_eq!(self.cur(), Some('/'));
+                self.bump(); // '/'
 
-            self.input.bump_bytes(idx + 2);
-            let end = self.cur_pos();
+                let end = self.cur_pos();
 
-            self.skip_space::<false>();
+                self.skip_space::<false>()?;
 
-            if self.input.is_byte(b';') {
-                is_for_next = false;
-            }
+                if self.input.is_byte(b';') {
+                    is_for_next = false;
+                }
 
-            self.store_comment(is_for_next, start, end, slice_start);
+                self.store_comment(is_for_next, start, end, slice_start);
 
-            return;
-        }
-
-        let len = self.input.as_str().bytes().len();
-        self.input.bump_bytes(len);
+                return Ok(());
+            }
+            if c.is_line_terminator() {
+                self.state.had_line_break = true;
+            }
 
-        let span = self.span(start);
+            was_star = c == '*';
+            self.bump();
+        }
 
-        self.emit_error_span(span, SyntaxError::UnterminatedBlockComment)
+        self.error(start, SyntaxError::UnterminatedBlockComment)?
     }
 
     #[inline(never)]

From 91cd73c55cde2e9039bc303f580bddff074b6b54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?=
 <kdy1997.dev@gmail.com>
Date: Mon, 1 Jul 2024 14:12:48 +0900
Subject: [PATCH 2/3] skip_space

---
 crates/swc_ecma_parser/src/lexer/jsx.rs   |  2 +-
 crates/swc_ecma_parser/src/lexer/mod.rs   | 10 +++++-----
 crates/swc_ecma_parser/src/lexer/state.rs |  4 ++--
 crates/swc_ecma_parser/src/lexer/util.rs  |  8 +++-----
 4 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/crates/swc_ecma_parser/src/lexer/jsx.rs b/crates/swc_ecma_parser/src/lexer/jsx.rs
index c85babc51cdc..5a35ff9f0344 100644
--- a/crates/swc_ecma_parser/src/lexer/jsx.rs
+++ b/crates/swc_ecma_parser/src/lexer/jsx.rs
@@ -27,7 +27,7 @@ impl<'a> Lexer<'a> {
 
                     self.emit_error_span(span, SyntaxError::TS1185);
                     self.skip_line_comment(6);
-                    self.skip_space::<true>()?;
+                    self.skip_space::<true>();
                     return self.read_token();
                 }
                 '<' | '{' => {
diff --git a/crates/swc_ecma_parser/src/lexer/mod.rs b/crates/swc_ecma_parser/src/lexer/mod.rs
index 1c04d9551ccd..ba807a39ae92 100644
--- a/crates/swc_ecma_parser/src/lexer/mod.rs
+++ b/crates/swc_ecma_parser/src/lexer/mod.rs
@@ -379,7 +379,7 @@ impl<'a> Lexer<'a> {
                 let span = fixed_len_span(start, 7);
                 self.emit_error_span(span, SyntaxError::TS1185);
                 self.skip_line_comment(5);
-                self.skip_space::<true>()?;
+                self.skip_space::<true>();
                 return self.error_span(span, SyntaxError::TS1185);
             }
 
@@ -572,7 +572,7 @@ impl<'a> Lexer<'a> {
             if self.state.had_line_break && c == b'-' && self.eat(b'>') {
                 self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
                 self.skip_line_comment(0);
-                self.skip_space::<true>()?;
+                self.skip_space::<true>();
                 return self.read_token();
             }
 
@@ -617,7 +617,7 @@ impl<'a> Lexer<'a> {
                     if had_line_break_before_last && self.is_str("====") {
                         self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
                         self.skip_line_comment(4);
-                        self.skip_space::<true>()?;
+                        self.skip_space::<true>();
                         return self.read_token();
                     }
 
@@ -676,7 +676,7 @@ impl<'a> Lexer<'a> {
         // XML style comment. `<!--`
         if c == '<' && self.is(b'!') && self.peek() == Some('-') && self.peek_ahead() == Some('-') {
             self.skip_line_comment(3);
-            self.skip_space::<true>()?;
+            self.skip_space::<true>();
             self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
 
             return self.read_token();
@@ -732,7 +732,7 @@ impl<'a> Lexer<'a> {
         {
             self.emit_error_span(fixed_len_span(start, 7), SyntaxError::TS1185);
             self.skip_line_comment(5);
-            self.skip_space::<true>()?;
+            self.skip_space::<true>();
             return self.read_token();
         }
 
diff --git a/crates/swc_ecma_parser/src/lexer/state.rs b/crates/swc_ecma_parser/src/lexer/state.rs
index 3a0f412ff1c2..17e524e259b8 100644
--- a/crates/swc_ecma_parser/src/lexer/state.rs
+++ b/crates/swc_ecma_parser/src/lexer/state.rs
@@ -210,7 +210,7 @@ impl Lexer<'_> {
 
         // skip spaces before getting next character, if we are allowed to.
         if self.state.can_skip_space() {
-            self.skip_space::<true>()?;
+            self.skip_space::<true>();
             *start = self.input.cur_pos();
         };
 
@@ -311,7 +311,7 @@ impl Lexer<'_> {
 
                         self.emit_error_span(span, SyntaxError::TS1185);
                         self.skip_line_comment(6);
-                        self.skip_space::<true>()?;
+                        self.skip_space::<true>();
                         return self.read_token();
                     }
 
diff --git a/crates/swc_ecma_parser/src/lexer/util.rs b/crates/swc_ecma_parser/src/lexer/util.rs
index 30ed8b80c751..3e1c78c2f4b9 100644
--- a/crates/swc_ecma_parser/src/lexer/util.rs
+++ b/crates/swc_ecma_parser/src/lexer/util.rs
@@ -160,7 +160,7 @@ impl<'a> Lexer<'a> {
     ///
     /// See https://tc39.github.io/ecma262/#sec-white-space
     #[inline(never)]
-    pub(super) fn skip_space<const LEX_COMMENTS: bool>(&mut self) -> LexResult<()> {
+    pub(super) fn skip_space<const LEX_COMMENTS: bool>(&mut self) {
         loop {
             let (offset, newline) = {
                 let mut skip = SkipWhitespace {
@@ -184,15 +184,13 @@ impl<'a> Lexer<'a> {
                     self.skip_line_comment(2);
                     continue;
                 } else if self.peek() == Some('*') {
-                    self.skip_block_comment()?;
+                    self.skip_block_comment();
                     continue;
                 }
             }
 
             break;
         }
-
-        Ok(())
     }
 
     #[inline(never)]
@@ -278,7 +276,7 @@ impl<'a> Lexer<'a> {
 
                 let end = self.cur_pos();
 
-                self.skip_space::<false>()?;
+                self.skip_space::<false>();
 
                 if self.input.is_byte(b';') {
                     is_for_next = false;

From 73ebb0f84fd3a3218b38ed74f6264aa4e8b41341 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?=
 <kdy1997.dev@gmail.com>
Date: Mon, 1 Jul 2024 14:14:43 +0900
Subject: [PATCH 3/3] revert other changes

---
 crates/swc_ecma_parser/src/lexer/state.rs | 81 +++++++++++++----------
 crates/swc_ecma_parser/src/lexer/util.rs  |  6 +-
 2 files changed, 48 insertions(+), 39 deletions(-)

diff --git a/crates/swc_ecma_parser/src/lexer/state.rs b/crates/swc_ecma_parser/src/lexer/state.rs
index 17e524e259b8..58e018f09cdd 100644
--- a/crates/swc_ecma_parser/src/lexer/state.rs
+++ b/crates/swc_ecma_parser/src/lexer/state.rs
@@ -194,6 +194,50 @@ impl Tokens for Lexer<'_> {
 }
 
 impl Lexer<'_> {
+    /// Consume pending comments.
+    ///
+    /// This is called when the input is exhausted.
+    #[cold]
+    #[inline(never)]
+    fn consume_pending_comments(&mut self) {
+        if let Some(comments) = self.comments.as_mut() {
+            let comments_buffer = self.comments_buffer.as_mut().unwrap();
+            let last = self.state.prev_hi;
+
+            // move the pending to the leading or trailing
+            for c in comments_buffer.take_pending_leading() {
+                // if the file had no tokens and no shebang, then treat any
+                // comments in the leading comments buffer as leading.
+                // Otherwise treat them as trailing.
+                if last == self.start_pos {
+                    comments_buffer.push(BufferedComment {
+                        kind: BufferedCommentKind::Leading,
+                        pos: last,
+                        comment: c,
+                    });
+                } else {
+                    comments_buffer.push(BufferedComment {
+                        kind: BufferedCommentKind::Trailing,
+                        pos: last,
+                        comment: c,
+                    });
+                }
+            }
+
+            // now fill the user's passed in comments
+            for comment in comments_buffer.take_comments() {
+                match comment.kind {
+                    BufferedCommentKind::Leading => {
+                        comments.add_leading(comment.pos, comment.comment);
+                    }
+                    BufferedCommentKind::Trailing => {
+                        comments.add_trailing(comment.pos, comment.comment);
+                    }
+                }
+            }
+        }
+    }
+
     fn next_token(&mut self, start: &mut BytePos) -> Result<Option<Token>, Error> {
         if let Some(start) = self.state.next_regexp {
             return Ok(Some(self.read_regexp(start)?));
@@ -218,42 +262,7 @@ impl Lexer<'_> {
             Some(..) => {}
             // End of input.
             None => {
-                if let Some(comments) = self.comments.as_mut() {
-                    let comments_buffer = self.comments_buffer.as_mut().unwrap();
-                    let last = self.state.prev_hi;
-
-                    // move the pending to the leading or trailing
-                    for c in comments_buffer.take_pending_leading() {
-                        // if the file had no tokens and no shebang, then treat any
-                        // comments in the leading comments buffer as leading.
-                        // Otherwise treat them as trailing.
-                        if last == self.start_pos {
-                            comments_buffer.push(BufferedComment {
-                                kind: BufferedCommentKind::Leading,
-                                pos: last,
-                                comment: c,
-                            });
-                        } else {
-                            comments_buffer.push(BufferedComment {
-                                kind: BufferedCommentKind::Trailing,
-                                pos: last,
-                                comment: c,
-                            });
-                        }
-                    }
-
-                    // now fill the user's passed in comments
-                    for comment in comments_buffer.take_comments() {
-                        match comment.kind {
-                            BufferedCommentKind::Leading => {
-                                comments.add_leading(comment.pos, comment.comment);
-                            }
-                            BufferedCommentKind::Trailing => {
-                                comments.add_trailing(comment.pos, comment.comment);
-                            }
-                        }
-                    }
-                }
+                self.consume_pending_comments();
 
                 return Ok(None);
             }
diff --git a/crates/swc_ecma_parser/src/lexer/util.rs b/crates/swc_ecma_parser/src/lexer/util.rs
index 3e1c78c2f4b9..5b9abf4b7d84 100644
--- a/crates/swc_ecma_parser/src/lexer/util.rs
+++ b/crates/swc_ecma_parser/src/lexer/util.rs
@@ -250,7 +250,7 @@ impl<'a> Lexer<'a> {
 
     /// Expects current char to be '/' and next char to be '*'.
     #[inline(never)]
-    pub(super) fn skip_block_comment(&mut self) -> LexResult<()> {
+    pub(super) fn skip_block_comment(&mut self) {
         let start = self.cur_pos();
 
         debug_assert_eq!(self.cur(), Some('/'));
@@ -284,7 +284,7 @@ impl<'a> Lexer<'a> {
 
                 self.store_comment(is_for_next, start, end, slice_start);
 
-                return Ok(());
+                return;
             }
             if c.is_line_terminator() {
                 self.state.had_line_break = true;
@@ -294,7 +294,7 @@ impl<'a> Lexer<'a> {
             self.bump();
         }
 
-        self.error(start, SyntaxError::UnterminatedBlockComment)?
+        self.emit_error(start, SyntaxError::UnterminatedBlockComment)
     }
 
     #[inline(never)]