refactor(parser): simplify parsing literal types (#16572)

I first noticed that `parse_literal_type_node` was always called with
`negative` = `false`. Then I split function
`parse_rest_of_literal_type_node` into the more specific functions
`parse_literal_type` and `parse_literal_type_negative` and inlined code
for parsing `Kind::NoSubstitutionTemplate`.

This avoids some redundant checks, makes code simpler and leads to nine
lines less code.

Author: ulrichstark

crates/oxc_parser/src/ts/types.rs

@@ -380,11 +380,13 @@ impl<'a> ParserImpl<'a> {
             // return parseJSDocFunctionType();
             Kind::Question => self.parse_js_doc_unknown_or_nullable_type(),
             Kind::Bang => self.parse_js_doc_non_nullable_type(),
-            Kind::NoSubstitutionTemplate | Kind::Str | Kind::True | Kind::False => {
-                self.parse_literal_type_node(/* negative */ false)
-            }
-            kind if kind.is_number() => {
-                self.parse_literal_type_node(/* negative */ false)
+            Kind::Str | Kind::True | Kind::False => self.parse_literal_type(),
+            kind if kind.is_number() => self.parse_literal_type(),
+            Kind::NoSubstitutionTemplate => {
+                let span = self.start_span();
+                let literal = self.parse_template_literal(false);
+                let span = self.end_span(span);
+                self.ast.ts_type_literal_type(span, TSLiteral::TemplateLiteral(self.alloc(literal)))
             }
             Kind::Minus => {
                 let checkpoint = self.checkpoint();
@@ -393,7 +395,7 @@ impl<'a> ParserImpl<'a> {
                 self.bump_any(); // bump `-`
 
                 if self.cur_kind().is_number() {
-                    self.parse_rest_of_literal_type_node(minus_start_span, /* negative */ true)
+                    self.parse_literal_type_negative(minus_start_span)
                 } else {
                     self.rewind(checkpoint);
                     self.parse_type_reference()
@@ -984,39 +986,28 @@ impl<'a> ParserImpl<'a> {
         }
     }
 
-    fn parse_literal_type_node(&mut self, negative: bool) -> TSType<'a> {
+    fn parse_literal_type(&mut self) -> TSType<'a> {
         let span = self.start_span();
-        if negative {
-            self.bump_any(); // bump `-`
-        }
-
-        self.parse_rest_of_literal_type_node(span, negative)
-    }
-
-    fn parse_rest_of_literal_type_node(&mut self, span: u32, negative: bool) -> TSType<'a> {
-        let expression = if self.at(Kind::NoSubstitutionTemplate) {
-            self.parse_template_literal_expression(false)
-        } else {
-            self.parse_literal_expression()
-        };
-
+        let expression = self.parse_literal_expression();
         let span = self.end_span(span);
-        let literal = if negative {
-            match self.ast.expression_unary(span, UnaryOperator::UnaryNegation, expression) {
-                Expression::UnaryExpression(unary_expr) => TSLiteral::UnaryExpression(unary_expr),
-                _ => unreachable!(),
-            }
-        } else {
-            match expression {
-                Expression::BooleanLiteral(literal) => TSLiteral::BooleanLiteral(literal),
-                Expression::NumericLiteral(literal) => TSLiteral::NumericLiteral(literal),
-                Expression::BigIntLiteral(literal) => TSLiteral::BigIntLiteral(literal),
-                Expression::StringLiteral(literal) => TSLiteral::StringLiteral(literal),
-                Expression::TemplateLiteral(literal) => TSLiteral::TemplateLiteral(literal),
-                _ => return self.unexpected(),
-            }
+        let literal = match expression {
+            Expression::BooleanLiteral(literal) => TSLiteral::BooleanLiteral(literal),
+            Expression::NumericLiteral(literal) => TSLiteral::NumericLiteral(literal),
+            Expression::BigIntLiteral(literal) => TSLiteral::BigIntLiteral(literal),
+            Expression::StringLiteral(literal) => TSLiteral::StringLiteral(literal),
+            _ => return self.unexpected(),
         };
+        self.ast.ts_type_literal_type(span, literal)
+    }
 
+    fn parse_literal_type_negative(&mut self, span: u32) -> TSType<'a> {
+        let literal_expr = self.parse_literal_expression();
+        let span = self.end_span(span);
+        let literal = TSLiteral::UnaryExpression(self.ast.alloc_unary_expression(
+            span,
+            UnaryOperator::UnaryNegation,
+            literal_expr,
+        ));
         self.ast.ts_type_literal_type(span, literal)
     }