Get rid of PreParserIdentifier.

src/parser.cc

 // Copyright 2012 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 "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 374 matching lines @@
 
 #define CHECK_FAILED  /**/);   \
   if (failed_) return NULL; \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
-bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
-  return identifier == parser_->ast_value_factory()->eval_string() ||
-         identifier == parser_->ast_value_factory()->arguments_string();
-}
-
-
-bool ParserTraits::IsPrototype(const AstRawString* identifier) const {
-  return identifier == parser_->ast_value_factory()->prototype_string();
-}
-
-
-bool ParserTraits::IsConstructor(const AstRawString* identifier) const {
-  return identifier == parser_->ast_value_factory()->constructor_string();
-}
-
-
 bool ParserTraits::IsThisProperty(Expression* expression) {
   DCHECK(expression != NULL);
   Property* property = expression->AsProperty();
   return property != NULL && property->obj()->IsVariableProxy() &&
          property->obj()->AsVariableProxy()->is_this();
 }
 
 
 bool ParserTraits::IsIdentifier(Expression* expression) {
   VariableProxy* operand = expression->AsVariableProxy();
@@ skipping 226 matching lines @@
   }
   parser_->has_pending_error_ = true;
   parser_->pending_error_location_ = source_location;
   parser_->pending_error_message_ = message;
   parser_->pending_error_char_arg_ = NULL;
   parser_->pending_error_arg_ = arg;
   parser_->pending_error_is_reference_error_ = is_reference_error;
 }
 
 
-const AstRawString* ParserTraits::GetSymbol(Scanner* scanner) {
-  const AstRawString* result =
-      parser_->scanner()->CurrentSymbol(parser_->ast_value_factory());
-  DCHECK(result != NULL);
-  return result;
-}
-
-
-const AstRawString* ParserTraits::GetNumberAsSymbol(Scanner* scanner) {
-  double double_value = parser_->scanner()->DoubleValue();
-  char array[100];
-  const char* string =
-      DoubleToCString(double_value, Vector<char>(array, arraysize(array)));
-  return parser_->ast_value_factory()->GetOneByteString(string);
-}
-
-
-const AstRawString* ParserTraits::GetNextSymbol(Scanner* scanner) {
-  return parser_->scanner()->NextSymbol(parser_->ast_value_factory());
-}
-
-
 Expression* ParserTraits::ThisExpression(Scope* scope, AstNodeFactory* factory,
                                          int pos) {
   return factory->NewVariableProxy(scope->receiver(), pos);
 }
 
 Expression* ParserTraits::SuperReference(Scope* scope, AstNodeFactory* factory,
                                          int pos) {
   return factory->NewSuperReference(
       ThisExpression(scope, factory, pos)->AsVariableProxy(),
       pos);
@@ skipping 43 matching lines @@
   // for Traits::DeclareArrowParametersFromExpression() to be able to
   // pick the names of the parameters.
   return parser_->parsing_lazy_arrow_parameters_
       ? factory->NewVariableProxy(name, false, interface, pos)
       : scope->NewUnresolved(factory, name, interface, pos);
 }
 
 
 Expression* ParserTraits::ExpressionFromString(int pos, Scanner* scanner,
                                                AstNodeFactory* factory) {
-  const AstRawString* symbol = GetSymbol(scanner);
+  const AstRawString* symbol = parser_->GetSymbol(scanner);
   if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
   return factory->NewStringLiteral(symbol, pos);
 }
 
 
 Expression* ParserTraits::GetIterator(Expression* iterable,
                                       AstNodeFactory* factory) {
   Expression* iterator_symbol_literal =
       factory->NewSymbolLiteral("iterator_symbol", RelocInfo::kNoPosition);
   int pos = iterable->position();
@@ skipping 2742 matching lines @@
   Smi* literal_type = Smi::cast(value->get(kLiteralTypeSlot));
   return static_cast<LiteralType>(literal_type->value());
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetElements(Handle<FixedArray> value) {
   return Handle<FixedArray>(FixedArray::cast(value->get(kElementsSlot)));
 }
 
 
-bool CheckAndDeclareArrowParameter(ParserTraits* traits, Expression* expression,
+bool CheckAndDeclareArrowParameter(AstValueFactory* ast_value_factory,
+                                   Scanner* scanner, Expression* expression,
                                    Scope* scope, int* num_params,
                                    Scanner::Location* dupe_loc) {
   // Case for empty parameter lists:
   //   () => ...
   if (expression == NULL) return true;
 
   // Too many parentheses around expression:
   //   (( ... )) => ...
   if (expression->is_multi_parenthesized()) return false;
 
   // Case for a single parameter:
   //   (foo) => ...
   //   foo => ...
   if (expression->IsVariableProxy()) {
     if (expression->AsVariableProxy()->is_this()) return false;
 
     const AstRawString* raw_name = expression->AsVariableProxy()->raw_name();
-    if (traits->IsEvalOrArguments(raw_name) ||
-        traits->IsFutureStrictReserved(raw_name))
+    if (raw_name == ast_value_factory->eval_string() ||
+        raw_name == ast_value_factory->arguments_string() ||
+        scanner->IdentifierIsFutureStrictReserved(raw_name))
       return false;
 
     if (scope->IsDeclared(raw_name)) {
       *dupe_loc = Scanner::Location(
           expression->position(), expression->position() + raw_name->length());
       return false;
     }
 
     scope->DeclareParameter(raw_name, VAR);
     ++(*num_params);
     return true;
   }
 
   // Case for more than one parameter:
   //   (foo, bar [, ...]) => ...
   if (expression->IsBinaryOperation()) {
     BinaryOperation* binop = expression->AsBinaryOperation();
     if (binop->op() != Token::COMMA || binop->left()->is_parenthesized() ||
         binop->right()->is_parenthesized())
       return false;
 
-    return CheckAndDeclareArrowParameter(traits, binop->left(), scope,
-                                         num_params, dupe_loc) &&
-           CheckAndDeclareArrowParameter(traits, binop->right(), scope,
-                                         num_params, dupe_loc);
+    return CheckAndDeclareArrowParameter(ast_value_factory, scanner,
+                                         binop->left(), scope, num_params,
+                                         dupe_loc) &&
+           CheckAndDeclareArrowParameter(ast_value_factory, scanner,
+                                         binop->right(), scope, num_params,
+                                         dupe_loc);
   }
 
   // Any other kind of expression is not a valid parameter list.
   return false;
 }
 
 
 int ParserTraits::DeclareArrowParametersFromExpression(
     Expression* expression, Scope* scope, Scanner::Location* dupe_loc,
     bool* ok) {
   int num_params = 0;
   // Always reset the flag: It only needs to be set for the first expression
   // parsed as arrow function parameter list, becauseonly top-level functions
   // are parsed lazily.
   parser_->parsing_lazy_arrow_parameters_ = false;
-  *ok = CheckAndDeclareArrowParameter(this, expression, scope, &num_params,
-                                      dupe_loc);
+  *ok = CheckAndDeclareArrowParameter(parser_->ast_value_factory(),
+                                      parser_->scanner(), expression, scope,
+                                      &num_params, dupe_loc);
   return num_params;
 }
 
 
 FunctionLiteral* Parser::ParseFunctionLiteral(
     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 ::
@@ skipping 1872 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal