refactor(oxc_parser): removed not needed generic from unexpected function

crates/oxc_parser/src/js/binding.rs

@@ -94,7 +94,7 @@ impl<'a> Parser<'a> {
                 let left = self.ast.binding_pattern(identifier, None, false);
                 PropertyValue::Pattern(self.parse_initializer(span, left)?)
             } else {
-                return self.unexpected();
+                return Err(self.unexpected());
             }
         } else {
             // let { a: b } = c

crates/oxc_parser/src/js/class.rs

@@ -241,7 +241,7 @@ impl<'a> Parser<'a> {
                 kind if kind.is_class_element_name_start() => {
                     Some(self.parse_class_element_name()?)
                 }
-                _ => return self.unexpected(),
+                _ => return Err(self.unexpected()),
             }
         }
 

crates/oxc_parser/src/js/declaration.rs

@@ -51,7 +51,7 @@ impl<'a> Parser<'a> {
             Kind::Var => VariableDeclarationKind::Var,
             Kind::Const => VariableDeclarationKind::Const,
             Kind::Let => VariableDeclarationKind::Let,
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         self.bump_any();
 

crates/oxc_parser/src/js/expression.rs

@@ -47,7 +47,7 @@ impl<'a> Parser<'a> {
     pub fn parse_identifier_reference(&mut self) -> Result<IdentifierReference> {
         // allow `await` and `yield`, let semantic analysis report error
         if !self.cur_kind().is_identifier_reference(false, false) {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let (span, name) = self.parse_identifier_kind(Kind::Ident);
         self.check_identifier(span, &name);
@@ -57,7 +57,7 @@ impl<'a> Parser<'a> {
     /// `BindingIdentifier` : Identifier
     pub fn parse_binding_identifier(&mut self) -> Result<BindingIdentifier> {
         if !self.cur_kind().is_binding_identifier() {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let (span, name) = self.parse_identifier_kind(Kind::Ident);
         self.check_identifier(span, &name);
@@ -66,7 +66,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_label_identifier(&mut self) -> Result<LabelIdentifier> {
         if !self.cur_kind().is_label_identifier(self.ctx.has_yield(), self.ctx.has_await()) {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let (span, name) = self.parse_identifier_kind(Kind::Ident);
         self.check_identifier(span, &name);
@@ -75,7 +75,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_identifier_name(&mut self) -> Result<IdentifierName> {
         if !self.cur_kind().is_identifier_name() {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let (span, name) = self.parse_identifier_kind(Kind::Ident);
         Ok(IdentifierName { span, name })
@@ -174,7 +174,7 @@ impl<'a> Parser<'a> {
                 match self.cur_kind() {
                     Kind::Dot => self.parse_meta_property(span, identifier),
                     Kind::LParen => self.parse_import_expression(span),
-                    _ => self.unexpected(),
+                    _ => Err(self.unexpected()),
                 }
             }
             Kind::LParen => self.parse_parenthesized_expression(span),
@@ -243,7 +243,7 @@ impl<'a> Parser<'a> {
                         .map(|literal| self.ast.literal_number_expression(literal))
                 }
             }
-            _ => self.unexpected(),
+            _ => Err(self.unexpected()),
         }
     }
 
@@ -252,7 +252,7 @@ impl<'a> Parser<'a> {
         let value = match self.cur_kind() {
             Kind::True => true,
             Kind::False => false,
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         self.bump_any();
         Ok(BooleanLiteral { span: self.end_span(span), value })
@@ -271,7 +271,7 @@ impl<'a> Parser<'a> {
             Kind::Binary => NumberBase::Binary,
             Kind::Octal => NumberBase::Octal,
             Kind::Hex => NumberBase::Hex,
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         let value = self.cur_token().value.as_number();
         let raw = self.cur_src();
@@ -283,7 +283,7 @@ impl<'a> Parser<'a> {
         let span = self.start_span();
         let value = match self.cur_kind() {
             kind if kind.is_number() => self.cur_token().value.as_bigint(),
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         self.bump_any();
         Ok(BigintLiteral { span: self.end_span(span), value })
@@ -293,7 +293,7 @@ impl<'a> Parser<'a> {
         let span = self.start_span();
         let r = match self.cur_kind() {
             Kind::RegExp => self.cur_token().value.as_regex(),
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         let pattern = Atom::from(r.pattern);
         let flags = r.flags;
@@ -307,7 +307,7 @@ impl<'a> Parser<'a> {
 
     pub fn parse_literal_string(&mut self) -> Result<StringLiteral> {
         if !self.at(Kind::Str) {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let TokenValue::String(value) = std::mem::take(&mut self.token.value) else {
             unreachable!()
@@ -680,7 +680,7 @@ impl<'a> Parser<'a> {
                         let arguments = p.parse_ts_type_arguments()?;
                         if p.at(Kind::RAngle) {
                             // a<b>>c is not (a<b>)>c, but a<(b>>c)
-                            return p.unexpected();
+                            return Err(p.unexpected());
                         }
 
                         // a<b>c is (a<b)>c
@@ -690,7 +690,7 @@ impl<'a> Parser<'a> {
                             && p.cur_kind().is_at_expression()
                             && !p.cur_token().is_on_new_line
                         {
-                            return p.unexpected();
+                            return Err(p.unexpected());
                         }
 
                         type_arguments = arguments;
@@ -721,7 +721,7 @@ impl<'a> Parser<'a> {
                 let arguments = p.parse_ts_type_arguments()?;
                 if p.at(Kind::RAngle) {
                     // a<b>>c is not (a<b>)>c, but a<(b>>c)
-                    return p.unexpected();
+                    return Err(p.unexpected());
                 }
 
                 // a<b>c is (a<b)>c
@@ -731,7 +731,7 @@ impl<'a> Parser<'a> {
                     && p.cur_kind().is_at_expression()
                     && !p.cur_token().is_on_new_line
                 {
-                    return p.unexpected();
+                    return Err(p.unexpected());
                 }
 
                 type_arguments = arguments;

crates/oxc_parser/src/js/function.rs

@@ -99,7 +99,7 @@ impl<'a> Parser<'a> {
         self.ctx = self.ctx.and_await(has_await).and_yield(has_yield);
 
         if !self.ts_enabled() && body.is_none() {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
 
         let function_type = if body.is_none() {

crates/oxc_parser/src/js/grammar.rs

@@ -152,7 +152,7 @@ impl<'a> CoverGrammar<'a, Property<'a>> for AssignmentTargetProperty<'a> {
                 PropertyKey::Identifier(ident) => {
                     IdentifierReference { span: ident.span, name: ident.unbox().name }
                 }
-                _ => return p.unexpected(),
+                _ => return Err(p.unexpected()),
             };
             let init = match property.value {
                 PropertyValue::Expression(Expression::AssignmentExpression(assignment_expr)) => {

crates/oxc_parser/src/js/module.rs

@@ -87,7 +87,7 @@ impl<'a> Parser<'a> {
                         let mut import_specifiers = self.parse_import_specifiers()?;
                         specifiers.append(&mut import_specifiers);
                     }
-                    _ => return self.unexpected(),
+                    _ => return Err(self.unexpected()),
                 }
             }
         // import * as name from "module-name";

crates/oxc_parser/src/js/object.rs

@@ -77,7 +77,7 @@ impl<'a> Parser<'a> {
                     ));
                 }
 
-                self.unexpected()
+                Err(self.unexpected())
             }
         }
     }

crates/oxc_parser/src/js/statement.rs

@@ -417,7 +417,7 @@ impl<'a> Parser<'a> {
                 let expression = self.parse_expression()?;
                 Some(expression)
             }
-            _ => return self.unexpected(),
+            _ => return Err(self.unexpected()),
         };
         self.expect(Kind::Colon)?;
         let mut consequent = self.ast.new_vec();

crates/oxc_parser/src/jsx/mod.rs

@@ -173,7 +173,7 @@ impl<'a> Parser<'a> {
             return Ok(self.ast.jsx_member_expression(self.end_span(span), object, property));
         }
 
-        self.unexpected()
+        Err(self.unexpected())
     }
 
     /// `JSXChildren` :
@@ -218,7 +218,7 @@ impl<'a> Parser<'a> {
                 .map(Some),
             // text
             Kind::JSXText => Ok(Some(JSXChild::Text(self.parse_jsx_text()))),
-            _ => self.unexpected(),
+            _ => Err(self.unexpected()),
         }
     }
 
@@ -336,7 +336,7 @@ impl<'a> Parser<'a> {
                 let expr = self.parse_jsx_expression_container(false)?;
                 Ok(JSXAttributeValue::ExpressionContainer(expr))
             }
-            _ => self.unexpected(),
+            _ => Err(self.unexpected()),
         }
     }
 
@@ -347,7 +347,7 @@ impl<'a> Parser<'a> {
     fn parse_jsx_identifier(&mut self) -> Result<JSXIdentifier> {
         let span = self.start_span();
         if !self.at(Kind::Ident) && !self.cur_kind().is_all_keyword() {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         // we are at a valid normal Ident or Keyword, let's keep on lexing for `-`
         self.re_lex_jsx_identifier();

crates/oxc_parser/src/lib.rs

@@ -137,13 +137,13 @@ impl<'a> Parser<'a> {
     /// Return error info at current token
     /// # Panics
     ///   * The lexer did not push a diagnostic when `Kind::Undetermined` is returned
-    fn unexpected<T>(&mut self) -> Result<T> {
+    fn unexpected(&mut self) -> Error {
         // The lexer should have reported a more meaningful diagnostic
         // when it is a undetermined kind.
         if self.cur_kind() == Kind::Undetermined {
-            return Err(self.lexer.errors.pop().unwrap());
+            return self.lexer.errors.pop().unwrap();
         }
-        Err(diagnostics::UnexpectedToken(self.cur_token().span()).into())
+        diagnostics::UnexpectedToken(self.cur_token().span()).into()
     }
 
     /// Push a Syntax Error

crates/oxc_parser/src/ts/statement.rs

@@ -86,7 +86,7 @@ impl<'a> Parser<'a> {
             let type_annotation = self.parse_ts_type()?;
             Ok((Some(self.ast.ts_type_annotation(self.end_span(span), type_annotation)), true))
         } else {
-            self.unexpected()
+            Err(self.unexpected())
         }
     }
 
@@ -406,7 +406,7 @@ impl<'a> Parser<'a> {
                         .map(Declaration::FunctionDeclaration)
                 }
             }
-            _ => self.unexpected(),
+            _ => Err(self.unexpected()),
         }
     }
 

crates/oxc_parser/src/ts/types.rs

@@ -511,7 +511,7 @@ impl<'a> Parser<'a> {
                 if p.cur_kind().can_follow_type_arguments_in_expr() {
                     Ok(params)
                 } else {
-                    p.unexpected()
+                    Err(p.unexpected())
                 }
             })
             .ok()
@@ -604,7 +604,7 @@ impl<'a> Parser<'a> {
         self.expect(Kind::LBrack)?;
         let type_parameter_span = self.start_span();
         if !self.cur_kind().is_identifier_name() {
-            return self.unexpected();
+            return Err(self.unexpected());
         }
         let name = self.parse_binding_identifier()?;
         self.expect(Kind::In)?;
@@ -693,7 +693,7 @@ impl<'a> Parser<'a> {
                 Expression::RegExpLiteral(literal) => TSLiteral::RegExpLiteral(literal),
                 Expression::StringLiteral(literal) => TSLiteral::StringLiteral(literal),
                 Expression::TemplateLiteral(literal) => TSLiteral::TemplateLiteral(literal),
-                _ => return self.unexpected(),
+                _ => return Err(self.unexpected()),
             }
         };
 
@@ -825,7 +825,7 @@ impl<'a> Parser<'a> {
                 return Ok(Some(constraint));
             }
         }
-        self.unexpected()
+        Err(self.unexpected())
     }
 
     pub fn parse_ts_return_type_annotation(
@@ -1022,7 +1022,7 @@ impl<'a> Parser<'a> {
         let span = self.start_span();
         while self.is_nth_at_modifier(0, false) {
             if !self.eat(Kind::Readonly) {
-                self.unexpected()?;
+                return Err(self.unexpected());
             }
         }
 
@@ -1038,7 +1038,7 @@ impl<'a> Parser<'a> {
             self.bump(Kind::Semicolon);
             Ok(self.ast.ts_index_signature(self.end_span(span), parameters, type_annotation))
         } else {
-            self.unexpected()
+            Err(self.unexpected())
         }
     }
 
@@ -1048,7 +1048,7 @@ impl<'a> Parser<'a> {
         let type_annotation = self.parse_ts_type_annotation()?;
 
         if type_annotation.is_none() {
-            self.unexpected()?;
+            return Err(self.unexpected());
         }
 
         Ok(self.ast.alloc(TSIndexSignatureName {