Get rid of PreParserIdentifier.

src/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 24 matching lines @@
 void PreParserTraits::ReportMessageAt(int start_pos,
                                       int end_pos,
                                       const char* message,
                                       const char* arg,
                                       bool is_reference_error) {
   pre_parser_->log_->LogMessage(start_pos, end_pos, message, arg,
                                 is_reference_error);
 }
 
 
-PreParserIdentifier PreParserTraits::GetSymbol(Scanner* scanner) {
-  if (scanner->current_token() == Token::FUTURE_RESERVED_WORD) {
-    return PreParserIdentifier::FutureReserved();
-  } else if (scanner->current_token() ==
-             Token::FUTURE_STRICT_RESERVED_WORD) {
-    return PreParserIdentifier::FutureStrictReserved();
-  } else if (scanner->current_token() == Token::LET) {
-    return PreParserIdentifier::Let();
-  } else if (scanner->current_token() == Token::STATIC) {
-    return PreParserIdentifier::Static();
-  } else if (scanner->current_token() == Token::YIELD) {
-    return PreParserIdentifier::Yield();
-  }
-  if (scanner->UnescapedLiteralMatches("eval", 4)) {
-    return PreParserIdentifier::Eval();
-  }
-  if (scanner->UnescapedLiteralMatches("arguments", 9)) {
-    return PreParserIdentifier::Arguments();
-  }
-  if (scanner->LiteralMatches("prototype", 9)) {
-    return PreParserIdentifier::Prototype();
-  }
-  if (scanner->LiteralMatches("constructor", 11)) {
-    return PreParserIdentifier::Constructor();
-  }
-  return PreParserIdentifier::Default();
+PreParserExpression PreParserTraits::ExpressionFromIdentifier(
+    const AstRawString* name, int pos, Scope* scope,
+    PreParserFactory* factory) {
+  bool is_valid_arrow_function_param =
+      !(pre_parser_->IsEvalOrArguments(name) ||
+        pre_parser_->scanner()->IdentifierIsFutureStrictReserved(name));
+  return PreParserExpression::FromIdentifier(name,
+                                             is_valid_arrow_function_param);
 }
 
 
-PreParserIdentifier PreParserTraits::GetNumberAsSymbol(Scanner* scanner) {
-  return PreParserIdentifier::Default();
-}
-
-
 PreParserExpression PreParserTraits::ExpressionFromString(
     int pos, Scanner* scanner, PreParserFactory* factory) {
   if (scanner->UnescapedLiteralMatches("use strict", 10)) {
     return PreParserExpression::UseStrictStringLiteral();
   } else if (scanner->UnescapedLiteralMatches("use strong", 10)) {
     return PreParserExpression::UseStrongStringLiteral();
   }
   return PreParserExpression::StringLiteral();
 }
 
 
 PreParserExpression PreParserTraits::ParseV8Intrinsic(bool* ok) {
   return pre_parser_->ParseV8Intrinsic(ok);
 }
 
 
 PreParserExpression PreParserTraits::ParseFunctionLiteral(
-    PreParserIdentifier name, Scanner::Location function_name_location,
+    const AstRawString* name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind,
     int function_token_position, FunctionLiteral::FunctionType type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   return pre_parser_->ParseFunctionLiteral(
       name, function_name_location, name_is_strict_reserved, kind,
       function_token_position, type, arity_restriction, ok);
 }
 
 
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
@@ skipping 21 matching lines @@
     if (is_strict(scope_->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
     }
   }
   return kPreParseSuccess;
 }
 
 
 PreParserExpression PreParserTraits::ParseClassLiteral(
-    PreParserIdentifier name, Scanner::Location class_name_location,
+    const AstRawString* name, Scanner::Location class_name_location,
     bool name_is_strict_reserved, int pos, bool* ok) {
   return pre_parser_->ParseClassLiteral(name, class_name_location,
                                         name_is_strict_reserved, pos, ok);
 }
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparser-data.h for the data.
 
@@ skipping 183 matching lines @@
 PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
   bool is_strict_reserved = false;
-  Identifier name = ParseIdentifierOrStrictReservedWord(
-      &is_strict_reserved, CHECK_OK);
+  const AstRawString* name =
+      ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name, scanner()->location(), is_strict_reserved,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
   Expect(Token::CLASS, CHECK_OK);
   if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
     ReportMessage("sloppy_lexical");
     *ok = false;
     return Statement::Default();
   }
 
   int pos = position();
   bool is_strict_reserved = false;
-  Identifier name =
+  const AstRawString* name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
                     CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' Statement* '}'
@@ skipping 133 matching lines @@
   }
 
   bool starts_with_identifier = peek_any_identifier();
   Expression expr = ParseExpression(true, CHECK_OK);
   // Even if the expression starts with an identifier, it is not necessarily an
   // identifier. For example, "foo + bar" starts with an identifier but is not
   // an identifier.
   if (starts_with_identifier && expr.IsIdentifier() && peek() == Token::COLON) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
-    DCHECK(!expr.AsIdentifier().IsFutureReserved());
+    DCHECK(!scanner()->IdentifierIsFutureReserved(expr.AsIdentifier()));
     DCHECK(is_sloppy(language_mode()) ||
-           !IsFutureStrictReserved(expr.AsIdentifier()));
+           !scanner()->IdentifierIsFutureStrictReserved(expr.AsIdentifier()));
     Consume(Token::COLON);
     return ParseStatement(ok);
     // Preparsing is disabled for extensions (because the extension details
     // aren't passed to lazily compiled functions), so we don't
     // accept "native function" in the preparser.
   }
   // Parsed expression statement.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (peek() == Token::IDENTIFIER && is_sloppy(language_mode()) &&
-      expr.IsIdentifier() && expr.AsIdentifier().IsLet()) {
+      expr.IsIdentifier() && expr.AsIdentifier()->IsOneByteEqualTo("let")) {
     ReportMessage("sloppy_lexical", NULL);
     *ok = false;
     return Statement::Default();
   }
   ExpectSemicolon(CHECK_OK);
   return Statement::ExpressionStatement(expr);
 }
 
 
 PreParser::Statement PreParser::ParseIfStatement(bool* ok) {
@@ skipping 186 matching lines @@
       if (accept_IN && CheckInOrOf(accept_OF)) {
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
 
         ParseStatement(CHECK_OK);
         return Statement::Default();
       }
     } else {
       Expression lhs = ParseExpression(false, CHECK_OK);
       is_let_identifier_expression =
-          lhs.IsIdentifier() && lhs.AsIdentifier().IsLet();
+          lhs.IsIdentifier() && lhs.AsIdentifier()->IsOneByteEqualTo("let");
       if (CheckInOrOf(lhs.IsIdentifier())) {
         ParseExpression(true, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
 
         ParseStatement(CHECK_OK);
         return Statement::Default();
       }
     }
   }
 
@@ skipping 95 matching lines @@
 
 #undef CHECK_OK
 #define CHECK_OK  ok);                     \
   if (!*ok) return Expression::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
 PreParser::Expression PreParser::ParseFunctionLiteral(
-    Identifier function_name, Scanner::Location function_name_location,
+    const AstRawString* function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
 
   // Parse function body.
   bool outer_is_script_scope = scope_->is_script_scope();
   Scope* function_scope = NewScope(scope_, FUNCTION_SCOPE);
   PreParserFactory factory(NULL);
@@ skipping 15 matching lines @@
   bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
       (peek() == Token::RPAREN &&
        arity_restriction != FunctionLiteral::SETTER_ARITY);
   while (!done) {
     bool is_strict_reserved = false;
     is_rest = peek() == Token::ELLIPSIS && allow_harmony_rest_params();
     if (is_rest) {
       Consume(Token::ELLIPSIS);
     }
 
-    Identifier param_name =
+    const AstRawString* param_name =
         ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
-    if (!eval_args_error_loc.IsValid() && param_name.IsEvalOrArguments()) {
+    if (!eval_args_error_loc.IsValid() && IsEvalOrArguments(param_name)) {
       eval_args_error_loc = scanner()->location();
     }
     if (!reserved_error_loc.IsValid() && is_strict_reserved) {
       reserved_error_loc = scanner()->location();
     }
 
     int prev_value = scanner()->FindSymbol(&duplicate_finder, 1);
 
     if (!dupe_error_loc.IsValid() && prev_value != 0) {
       dupe_error_loc = scanner()->location();
@@ skipping 52 matching lines @@
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   log_->LogFunction(
       body_start, body_end, function_state_->materialized_literal_count(),
       function_state_->expected_property_count(), language_mode());
 }
 
 
 PreParserExpression PreParser::ParseClassLiteral(
-    PreParserIdentifier name, Scanner::Location class_name_location,
+    const AstRawString* name, Scanner::Location class_name_location,
     bool name_is_strict_reserved, int pos, bool* ok) {
   // All parts of a ClassDeclaration and ClassExpression are strict code.
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location, "unexpected_strict_reserved");
     *ok = false;
     return EmptyExpression();
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, "strict_eval_arguments");
     *ok = false;
@@ skipping 44 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal