[parser] Clean up (pre)parser 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-expression-rewriter.h"
@@ skipping 660 matching lines @@
   Zone* zone = delegate()->zone();
   ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(0, zone);
   return factory->NewCall(prop, args, pos);
 }
 
 Literal* ParserBaseTraits<Parser>::GetLiteralTheHole(
     int position, AstNodeFactory* factory) const {
   return factory->NewTheHoleLiteral(kNoSourcePosition);
 }
 
-Expression* ParserBaseTraits<Parser>::ParseV8Intrinsic(bool* ok) {
-  return delegate()->ParseV8Intrinsic(ok);
-}
-
-FunctionLiteral* ParserBaseTraits<Parser>::ParseFunctionLiteral(
-    const AstRawString* name, Scanner::Location function_name_location,
-    FunctionNameValidity function_name_validity, FunctionKind kind,
-    int function_token_position, FunctionLiteral::FunctionType type,
-    LanguageMode language_mode, bool* ok) {
-  return delegate()->ParseFunctionLiteral(
-      name, function_name_location, function_name_validity, kind,
-      function_token_position, type, language_mode, ok);
-}
-
-Expression* ParserBaseTraits<Parser>::ParseClassLiteral(
-    Type::ExpressionClassifier* classifier, const AstRawString* name,
-    Scanner::Location class_name_location, bool name_is_strict_reserved,
-    int pos, bool* ok) {
-  return delegate()->ParseClassLiteral(classifier, name, class_name_location,
-                                       name_is_strict_reserved, pos, ok);
-}
-
-void ParserBaseTraits<Parser>::MarkTailPosition(Expression* expression) {
+void Parser::MarkTailPosition(Expression* expression) {
   expression->MarkTail();
 }
 
-void ParserBaseTraits<Parser>::MarkCollectedTailCallExpressions() {
-  delegate()->MarkCollectedTailCallExpressions();
-}
-
 Parser::Parser(ParseInfo* info)
     : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
                          info->extension(), info->ast_value_factory(), NULL),
       scanner_(info->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
       target_stack_(NULL),
       compile_options_(info->compile_options()),
       cached_parse_data_(NULL),
       total_preparse_skipped_(0),
@@ skipping 212 matching lines @@
       if (body->length() != 1 ||
           !body->at(0)->IsExpressionStatement() ||
           !body->at(0)->AsExpressionStatement()->
               expression()->IsFunctionLiteral()) {
         ReportMessage(MessageTemplate::kSingleFunctionLiteral);
         ok = false;
       }
     }
 
     if (ok) {
-      ParserBaseTraits<Parser>::RewriteDestructuringAssignments();
+      RewriteDestructuringAssignments();
       result = factory()->NewScriptOrEvalFunctionLiteral(
           scope, body, function_state.materialized_literal_count(),
           function_state.expected_property_count());
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
@@ skipping 3023 matching lines @@
   if (expr->IsAssignment()) {
     Assignment* assignment = expr->AsAssignment();
     DCHECK(!assignment->is_compound());
     initializer = assignment->value();
     expr = assignment->target();
   }
 
   AddFormalParameter(parameters, expr, initializer, end_pos, is_rest);
 }
 
-void ParserBaseTraits<Parser>::ParseAsyncArrowSingleExpressionBody(
-    ZoneList<Statement*>* body, bool accept_IN,
-    Type::ExpressionClassifier* classifier, int pos, bool* ok) {
-  delegate()->DesugarAsyncFunctionBody(
-      delegate()->ast_value_factory()->empty_string(), delegate()->scope(),
-      body, classifier, kAsyncArrowFunction,
-      Parser::FunctionBodyType::kSingleExpression, accept_IN, pos, ok);
-}
-
 void Parser::DesugarAsyncFunctionBody(const AstRawString* function_name,
                                       Scope* scope, ZoneList<Statement*>* body,
                                       ExpressionClassifier* classifier,
                                       FunctionKind kind,
                                       FunctionBodyType body_type,
                                       bool accept_IN, int pos, bool* ok) {
   // function async_function() {
   //   try {
   //     .generator_object = %CreateGeneratorObject();
   //     ... function body ...
@@ skipping 17 matching lines @@
 
   ZoneList<Statement*>* inner_body = try_block->statements();
 
   Expression* return_value = nullptr;
   if (body_type == FunctionBodyType::kNormal) {
     ParseStatementList(inner_body, Token::RBRACE, CHECK_OK_VOID);
     return_value = factory()->NewUndefinedLiteral(kNoSourcePosition);
   } else {
     return_value =
         ParseAssignmentExpression(accept_IN, classifier, CHECK_OK_VOID);
-    ParserBaseTraits<Parser>::RewriteNonPattern(classifier, CHECK_OK_VOID);
+    RewriteNonPattern(classifier, CHECK_OK_VOID);
   }
 
   return_value = BuildPromiseResolve(return_value, return_value->position());
   inner_body->Add(
       factory()->NewReturnStatement(return_value, return_value->position()),
       zone());
   body->Add(BuildRejectPromiseOnException(try_block), zone());
   scope->set_end_position(scanner()->location().end_pos);
 }
 
@@ skipping 283 matching lines @@
     if (is_strict(language_mode)) {
       CheckStrictOctalLiteral(scope->start_position(), scope->end_position(),
                               CHECK_OK);
       CheckDecimalLiteralWithLeadingZero(use_counts_, scope->start_position(),
                                          scope->end_position());
     }
     CheckConflictingVarDeclarations(scope, CHECK_OK);
 
     if (body) {
       // If body can be inspected, rewrite queued destructuring assignments
-      ParserBaseTraits<Parser>::RewriteDestructuringAssignments();
+      RewriteDestructuringAssignments();
     }
     has_duplicate_parameters =
       !formals_classifier.is_valid_formal_parameter_list_without_duplicates();
 
     if (use_temp_zone) {
       DCHECK(main_scope != scope);
       scope->AnalyzePartially(main_scope, &previous_zone_ast_node_factory);
     }
   }  // DiscardableZoneScope goes out of scope.
 
@@ skipping 1001 matching lines @@
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (produce_cached_parse_data()) {
     if (result != NULL) *info->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
 }
 
-ParserBaseTraits<Parser>::TemplateLiteralState Parser::OpenTemplateLiteral(
-    int pos) {
-  return new (zone()) ParserBaseTraits<Parser>::TemplateLiteral(zone(), pos);
+Parser::TemplateLiteralState Parser::OpenTemplateLiteral(int pos) {
+  return new (zone()) TemplateLiteral(zone(), pos);
 }
 
 
 void Parser::AddTemplateSpan(TemplateLiteralState* state, bool tail) {
   int pos = scanner()->location().beg_pos;
   int end = scanner()->location().end_pos - (tail ? 1 : 2);
   const AstRawString* tv = scanner()->CurrentSymbol(ast_value_factory());
   const AstRawString* trv = scanner()->CurrentRawSymbol(ast_value_factory());
   Literal* cooked = factory()->NewStringLiteral(tv, pos);
   Literal* raw = factory()->NewStringLiteral(trv, pos);
@@ skipping 255 matching lines @@
     ZoneList<Expression*>* args) {
   AstNodeFactory* factory = delegate()->factory();
   Expression* expr = args->at(0);
   for (int i = 1; i < args->length(); ++i) {
     expr = factory->NewBinaryOperation(Token::COMMA, expr, args->at(i),
                                        expr->position());
   }
   return expr;
 }
 
-void ParserBaseTraits<Parser>::RewriteDestructuringAssignments() {
-  delegate()->RewriteDestructuringAssignments();
-}
-
-Expression* ParserBaseTraits<Parser>::RewriteExponentiation(Expression* left,
-                                                            Expression* right,
-                                                            int pos) {
-  return delegate()->RewriteExponentiation(left, right, pos);
-}
-
-Expression* ParserBaseTraits<Parser>::RewriteAssignExponentiation(
-    Expression* left, Expression* right, int pos) {
-  return delegate()->RewriteAssignExponentiation(left, right, pos);
-}
-
-void ParserBaseTraits<Parser>::RewriteNonPattern(
-    Type::ExpressionClassifier* classifier, bool* ok) {
-  delegate()->RewriteNonPattern(classifier, ok);
-}
-
-Expression* ParserBaseTraits<Parser>::RewriteAwaitExpression(Expression* value,
-                                                             int await_pos) {
+Expression* Parser::RewriteAwaitExpression(Expression* value, int await_pos) {
   // yield %AsyncFunctionAwait(.generator_object, <operand>)
   Variable* generator_object_variable =
       delegate()->function_state_->generator_object_variable();
 
   // If generator_object_variable is null,
   if (!generator_object_variable) return value;
 
   auto factory = delegate()->factory();
   const int nopos = kNoSourcePosition;
 
@@ skipping 231 matching lines @@
                                append_body, finalize);
       do_block->statements()->Add(loop, zone());
     }
   }
   // Now, rewind the original array literal to truncate everything from the
   // first spread (included) until the end. This fixes $R's initialization.
   lit->RewindSpreads();
   return factory()->NewDoExpression(do_block, result, lit->position());
 }
 
-void ParserBaseTraits<Parser>::QueueDestructuringAssignmentForRewriting(
-    Expression* expr) {
+void Parser::QueueDestructuringAssignmentForRewriting(Expression* expr) {
   DCHECK(expr->IsRewritableExpression());
-  delegate()->function_state_->AddDestructuringAssignment(
-      Parser::DestructuringAssignment(expr, delegate()->scope()));
+  function_state_->AddDestructuringAssignment(
+      DestructuringAssignment(expr, delegate()->scope()));
 }
 
-void ParserBaseTraits<Parser>::QueueNonPatternForRewriting(Expression* expr,
-                                                           bool* ok) {
+void Parser::QueueNonPatternForRewriting(Expression* expr, bool* ok) {
   DCHECK(expr->IsRewritableExpression());
-  delegate()->function_state_->AddNonPatternForRewriting(expr, ok);
+  function_state_->AddNonPatternForRewriting(expr, ok);
 }
 
 void ParserBaseTraits<Parser>::SetFunctionNameFromPropertyName(
     ObjectLiteralProperty* property, const AstRawString* name) {
   Expression* value = property->value();
 
   // Computed name setting must happen at runtime.
   if (property->is_computed_name()) return;
 
   // Getter and setter names are handled here because their names
@@ skipping 971 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8