[parser] Restructure ParsePrimaryExpression

Use token ranges for parsing identifiers and literals.

Change-Id: Ic6af2c4012033d7f7c69181f90aa6b1b9c2b2a60
Reviewed-on: https://chromium-review.googlesource.com/c/1280224Reviewed-by: Igor Sheludko <ishell@chromium.org>
Commit-Queue: Toon Verwaest <verwaest@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56648}

src/parsing/parser-base.h

@@ -1772,6 +1772,26 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePrimaryExpression(
 
   int beg_pos = peek_position();
   Token::Value token = peek();
+
+  if (IsInRange(token, Token::IDENTIFIER,
+                Token::ESCAPED_STRICT_RESERVED_WORD)) {
+    if (token == Token::ASYNC && !scanner()->HasLineTerminatorAfterNext() &&
+        PeekAhead() == Token::FUNCTION) {
+      BindingPatternUnexpectedToken();
+      Consume(Token::ASYNC);
+      return ParseAsyncFunctionLiteral(ok);
+    }
+    // Using eval or arguments in this context is OK even in strict mode.
+    IdentifierT name = ParseAndClassifyIdentifier(CHECK_OK);
+    return impl()->ExpressionFromIdentifier(name, beg_pos);
+  }
+  DCHECK_IMPLIES(Token::IsAnyIdentifier(token), token == Token::ENUM);
+
+  if (Token::IsLiteral(token)) {
+    BindingPatternUnexpectedToken();
+    return impl()->ExpressionFromLiteral(Next(), beg_pos);
+  }
+
   switch (token) {
     case Token::THIS: {
       BindingPatternUnexpectedToken();
@@ -1779,48 +1799,6 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParsePrimaryExpression(
       return impl()->ThisExpression(beg_pos);
     }
 
-    case Token::NULL_LITERAL:
-    case Token::TRUE_LITERAL:
-    case Token::FALSE_LITERAL:
-    case Token::SMI:
-    case Token::NUMBER:
-    case Token::BIGINT: {
-      // Ensure continuous enum range.
-      DCHECK(Token::IsLiteral(token));
-      BindingPatternUnexpectedToken();
-      return impl()->ExpressionFromLiteral(Next(), beg_pos);
-    }
-    case Token::STRING: {
-      DCHECK(Token::IsLiteral(token));
-      BindingPatternUnexpectedToken();
-      Consume(Token::STRING);
-      return impl()->ExpressionFromString(beg_pos);
-    }
-
-    case Token::ASYNC:
-      if (!scanner()->HasLineTerminatorAfterNext() &&
-          PeekAhead() == Token::FUNCTION) {
-        BindingPatternUnexpectedToken();
-        Consume(Token::ASYNC);
-        return ParseAsyncFunctionLiteral(ok);
-      }
-      // CoverCallExpressionAndAsyncArrowHead
-      V8_FALLTHROUGH;
-    case Token::IDENTIFIER:
-    case Token::LET:
-    case Token::STATIC:
-    case Token::YIELD:
-    case Token::AWAIT:
-    case Token::FUTURE_STRICT_RESERVED_WORD:
-    case Token::ESCAPED_STRICT_RESERVED_WORD: {
-      // Ensure continuous enum range.
-      DCHECK(IsInRange(token, Token::IDENTIFIER,
-                       Token::ESCAPED_STRICT_RESERVED_WORD));
-      // Using eval or arguments in this context is OK even in strict mode.
-      IdentifierT name = ParseAndClassifyIdentifier(CHECK_OK);
-      return impl()->ExpressionFromIdentifier(name, beg_pos);
-    }
-
     case Token::ASSIGN_DIV:
     case Token::DIV:
       classifier()->RecordBindingPatternError(

src/parsing/parser.cc

@@ -351,6 +351,11 @@ Literal* Parser::ExpressionFromLiteral(Token::Value token, int pos) {
     case Token::BIGINT:
       return factory()->NewBigIntLiteral(
           AstBigInt(scanner()->CurrentLiteralAsCString(zone())), pos);
+    case Token::STRING: {
+      const AstRawString* symbol = GetSymbol();
+      fni_.PushLiteralName(symbol);
+      return factory()->NewStringLiteral(symbol, pos);
+    }
     default:
       DCHECK(false);
   }

src/parsing/parser.h

@@ -876,12 +876,6 @@ class V8_EXPORT_PRIVATE Parser : public NON_EXPORTED_BASE(ParserBase<Parser>) {
     return NewUnresolved(name, start_position);
   }
 
-  V8_INLINE Expression* ExpressionFromString(int pos) {
-    const AstRawString* symbol = GetSymbol();
-    fni_.PushLiteralName(symbol);
-    return factory()->NewStringLiteral(symbol, pos);
-  }
-
   V8_INLINE ZonePtrList<Expression>* NewExpressionList(int size) const {
     return new (zone()) ZonePtrList<Expression>(size, zone());
   }

src/parsing/preparser.h

@@ -1622,20 +1622,17 @@ class PreParser : public ParserBase<PreParser> {
 
   V8_INLINE PreParserExpression ExpressionFromLiteral(Token::Value token,
                                                       int pos) {
-    return PreParserExpression::Default();
-  }
-
-  PreParserExpression ExpressionFromIdentifier(
-      const PreParserIdentifier& name, int start_position,
-      InferName infer = InferName::kYes);
-
-  V8_INLINE PreParserExpression ExpressionFromString(int pos) {
+    if (token != Token::STRING) return PreParserExpression::Default();
     if (scanner()->IsUseStrict()) {
       return PreParserExpression::UseStrictStringLiteral();
     }
     return PreParserExpression::StringLiteral();
   }
 
+  PreParserExpression ExpressionFromIdentifier(
+      const PreParserIdentifier& name, int start_position,
+      InferName infer = InferName::kYes);
+
   V8_INLINE PreParserExpressionList NewExpressionList(int size) const {
     return PreParserExpressionList();
   }