[parser] Refactor parser and preparser traits

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 57 matching lines @@
   bool IsArguments() const { return type_ == kArgumentsIdentifier; }
   bool IsEvalOrArguments() const { return IsEval() || IsArguments(); }
   bool IsUndefined() const { return type_ == kUndefinedIdentifier; }
   bool IsLet() const { return type_ == kLetIdentifier; }
   bool IsStatic() const { return type_ == kStaticIdentifier; }
   bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
   bool IsConstructor() const { return type_ == kConstructorIdentifier; }
   bool IsEnum() const { return type_ == kEnumIdentifier; }
   bool IsAwait() const { return type_ == kAwaitIdentifier; }
-  bool IsAsync() const { return type_ == kAsyncIdentifier; }
   bool IsFutureStrictReserved() const {
     return type_ == kFutureStrictReservedIdentifier ||
            type_ == kLetIdentifier || type_ == kStaticIdentifier ||
            type_ == kYieldIdentifier;
   }
 
   // Allow identifier->name()[->length()] to work. The preparser
   // does not need the actual positions/lengths of the identifiers.
   const PreParserIdentifier* operator->() const { return this; }
   const PreParserIdentifier raw_name() const { return *this; }
@@ skipping 526 matching lines @@
     typedef PreParserFormalParameters FormalParameters;
     typedef PreParserStatementList StatementList;
 
     // For constructing objects returned by the traversing functions.
     typedef PreParserFactory Factory;
   };
 
   explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
 
   // Helper functions for recursive descent.
-  static bool IsEval(PreParserIdentifier identifier) {
+  bool IsEval(PreParserIdentifier identifier) const {
     return identifier.IsEval();
   }
 
-  static bool IsArguments(PreParserIdentifier identifier) {
+  bool IsArguments(PreParserIdentifier identifier) const {
     return identifier.IsArguments();
   }
 
-  static bool IsAwait(PreParserIdentifier identifier) {
+  bool IsAwait(PreParserIdentifier identifier) const {
     return identifier.IsAwait();
   }
 
-  static bool IsAsync(PreParserIdentifier identifier) {
-    return identifier.IsAsync();
-  }
-
-  static bool IsEvalOrArguments(PreParserIdentifier identifier) {
+  bool IsEvalOrArguments(PreParserIdentifier identifier) const {
     return identifier.IsEvalOrArguments();
   }
 
-  static bool IsUndefined(PreParserIdentifier identifier) {
+  bool IsUndefined(PreParserIdentifier identifier) const {
     return identifier.IsUndefined();
   }
 
-  static bool IsPrototype(PreParserIdentifier identifier) {
+  bool IsPrototype(PreParserIdentifier identifier) const {
     return identifier.IsPrototype();
   }
 
-  static bool IsConstructor(PreParserIdentifier identifier) {
+  bool IsConstructor(PreParserIdentifier identifier) const {
     return identifier.IsConstructor();
   }
 
   // Returns true if the expression is of type "this.foo".
   static bool IsThisProperty(PreParserExpression expression) {
     return expression.IsThisProperty();
   }
 
   static bool IsIdentifier(PreParserExpression expression) {
     return expression.IsIdentifier();
   }
 
   static PreParserIdentifier AsIdentifier(PreParserExpression expression) {
     return expression.AsIdentifier();
   }
 
-  static bool IsEvalIdentifier(PreParserExpression expression) {
-    return IsIdentifier(expression) && IsEval(AsIdentifier(expression));
-  }
-
-  static bool IsDirectEvalCall(PreParserExpression expression) {
+  bool IsDirectEvalCall(PreParserExpression expression) const {
     return expression.IsDirectEvalCall();
   }
 
-  static bool IsFutureStrictReserved(PreParserIdentifier identifier) {
+  bool IsFutureStrictReserved(PreParserIdentifier identifier) const {
     return identifier.IsFutureStrictReserved();
   }
 
   static bool IsBoilerplateProperty(PreParserExpression property) {
     // PreParser doesn't count boilerplate properties.
     return false;
   }
 
   static bool IsArrayIndex(PreParserIdentifier string, uint32_t* index) {
     return false;
   }
 
   static PreParserExpression GetPropertyValue(PreParserExpression property) {
     return PreParserExpression::Default();
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
   static void PushLiteralName(FuncNameInferrer* fni, PreParserIdentifier id) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
 
-  static void PushPropertyName(FuncNameInferrer* fni,
-                               PreParserExpression expression) {
+  void PushPropertyName(FuncNameInferrer* fni, PreParserExpression expression) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
 
   static void InferFunctionName(FuncNameInferrer* fni,
                                 PreParserExpression expression) {
     // PreParser should not use FuncNameInferrer.
     UNREACHABLE();
   }
 
   static void CheckAssigningFunctionLiteralToProperty(
       PreParserExpression left, PreParserExpression right) {}
 
   static PreParserExpression MarkExpressionAsAssigned(
       PreParserExpression expression) {
     // TODO(marja): To be able to produce the same errors, the preparser needs
     // to start tracking which expressions are variables and which are assigned.
     return expression;
   }
 
   bool ShortcutNumericLiteralBinaryExpression(PreParserExpression* x,
                                               PreParserExpression y,
-                                              Token::Value op,
-                                              int pos,
+                                              Token::Value op, int pos,
                                               PreParserFactory* factory) {
     return false;
   }
 
   PreParserExpression BuildUnaryExpression(PreParserExpression expression,
                                            Token::Value op, int pos,
                                            PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   PreParserExpression BuildIteratorResult(PreParserExpression value,
                                           bool done) {
     return PreParserExpression::Default();
   }
+
   PreParserExpression NewThrowReferenceError(MessageTemplate::Template message,
                                              int pos) {
     return PreParserExpression::Default();
   }
+
   PreParserExpression NewThrowSyntaxError(MessageTemplate::Template message,
-                                          Handle<Object> arg, int pos) {
-    return PreParserExpression::Default();
-  }
-  PreParserExpression NewThrowTypeError(MessageTemplate::Template message,
-                                        Handle<Object> arg, int pos) {
+                                          PreParserIdentifier arg, int pos) {
     return PreParserExpression::Default();
   }
 
+  PreParserExpression NewThrowTypeError(MessageTemplate::Template message,
+                                        PreParserIdentifier arg, int pos) {
+    return PreParserExpression::Default();
+  }
+
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
                        MessageTemplate::Template message,
                        const char* arg = NULL,
                        ParseErrorType error_type = kSyntaxError);
-  void ReportMessageAt(int start_pos, int end_pos,
+  void ReportMessageAt(Scanner::Location location,
                        MessageTemplate::Template message,
-                       const char* arg = NULL,
+                       const AstRawString* arg,
                        ParseErrorType error_type = kSyntaxError);
 
   // A dummy function, just useful as an argument to CHECK_OK_CUSTOM.
   static void Void() {}
 
   // "null" return type creators.
   static PreParserIdentifier EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
   static PreParserIdentifier EmptyIdentifierString() {
     return PreParserIdentifier::Default();
   }
   static PreParserExpression EmptyExpression() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyObjectLiteralProperty() {
     return PreParserExpression::Default();
   }
   static PreParserExpression EmptyFunctionLiteral() {
     return PreParserExpression::Default();
   }
   static PreParserExpressionList NullExpressionList() {
     return PreParserExpressionList();
   }
 
   // Odd-ball literal creators.
-  static PreParserExpression GetLiteralTheHole(int position,
-                                               PreParserFactory* factory) {
+  PreParserExpression GetLiteralTheHole(int position,
+                                        PreParserFactory* factory) const {
     return PreParserExpression::Default();
   }
 
   // Producing data during the recursive descent.
   PreParserIdentifier GetSymbol(Scanner* scanner);
-  PreParserIdentifier GetNumberAsSymbol(Scanner* scanner);
-
-  static PreParserIdentifier GetNextSymbol(Scanner* scanner) {
+  PreParserIdentifier GetNumberAsSymbol(Scanner* scanner) {
     return PreParserIdentifier::Default();
   }
 
-  static PreParserExpression ThisExpression(int pos) {
+  PreParserIdentifier GetNextSymbol(Scanner* scanner) const {
+    return PreParserIdentifier::Default();
+  }
+
+  PreParserExpression ThisExpression(int pos = kNoSourcePosition) const {
     return PreParserExpression::This();
   }
 
-  static PreParserExpression NewSuperPropertyReference(
-      PreParserFactory* factory, int pos) {
+  PreParserExpression NewSuperPropertyReference(PreParserFactory* factory,
+                                                int pos) const {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression NewSuperCallReference(PreParserFactory* factory,
-                                                   int pos) {
+  PreParserExpression NewSuperCallReference(PreParserFactory* factory,
+                                            int pos) const {
     return PreParserExpression::SuperCallReference();
   }
 
-  static PreParserExpression NewTargetExpression(int pos) {
+  PreParserExpression NewTargetExpression(int pos) const {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression FunctionSentExpression(PreParserFactory* factory,
-                                                    int pos) {
+  PreParserExpression FunctionSentExpression(PreParserFactory* factory,
+                                             int pos) const {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression ExpressionFromLiteral(
-      Token::Value token, int pos, Scanner* scanner,
-      PreParserFactory* factory) {
+  PreParserExpression ExpressionFromLiteral(Token::Value token, int pos,
+                                            Scanner* scanner,
+                                            PreParserFactory* factory) const {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression ExpressionFromIdentifier(
+  PreParserExpression ExpressionFromIdentifier(
       PreParserIdentifier name, int start_position, int end_position,
-      InferName = InferName::kYes) {
+      InferName = InferName::kYes) const {
     return PreParserExpression::FromIdentifier(name);
   }
 
-  PreParserExpression ExpressionFromString(int pos,
-                                           Scanner* scanner,
-                                           PreParserFactory* factory = NULL);
+  PreParserExpression ExpressionFromString(int pos, Scanner* scanner,
+                                           PreParserFactory* factory);
 
   PreParserExpression GetIterator(PreParserExpression iterable,
                                   PreParserFactory* factory, int pos) {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpressionList NewExpressionList(int size, Zone* zone) {
+  PreParserExpressionList NewExpressionList(int size, Zone* zone) const {
     return PreParserExpressionList();
   }
 
-  static PreParserStatementList NewStatementList(int size, Zone* zone) {
+  PreParserStatementList NewStatementList(int size, Zone* zone) const {
     return PreParserStatementList();
   }
 
-  static PreParserExpressionList NewPropertyList(int size, Zone* zone) {
+  PreParserExpressionList NewPropertyList(int size, Zone* zone) const {
     return PreParserExpressionList();
   }
 
-  static void AddParameterInitializationBlock(
+  void AddParameterInitializationBlock(
       const PreParserFormalParameters& parameters, PreParserStatementList list,
-      bool is_async, bool* ok) {}
+      bool is_async, bool* ok) const {}
 
-  V8_INLINE void SkipLazyFunctionBody(int* materialized_literal_count,
-                                      int* expected_property_count, bool* ok) {
+  V8_INLINE void SkipLazyFunctionBody(
+      int* materialized_literal_count, int* expected_property_count, bool* ok,
+      Scanner::BookmarkScope* bookmark = nullptr) {
     UNREACHABLE();
   }
 
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
-      PreParserIdentifier function_name, int pos,
+      PreParserIdentifier name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE void ParseArrowFunctionFormalParameterList(
       PreParserFormalParameters* parameters, PreParserExpression expression,
       const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
       const Scope::Snapshot& scope_snapshot, bool* ok);
 
   void ParseAsyncArrowSingleExpressionBody(
       PreParserStatementList body, bool accept_IN,
       Type::ExpressionClassifier* classifier, int pos, bool* ok);
 
   V8_INLINE PreParserExpression ParseAsyncFunctionExpression(bool* ok);
 
-  void ReindexLiterals(const PreParserFormalParameters& paramaters) {}
+  void ReindexLiterals(const PreParserFormalParameters& parameters) {}
 
   struct TemplateLiteralState {};
 
   TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
   }
-  void AddTemplateSpan(TemplateLiteralState*, bool) {}
-  void AddTemplateExpression(TemplateLiteralState*, PreParserExpression) {}
-  PreParserExpression CloseTemplateLiteral(TemplateLiteralState*, int,
-                                           PreParserExpression tag) {
-    if (IsTaggedTemplate(tag)) {
-      // Emulate generation of array literals for tag callsite
-      // 1st is array of cooked strings, second is array of raw strings
-      MaterializeTemplateCallsiteLiterals();
-    }
-    return EmptyExpression();
-  }
-  inline void MaterializeTemplateCallsiteLiterals();
+  void AddTemplateSpan(TemplateLiteralState* state, bool tail) {}
+  void AddTemplateExpression(TemplateLiteralState* state,
+                             PreParserExpression expression) {}
+  V8_INLINE PreParserExpression CloseTemplateLiteral(
+      TemplateLiteralState* state, int start, PreParserExpression tag);
   PreParserExpression NoTemplateTag() {
     return PreParserExpression::NoTemplateTag();
   }
   static bool IsTaggedTemplate(const PreParserExpression tag) {
     return !tag.IsNoTemplateTag();
   }
 
   void AddFormalParameter(PreParserFormalParameters* parameters,
                           PreParserExpression pattern,
                           PreParserExpression initializer,
@@ skipping 19 matching lines @@
       int function_token_position, FunctionLiteral::FunctionType type,
       LanguageMode language_mode, bool* ok);
 
   PreParserExpression ParseClassLiteral(Type::ExpressionClassifier* classifier,
                                         PreParserIdentifier name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok);
 
   V8_INLINE void MarkCollectedTailCallExpressions() {}
-  V8_INLINE void MarkTailPosition(PreParserExpression) {}
+  V8_INLINE void MarkTailPosition(PreParserExpression expression) {}
 
   PreParserExpressionList PrepareSpreadArguments(PreParserExpressionList list) {
     return list;
   }
 
   inline void MaterializeUnspreadArgumentsLiterals(int count);
 
   inline PreParserExpression SpreadCall(PreParserExpression function,
                                         PreParserExpressionList args, int pos);
 
@@ skipping 11 matching lines @@
   inline PreParserExpression RewriteExponentiation(PreParserExpression left,
                                                    PreParserExpression right,
                                                    int pos) {
     return left;
   }
   inline PreParserExpression RewriteAssignExponentiation(
       PreParserExpression left, PreParserExpression right, int pos) {
     return left;
   }
 
-  inline void QueueDestructuringAssignmentForRewriting(PreParserExpression) {}
-  inline void QueueNonPatternForRewriting(PreParserExpression, bool* ok) {}
+  inline void QueueDestructuringAssignmentForRewriting(
+      PreParserExpression assignment) {}
+  inline void QueueNonPatternForRewriting(PreParserExpression expr, bool* ok) {}
 
-  void SetFunctionNameFromPropertyName(PreParserExpression,
-                                       PreParserIdentifier) {}
-  void SetFunctionNameFromIdentifierRef(PreParserExpression,
-                                        PreParserExpression) {}
+  void SetFunctionNameFromPropertyName(PreParserExpression property,
+                                       PreParserIdentifier name) {}
+  void SetFunctionNameFromIdentifierRef(PreParserExpression value,
+                                        PreParserExpression identifier) {}
 
   inline void RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                 bool* ok);
 
   inline PreParserExpression RewriteAwaitExpression(PreParserExpression value,
                                                     int pos);
 
   V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
       GetReportedErrorList() const;
   V8_INLINE Zone* zone() const;
   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const;
 
-  inline PreParserExpression RewriteYieldStar(
-      PreParserExpression generator, PreParserExpression expr, int pos);
+  inline PreParserExpression RewriteYieldStar(PreParserExpression generator,
+                                              PreParserExpression expression,
+                                              int pos);
 
  private:
   PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
@@ skipping 122 matching lines @@
   Statement ParseWhileStatement(bool* ok);
   Statement ParseForStatement(bool* ok);
   Statement ParseThrowStatement(bool* ok);
   Statement ParseTryStatement(bool* ok);
   Statement ParseDebuggerStatement(bool* ok);
   Expression ParseConditionalExpression(bool accept_IN, bool* ok);
   Expression ParseObjectLiteral(bool* ok);
   Expression ParseV8Intrinsic(bool* ok);
   Expression ParseDoExpression(bool* ok);
 
-  V8_INLINE void SkipLazyFunctionBody(int* materialized_literal_count,
-                                      int* expected_property_count, bool* ok);
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   Expression ParseFunctionLiteral(
       Identifier name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_pos, FunctionLiteral::FunctionType function_type,
       LanguageMode language_mode, bool* ok);
   void ParseLazyFunctionLiteralBody(bool* ok,
                                     Scanner::BookmarkScope* bookmark = nullptr);
 
   PreParserExpression ParseClassLiteral(ExpressionClassifier* classifier,
                                         PreParserIdentifier name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok);
 
   int* use_counts_;
 };
 
 
-void PreParserTraits::MaterializeTemplateCallsiteLiterals() {
-  pre_parser_->function_state_->NextMaterializedLiteralIndex();
-  pre_parser_->function_state_->NextMaterializedLiteralIndex();
-}
-
-
 void PreParserTraits::MaterializeUnspreadArgumentsLiterals(int count) {
   for (int i = 0; i < count; ++i) {
     pre_parser_->function_state_->NextMaterializedLiteralIndex();
   }
 }
 
 
 PreParserExpression PreParserTraits::SpreadCall(PreParserExpression function,
                                                 PreParserExpressionList args,
                                                 int pos) {
@@ skipping 75 matching lines @@
 
 
 PreParserStatementList PreParserTraits::ParseEagerFunctionBody(
     PreParserIdentifier function_name, int pos,
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
+PreParserExpression PreParserTraits::CloseTemplateLiteral(
+    TemplateLiteralState* state, int start, PreParserExpression tag) {
+  if (IsTaggedTemplate(tag)) {
+    // Emulate generation of array literals for tag callsite
+    // 1st is array of cooked strings, second is array of raw strings
+    pre_parser_->function_state_->NextMaterializedLiteralIndex();
+    pre_parser_->function_state_->NextMaterializedLiteralIndex();
+  }
+  return EmptyExpression();
+}
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H