[parser] Refactor parser and preparser traits

src/parsing/parser.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 398 matching lines @@
 
   static const AstRawString* AsIdentifier(Expression* expression) {
     DCHECK(IsIdentifier(expression));
     return expression->AsVariableProxy()->raw_name();
   }
 
   bool IsPrototype(const AstRawString* identifier) const;
 
   bool IsConstructor(const AstRawString* identifier) const;
 
-  bool IsDirectEvalCall(Expression* expression) {
+  bool IsDirectEvalCall(Expression* expression) const {
     if (!expression->IsCall()) return false;
     expression = expression->AsCall()->expression();
     return IsIdentifier(expression) && IsEval(AsIdentifier(expression));
   }
 
   static bool IsBoilerplateProperty(ObjectLiteral::Property* property) {
     return ObjectLiteral::IsBoilerplateProperty(property);
   }
 
   static bool IsArrayIndex(const AstRawString* string, uint32_t* index) {
@@ skipping 78 matching lines @@
   static const AstRawString* EmptyIdentifier() { return nullptr; }
   static Expression* EmptyExpression() { return nullptr; }
   static Literal* EmptyLiteral() { return nullptr; }
   static ObjectLiteralProperty* EmptyObjectLiteralProperty() { return nullptr; }
   static FunctionLiteral* EmptyFunctionLiteral() { return nullptr; }
 
   // Used in error return values.
   static ZoneList<Expression*>* NullExpressionList() { return nullptr; }
 
   // Non-NULL empty string.
-  V8_INLINE const AstRawString* EmptyIdentifierString();
+  V8_INLINE const AstRawString* EmptyIdentifierString() const;
 
   // Odd-ball literal creators.
-  Literal* GetLiteralTheHole(int position, AstNodeFactory* factory);
+  Literal* GetLiteralTheHole(int position, AstNodeFactory* factory) const;
 
   // Producing data during the recursive descent.
-  const AstRawString* GetSymbol(Scanner* scanner);
-  const AstRawString* GetNextSymbol(Scanner* scanner);
-  const AstRawString* GetNumberAsSymbol(Scanner* scanner);
+  const AstRawString* GetSymbol(Scanner* scanner) const;
+  const AstRawString* GetNextSymbol(Scanner* scanner) const;
+  const AstRawString* GetNumberAsSymbol(Scanner* scanner) const;
 
-  Expression* ThisExpression(int pos);
-  Expression* NewSuperPropertyReference(AstNodeFactory* factory, int pos);
-  Expression* NewSuperCallReference(AstNodeFactory* factory, int pos);
-  Expression* NewTargetExpression(int pos);
-  Expression* FunctionSentExpression(AstNodeFactory* factory, int pos);
+  Expression* ThisExpression(int pos = kNoSourcePosition) const;
+  Expression* NewSuperPropertyReference(AstNodeFactory* factory, int pos) const;
+  Expression* NewSuperCallReference(AstNodeFactory* factory, int pos) const;
+  Expression* NewTargetExpression(int pos) const;
+  Expression* FunctionSentExpression(AstNodeFactory* factory, int pos) const;
   Literal* ExpressionFromLiteral(Token::Value token, int pos, Scanner* scanner,
-                                 AstNodeFactory* factory);
+                                 AstNodeFactory* factory) const;
   Expression* ExpressionFromIdentifier(const AstRawString* name,
                                        int start_position, int end_position,
-                                       InferName = InferName::kYes);
+                                       InferName = InferName::kYes) const;
   Expression* ExpressionFromString(int pos, Scanner* scanner,
-                                   AstNodeFactory* factory);
+                                   AstNodeFactory* factory) const;
   Expression* GetIterator(Expression* iterable, AstNodeFactory* factory,
                           int pos);
-  ZoneList<v8::internal::Expression*>* NewExpressionList(int size, Zone* zone) {
+  ZoneList<v8::internal::Expression*>* NewExpressionList(int size,
+                                                         Zone* zone) const {
     return new(zone) ZoneList<v8::internal::Expression*>(size, zone);
   }
-  ZoneList<ObjectLiteral::Property*>* NewPropertyList(int size, Zone* zone) {
+  ZoneList<ObjectLiteral::Property*>* NewPropertyList(int size,
+                                                      Zone* zone) const {
     return new(zone) ZoneList<ObjectLiteral::Property*>(size, zone);
   }
-  ZoneList<v8::internal::Statement*>* NewStatementList(int size, Zone* zone) {
+  ZoneList<v8::internal::Statement*>* NewStatementList(int size,
+                                                       Zone* zone) const {
     return new(zone) ZoneList<v8::internal::Statement*>(size, zone);
   }
 
   V8_INLINE void AddParameterInitializationBlock(
       const ParserFormalParameters& parameters,
-      ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok);
+      ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok) const;
 
   void ParseAsyncArrowSingleExpressionBody(
       ZoneList<Statement*>* body, bool accept_IN,
       Type::ExpressionClassifier* classifier, int pos, bool* ok);
 
   V8_INLINE void AddFormalParameter(ParserFormalParameters* parameters,
                                     Expression* pattern,
                                     Expression* initializer,
                                     int initializer_end_position, bool is_rest);
   V8_INLINE void DeclareFormalParameter(
@@ skipping 616 matching lines @@
   void Print(AstNode* node);
 #endif  // DEBUG
 };
 
 
 bool ParserTraits::IsFutureStrictReserved(
     const AstRawString* identifier) const {
   return parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
 }
 
-const AstRawString* ParserTraits::EmptyIdentifierString() {
+const AstRawString* ParserTraits::EmptyIdentifierString() const {
   return parser_->ast_value_factory()->empty_string();
 }
 
 
 void ParserTraits::SkipLazyFunctionBody(int* materialized_literal_count,
                                         int* expected_property_count, bool* ok,
                                         Scanner::BookmarkScope* bookmark) {
   return parser_->SkipLazyFunctionBody(materialized_literal_count,
                                        expected_property_count, ok, bookmark);
 }
@@ skipping 117 matching lines @@
   if (is_sloppy(scope->language_mode())) {
     // TODO(sigurds) Mark every parameter as maybe assigned. This is a
     // conservative approximation necessary to account for parameters
     // that are assigned via the arguments array.
     var->set_maybe_assigned();
   }
 }
 
 void ParserTraits::AddParameterInitializationBlock(
     const ParserFormalParameters& parameters,
-    ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok) {
+    ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok) const {
   if (!parameters.is_simple) {
     auto* init_block =
         parser_->BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
 
     if (is_async) {
       init_block = parser_->BuildRejectPromiseOnException(init_block);
     }
 
     if (init_block != nullptr) {
@@ skipping 12 matching lines @@
 
 Expression* ParserTraits::RewriteYieldStar(Expression* generator,
                                            Expression* iterable, int pos) {
   return parser_->RewriteYieldStar(generator, iterable, pos);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_