perf(es/parser): Replace byte arguments with generics (#10370)

CPunisher · web-flow · commit 68f76679b4a4 · 2025-04-13T21:18:22.000+09:00
diff --git a/crates/swc_ecma_parser/src/lexer/mod.rs b/crates/swc_ecma_parser/src/lexer/mod.rs
@@ -330,15 +330,15 @@ impl<'a> Lexer<'a> {
     ///
     /// This is extracted as a method to reduce size of `read_token`.
     #[inline(never)]
-    fn read_token_logical(&mut self, c: u8) -> LexResult<Token> {
+    fn read_token_logical<const C: u8>(&mut self) -> LexResult<Token> {
         let had_line_break_before_last = self.had_line_break_before_last();
         let start = self.cur_pos();
 
         unsafe {
             // Safety: cur() is Some(c as char)
             self.input.bump();
         }
-        let token = if c == b'&' {
+        let token = if C == b'&' {
             BinOpToken::BitAnd
         } else {
             BinOpToken::BitOr
@@ -354,7 +354,7 @@ impl<'a> Lexer<'a> {
         }
 
         // '||', '&&'
-        if self.input.cur() == Some(c as char) {
+        if self.input.cur() == Some(C as char) {
             unsafe {
                 // Safety: cur() is Some(c)
                 self.input.bump();
@@ -396,8 +396,8 @@ impl<'a> Lexer<'a> {
     ///
     /// This is extracted as a method to reduce size of `read_token`.
     #[inline(never)]
-    fn read_token_mul_mod(&mut self, c: u8) -> LexResult<Token> {
-        let is_mul = c == b'*';
+    fn read_token_mul_mod<const C: u8>(&mut self) -> LexResult<Token> {
+        let is_mul = C == b'*';
         unsafe {
             // Safety: cur() is Some(c)
             self.input.bump();
@@ -552,7 +552,7 @@ impl<'a> Lexer<'a> {
         Ok(Some(vec![c.into()]))
     }
 
-    fn read_token_plus_minus(&mut self, c: u8) -> LexResult<Option<Token>> {
+    fn read_token_plus_minus<const C: u8>(&mut self) -> LexResult<Option<Token>> {
         let start = self.cur_pos();
 
         unsafe {
@@ -561,41 +561,41 @@ impl<'a> Lexer<'a> {
         }
 
         // '++', '--'
-        Ok(Some(if self.input.cur() == Some(c as char) {
+        Ok(Some(if self.input.cur() == Some(C as char) {
             unsafe {
                 // Safety: cur() is Some(c)
                 self.input.bump();
             }
 
             // Handle -->
-            if self.state.had_line_break && c == b'-' && self.eat(b'>') {
+            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>();
                 return self.read_token();
             }
 
-            if c == b'+' {
+            if C == b'+' {
                 Token::PlusPlus
             } else {
                 Token::MinusMinus
             }
         } else if self.input.eat_byte(b'=') {
-            Token::AssignOp(if c == b'+' {
+            Token::AssignOp(if C == b'+' {
                 AssignOp::AddAssign
             } else {
                 AssignOp::SubAssign
             })
         } else {
-            Token::BinOp(if c == b'+' {
+            Token::BinOp(if C == b'+' {
                 BinOpToken::Add
             } else {
                 BinOpToken::Sub
             })
         }))
     }
 
-    fn read_token_bang_or_eq(&mut self, c: u8) -> LexResult<Option<Token>> {
+    fn read_token_bang_or_eq<const C: u8>(&mut self) -> LexResult<Option<Token>> {
         let start = self.cur_pos();
         let had_line_break_before_last = self.had_line_break_before_last();
 
@@ -608,7 +608,7 @@ impl<'a> Lexer<'a> {
             // "=="
 
             if self.input.eat_byte(b'=') {
-                if c == b'!' {
+                if C == b'!' {
                     Token::BinOp(BinOpToken::NotEqEq)
                 } else {
                     // =======
@@ -622,16 +622,16 @@ impl<'a> Lexer<'a> {
 
                     Token::BinOp(BinOpToken::EqEqEq)
                 }
-            } else if c == b'!' {
+            } else if C == b'!' {
                 Token::BinOp(BinOpToken::NotEq)
             } else {
                 Token::BinOp(BinOpToken::EqEq)
             }
-        } else if c == b'=' && self.input.eat_byte(b'>') {
+        } else if C == b'=' && self.input.eat_byte(b'>') {
             // "=>"
 
             Token::Arrow
-        } else if c == b'!' {
+        } else if C == b'!' {
             Token::Bang
         } else {
             Token::AssignOp(AssignOp::Assign)
@@ -655,51 +655,49 @@ impl Lexer<'_> {
     }
 
     #[inline(never)]
-    fn read_token_lt_gt(&mut self) -> LexResult<Option<Token>> {
-        debug_assert!(self.cur() == Some('<') || self.cur() == Some('>'));
-
+    fn read_token_lt_gt<const C: u8>(&mut self) -> LexResult<Option<Token>> {
         let had_line_break_before_last = self.had_line_break_before_last();
         let start = self.cur_pos();
-        let c = self.cur().unwrap();
         self.bump();
 
         if self.syntax.typescript()
             && self.ctx.contains(Context::InType)
             && !self.ctx.contains(Context::ShouldNotLexLtOrGtAsType)
         {
-            if c == '<' {
+            if C == b'<' {
                 return Ok(Some(tok!('<')));
-            } else if c == '>' {
+            } else if C == b'>' {
                 return Ok(Some(tok!('>')));
             }
         }
 
         // XML style comment. `<!--`
-        if c == '<' && self.is(b'!') && self.peek() == Some('-') && self.peek_ahead() == Some('-') {
+        if C == b'<' && self.is(b'!') && self.peek() == Some('-') && self.peek_ahead() == Some('-')
+        {
             self.skip_line_comment(3);
             self.skip_space::<true>();
             self.emit_module_mode_error(start, SyntaxError::LegacyCommentInModule);
 
             return self.read_token();
         }
 
-        let mut op = if c == '<' {
+        let mut op = if C == b'<' {
             BinOpToken::Lt
         } else {
             BinOpToken::Gt
         };
 
         // '<<', '>>'
-        if self.cur() == Some(c) {
+        if self.cur() == Some(C as char) {
             self.bump();
-            op = if c == '<' {
+            op = if C == b'<' {
                 BinOpToken::LShift
             } else {
                 BinOpToken::RShift
             };
 
             //'>>>'
-            if c == '>' && self.cur() == Some(c) {
+            if C == b'>' && self.cur() == Some(C as char) {
                 self.bump();
                 op = BinOpToken::ZeroFillRShift;
             }
diff --git a/crates/swc_ecma_parser/src/lexer/table.rs b/crates/swc_ecma_parser/src/lexer/table.rs
@@ -321,19 +321,19 @@ const UNI: ByteHandler = Some(|lexer| {
 const COL: ByteHandler = Some(|lexer| lexer.read_token_colon().map(Some));
 
 /// `%`
-const PRC: ByteHandler = Some(|lexer| lexer.read_token_mul_mod(b'%').map(Some));
+const PRC: ByteHandler = Some(|lexer| lexer.read_token_mul_mod::<b'%'>().map(Some));
 
 /// `*`
-const ATR: ByteHandler = Some(|lexer| lexer.read_token_mul_mod(b'*').map(Some));
+const ATR: ByteHandler = Some(|lexer| lexer.read_token_mul_mod::<b'*'>().map(Some));
 
 /// `?`
 const QST: ByteHandler = Some(|lexer| lexer.read_token_question_mark().map(Some));
 
 /// `&`
-const AMP: ByteHandler = Some(|lexer| lexer.read_token_logical(b'&').map(Some));
+const AMP: ByteHandler = Some(|lexer| lexer.read_token_logical::<b'&'>().map(Some));
 
 /// `|`
-const PIP: ByteHandler = Some(|lexer| lexer.read_token_logical(b'|').map(Some));
+const PIP: ByteHandler = Some(|lexer| lexer.read_token_logical::<b'|'>().map(Some));
 
 macro_rules! single_char {
     ($name:ident, $c:literal, $token:ident) => {
@@ -372,25 +372,25 @@ const CRT: ByteHandler = Some(|lexer| {
 });
 
 /// `+`
-const PLS: ByteHandler = Some(|lexer| lexer.read_token_plus_minus(b'+'));
+const PLS: ByteHandler = Some(|lexer| lexer.read_token_plus_minus::<b'+'>());
 
 /// `-`
-const MIN: ByteHandler = Some(|lexer| lexer.read_token_plus_minus(b'-'));
+const MIN: ByteHandler = Some(|lexer| lexer.read_token_plus_minus::<b'-'>());
 
 /// `!`
-const EXL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq(b'!'));
+const EXL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq::<b'!'>());
 
 /// `=`
-const EQL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq(b'='));
+const EQL: ByteHandler = Some(|lexer| lexer.read_token_bang_or_eq::<b'='>());
 
 /// `.`
 const PRD: ByteHandler = Some(|lexer| lexer.read_token_dot().map(Some));
 
 /// `<`
-const LSS: ByteHandler = Some(|lexer| lexer.read_token_lt_gt());
+const LSS: ByteHandler = Some(|lexer| lexer.read_token_lt_gt::<b'<'>());
 
 /// `>`
-const MOR: ByteHandler = Some(|lexer| lexer.read_token_lt_gt());
+const MOR: ByteHandler = Some(|lexer| lexer.read_token_lt_gt::<b'>'>());
 
 /// `/`
 const SLH: ByteHandler = Some(|lexer| lexer.read_slash());
