perf(parser): cleanup and optimize re-lexing angle tokens

Author: ulrichstark

crates/oxc_parser/src/cursor.rs

@@ -228,29 +228,27 @@ impl<'a> ParserImpl<'a> {
         }
     }
 
-    pub(crate) fn re_lex_l_angle(&mut self) -> Kind {
+    pub(crate) fn re_lex_ts_l_angle(&mut self) {
         if self.fatal_error.is_some() {
-            return Kind::Eof;
+            return;
         }
         let kind = self.cur_kind();
-        if matches!(kind, Kind::ShiftLeft | Kind::ShiftLeftEq | Kind::LtEq) {
-            self.token = self.lexer.re_lex_as_typescript_l_angle(kind);
-            self.token.kind()
-        } else {
-            kind
+        if kind == Kind::ShiftLeft || kind == Kind::LtEq {
+            self.token = self.lexer.re_lex_as_typescript_l_angle(2);
+        } else if kind == Kind::ShiftLeftEq {
+            self.token = self.lexer.re_lex_as_typescript_l_angle(3);
         }
     }
 
-    pub(crate) fn re_lex_ts_r_angle(&mut self) -> Kind {
+    pub(crate) fn re_lex_ts_r_angle(&mut self) {
         if self.fatal_error.is_some() {
-            return Kind::Eof;
+            return;
         }
         let kind = self.cur_kind();
-        if matches!(kind, Kind::ShiftRight | Kind::ShiftRight3) {
-            self.token = self.lexer.re_lex_as_typescript_r_angle(kind);
-            self.token.kind()
-        } else {
-            kind
+        if kind == Kind::ShiftRight {
+            self.token = self.lexer.re_lex_as_typescript_r_angle(2);
+        } else if kind == Kind::ShiftRight3 {
+            self.token = self.lexer.re_lex_as_typescript_r_angle(3);
         }
     }
 

crates/oxc_parser/src/lexer/typescript.rs

@@ -2,28 +2,16 @@ use super::{Kind, Lexer, Token};
 
 impl Lexer<'_> {
     /// Re-tokenize '<<' or '<=' or '<<=' to '<'
-    pub(crate) fn re_lex_as_typescript_l_angle(&mut self, kind: Kind) -> Token {
-        let offset = match kind {
-            Kind::ShiftLeft | Kind::LtEq => 2,
-            Kind::ShiftLeftEq => 3,
-            _ => unreachable!(),
-        };
+    pub(crate) fn re_lex_as_typescript_l_angle(&mut self, offset: u32) -> Token {
         self.token.set_start(self.offset() - offset);
         self.source.back(offset as usize - 1);
-        let kind = Kind::LAngle;
-        self.finish_next(kind)
+        self.finish_next(Kind::LAngle)
     }
 
     /// Re-tokenize '>>' and '>>>' to '>'
-    pub(crate) fn re_lex_as_typescript_r_angle(&mut self, kind: Kind) -> Token {
-        let offset = match kind {
-            Kind::ShiftRight => 2,
-            Kind::ShiftRight3 => 3,
-            _ => unreachable!(),
-        };
+    pub(crate) fn re_lex_as_typescript_r_angle(&mut self, offset: u32) -> Token {
         self.token.set_start(self.offset() - offset);
         self.source.back(offset as usize - 1);
-        let kind = Kind::RAngle;
-        self.finish_next(kind)
+        self.finish_next(Kind::RAngle)
     }
 }

crates/oxc_parser/src/ts/types.rs

@@ -829,28 +829,30 @@ impl<'a> ParserImpl<'a> {
     pub(crate) fn parse_type_arguments_of_type_reference(
         &mut self,
     ) -> Option<Box<'a, TSTypeParameterInstantiation<'a>>> {
-        if !self.cur_token().is_on_new_line() && self.re_lex_l_angle() == Kind::LAngle {
-            let span = self.start_span();
-            self.expect(Kind::LAngle);
-            let (params, _) =
-                self.parse_delimited_list(Kind::RAngle, Kind::Comma, Self::parse_ts_type);
-            self.expect(Kind::RAngle);
-            let span = self.end_span(span);
-            if params.is_empty() {
-                self.error(diagnostics::ts_empty_type_argument_list(span));
-            }
-            return Some(self.ast.alloc_ts_type_parameter_instantiation(span, params));
+        if self.cur_token().is_on_new_line() {
+            return None;
         }
-        None
+
+        let span = self.start_span();
+        self.re_lex_ts_l_angle();
+        if !self.eat(Kind::LAngle) {
+            return None;
+        }
+
+        let (params, _) = self.parse_delimited_list(Kind::RAngle, Kind::Comma, Self::parse_ts_type);
+        self.expect(Kind::RAngle);
+        let span = self.end_span(span);
+        if params.is_empty() {
+            self.error(diagnostics::ts_empty_type_argument_list(span));
+        }
+        Some(self.ast.alloc_ts_type_parameter_instantiation(span, params))
     }
 
     pub(crate) fn parse_type_arguments_in_expression(
         &mut self,
     ) -> Box<'a, TSTypeParameterInstantiation<'a>> {
         let span = self.start_span();
-        if self.re_lex_l_angle() != Kind::LAngle {
-            return self.unexpected();
-        }
+        self.re_lex_ts_l_angle();
         self.expect(Kind::LAngle);
         let (params, _) = self.parse_delimited_list(Kind::RAngle, Kind::Comma, Self::parse_ts_type);
         // `a < b> = c`` is valid but `a < b >= c` is BinaryExpression