[parser] Refactor parser and preparser traits

src/parsing/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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast.h"
@@ skipping 631 matching lines @@
     // stack overflow. The isolate allows only one pending exception at at time
     // and we want to report the stack overflow later.
     return;
   }
   parser_->pending_error_handler_.ReportMessageAt(source_location.beg_pos,
                                                   source_location.end_pos,
                                                   message, arg, error_type);
 }
 
 
-const AstRawString* ParserTraits::GetSymbol(Scanner* scanner) {
+const AstRawString* ParserTraits::GetSymbol(Scanner* scanner) const {
   const AstRawString* result =
       parser_->scanner()->CurrentSymbol(parser_->ast_value_factory());
   DCHECK(result != NULL);
   return result;
 }
 
 
-const AstRawString* ParserTraits::GetNumberAsSymbol(Scanner* scanner) {
+const AstRawString* ParserTraits::GetNumberAsSymbol(Scanner* scanner) const {
   double double_value = parser_->scanner()->DoubleValue();
   char array[100];
   const char* string = DoubleToCString(double_value, ArrayVector(array));
   return parser_->ast_value_factory()->GetOneByteString(string);
 }
 
 
-const AstRawString* ParserTraits::GetNextSymbol(Scanner* scanner) {
+const AstRawString* ParserTraits::GetNextSymbol(Scanner* scanner) const {
   return parser_->scanner()->NextSymbol(parser_->ast_value_factory());
 }
 
-Expression* ParserTraits::ThisExpression(int pos) {
+Expression* ParserTraits::ThisExpression(int pos) const {
   return parser_->NewUnresolved(parser_->ast_value_factory()->this_string(),
                                 pos, pos + 4, Variable::THIS);
 }
 
 Expression* ParserTraits::NewSuperPropertyReference(AstNodeFactory* factory,
-                                                    int pos) {
+                                                    int pos) const {
   // this_function[home_object_symbol]
   VariableProxy* this_function_proxy = parser_->NewUnresolved(
       parser_->ast_value_factory()->this_function_string(), pos);
   Expression* home_object_symbol_literal =
       factory->NewSymbolLiteral("home_object_symbol", kNoSourcePosition);
   Expression* home_object = factory->NewProperty(
       this_function_proxy, home_object_symbol_literal, pos);
   return factory->NewSuperPropertyReference(
       ThisExpression(pos)->AsVariableProxy(), home_object, pos);
 }
 
 Expression* ParserTraits::NewSuperCallReference(AstNodeFactory* factory,
-                                                int pos) {
+                                                int pos) const {
   VariableProxy* new_target_proxy = parser_->NewUnresolved(
       parser_->ast_value_factory()->new_target_string(), pos);
   VariableProxy* this_function_proxy = parser_->NewUnresolved(
       parser_->ast_value_factory()->this_function_string(), pos);
   return factory->NewSuperCallReference(ThisExpression(pos)->AsVariableProxy(),
                                         new_target_proxy, this_function_proxy,
                                         pos);
 }
 
-Expression* ParserTraits::NewTargetExpression(int pos) {
+Expression* ParserTraits::NewTargetExpression(int pos) const {
   static const int kNewTargetStringLength = 10;
   auto proxy =
       parser_->NewUnresolved(parser_->ast_value_factory()->new_target_string(),
                              pos, pos + kNewTargetStringLength);
   proxy->set_is_new_target();
   return proxy;
 }
 
 Expression* ParserTraits::FunctionSentExpression(AstNodeFactory* factory,
-                                                 int pos) {
+                                                 int pos) const {
   // We desugar function.sent into %_GeneratorGetInputOrDebugPos(generator).
   Zone* zone = parser_->zone();
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(1, zone);
   VariableProxy* generator = factory->NewVariableProxy(
       parser_->function_state_->generator_object_variable());
   args->Add(generator, zone);
   return factory->NewCallRuntime(Runtime::kInlineGeneratorGetInputOrDebugPos,
                                  args, pos);
 }
 
 
 Literal* ParserTraits::ExpressionFromLiteral(Token::Value token, int pos,
                                              Scanner* scanner,
-                                             AstNodeFactory* factory) {
+                                             AstNodeFactory* factory) const {
   switch (token) {
     case Token::NULL_LITERAL:
       return factory->NewNullLiteral(pos);
     case Token::TRUE_LITERAL:
       return factory->NewBooleanLiteral(true, pos);
     case Token::FALSE_LITERAL:
       return factory->NewBooleanLiteral(false, pos);
     case Token::SMI: {
       int value = scanner->smi_value();
       return factory->NewSmiLiteral(value, pos);
     }
     case Token::NUMBER: {
       bool has_dot = scanner->ContainsDot();
       double value = scanner->DoubleValue();
       return factory->NewNumberLiteral(value, pos, has_dot);
     }
     default:
       DCHECK(false);
   }
   return NULL;
 }
 
 Expression* ParserTraits::ExpressionFromIdentifier(const AstRawString* name,
                                                    int start_position,
                                                    int end_position,
-                                                   InferName infer) {
+                                                   InferName infer) const {
   if (infer == InferName::kYes && parser_->fni_ != NULL) {
     parser_->fni_->PushVariableName(name);
   }
   return parser_->NewUnresolved(name, start_position, end_position);
 }
 
 
 Expression* ParserTraits::ExpressionFromString(int pos, Scanner* scanner,
-                                               AstNodeFactory* factory) {
+                                               AstNodeFactory* factory) const {
   const AstRawString* symbol = GetSymbol(scanner);
   if (parser_->fni_ != NULL) parser_->fni_->PushLiteralName(symbol);
   return factory->NewStringLiteral(symbol, pos);
 }
 
 
 Expression* ParserTraits::GetIterator(Expression* iterable,
                                       AstNodeFactory* factory, int pos) {
   Expression* iterator_symbol_literal =
       factory->NewSymbolLiteral("iterator_symbol", kNoSourcePosition);
   Expression* prop =
       factory->NewProperty(iterable, iterator_symbol_literal, pos);
   Zone* zone = parser_->zone();
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(0, zone);
   return factory->NewCall(prop, args, pos);
 }
 
 
 Literal* ParserTraits::GetLiteralTheHole(int position,
-                                         AstNodeFactory* factory) {
+                                         AstNodeFactory* factory) const {
   return factory->NewTheHoleLiteral(kNoSourcePosition);
 }
 
 
 Expression* ParserTraits::ParseV8Intrinsic(bool* ok) {
   return parser_->ParseV8Intrinsic(ok);
 }
 
 
 FunctionLiteral* ParserTraits::ParseFunctionLiteral(
@@ skipping 6230 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8