Templatize AstVisitor with its subclass

This replaces the vtable on AstNode with a NodeType tag. The visitors replace double dispatch with a single switch over the NodeType.

For now, visitors with subclasses still have virtual methods themselves. We should probably specialize them later as well.

The uint8_t NodeType allows us to better pack memory, saving 8-16 bytes on many AST nodes (with additional packing that I'll do in a follow-up CL)

BUG=

Review-Url: https://codereview.chromium.org/2142233003
Cr-Commit-Position: refs/heads/master@{#37788}

src/ast/ast-expression-rewriter.h

@@ -17,19 +17,21 @@ namespace internal {
 // A rewriting Visitor over a CompilationInfo's AST that invokes
 // VisitExpression on each expression node.
 
-class AstExpressionRewriter : public AstVisitor {
+// This AstVistor is not final, and provides the AstVisitor methods as virtual
+// methods so they can be specialized by subclasses.
+class AstExpressionRewriter : public AstVisitor<AstExpressionRewriter> {
  public:
-  explicit AstExpressionRewriter(Isolate* isolate) : AstVisitor() {
+  explicit AstExpressionRewriter(Isolate* isolate) {
     InitializeAstRewriter(isolate);
   }
-  explicit AstExpressionRewriter(uintptr_t stack_limit) : AstVisitor() {
+  explicit AstExpressionRewriter(uintptr_t stack_limit) {
     InitializeAstRewriter(stack_limit);
   }
-  ~AstExpressionRewriter() override {}
+  virtual ~AstExpressionRewriter() {}
 
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
-  void VisitStatements(ZoneList<Statement*>* statements) override;
-  void VisitExpressions(ZoneList<Expression*>* expressions) override;
+  virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
+  virtual void VisitStatements(ZoneList<Statement*>* statements);
+  virtual void VisitExpressions(ZoneList<Expression*>* expressions);
 
   virtual void VisitObjectLiteralProperty(ObjectLiteralProperty* property);
 
@@ -39,7 +41,7 @@ class AstExpressionRewriter : public AstVisitor {
  private:
   DEFINE_AST_REWRITER_SUBCLASS_MEMBERS();
 
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/ast/ast-literal-reindexer.cc

@@ -321,9 +321,6 @@ void AstLiteralReindexer::VisitFunctionLiteral(FunctionLiteral* node) {
   // We don't recurse into the declarations or body of the function literal:
 }
 
-
-void AstLiteralReindexer::Reindex(Expression* pattern) {
-  pattern->Accept(this);
-}
+void AstLiteralReindexer::Reindex(Expression* pattern) { Visit(pattern); }
 }  // namespace internal
 }  // namespace v8

src/ast/ast-literal-reindexer.h

@@ -11,20 +11,20 @@
 namespace v8 {
 namespace internal {
 
-class AstLiteralReindexer final : public AstVisitor {
+class AstLiteralReindexer final : public AstVisitor<AstLiteralReindexer> {
  public:
-  AstLiteralReindexer() : AstVisitor(), next_index_(0) {}
+  AstLiteralReindexer() : next_index_(0) {}
 
   int count() const { return next_index_; }
   void Reindex(Expression* pattern);
 
  private:
-#define DEFINE_VISIT(type) void Visit##type(type* node) override;
+#define DEFINE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
-  void VisitStatements(ZoneList<Statement*>* statements) override;
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+  void VisitStatements(ZoneList<Statement*>* statements);
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
   void VisitArguments(ZoneList<Expression*>* arguments);
   void VisitObjectLiteralProperty(ObjectLiteralProperty* property);
 
@@ -32,10 +32,9 @@ class AstLiteralReindexer final : public AstVisitor {
     literal->literal_index_ = next_index_++;
   }
 
-  void Visit(AstNode* node) override { node->Accept(this); }
-
   int next_index_;
 
+  DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW()
   DISALLOW_COPY_AND_ASSIGN(AstLiteralReindexer);
 };
 }  // namespace internal

src/ast/ast-numbering.cc

@@ -10,11 +10,10 @@
 namespace v8 {
 namespace internal {
 
-class AstNumberingVisitor final : public AstVisitor {
+class AstNumberingVisitor final : public AstVisitor<AstNumberingVisitor> {
  public:
   AstNumberingVisitor(Isolate* isolate, Zone* zone)
-      : AstVisitor(),
-        isolate_(isolate),
+      : isolate_(isolate),
         zone_(zone),
         next_id_(BailoutId::FirstUsable().ToInt()),
         yield_count_(0),
@@ -29,7 +28,7 @@ class AstNumberingVisitor final : public AstVisitor {
 
  private:
 // AST node visitor interface.
-#define DEFINE_VISIT(type) void Visit##type(type* node) override;
+#define DEFINE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEFINE_VISIT)
 #undef DEFINE_VISIT
 
@@ -37,8 +36,8 @@ class AstNumberingVisitor final : public AstVisitor {
   void VisitPropertyReference(Property* node);
   void VisitReference(Expression* expr);
 
-  void VisitStatements(ZoneList<Statement*>* statements) override;
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+  void VisitStatements(ZoneList<Statement*>* statements);
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
   void VisitArguments(ZoneList<Expression*>* arguments);
   void VisitObjectLiteralProperty(ObjectLiteralProperty* property);
 

src/ast/ast.cc

@@ -22,15 +22,6 @@
 namespace v8 {
 namespace internal {
 
-// ----------------------------------------------------------------------------
-// All the Accept member functions for each syntax tree node type.
-
-#define DECL_ACCEPT(type)                                       \
-  void type::Accept(AstVisitor* v) { v->Visit##type(this); }
-AST_NODE_LIST(DECL_ACCEPT)
-#undef DECL_ACCEPT
-
-
 // ----------------------------------------------------------------------------
 // Implementation of other node functionality.
 
@@ -182,7 +173,7 @@ bool Statement::IsJump() const {
 
 VariableProxy::VariableProxy(Zone* zone, Variable* var, int start_position,
                              int end_position)
-    : Expression(zone, start_position),
+    : Expression(zone, start_position, kVariableProxy),
       bit_field_(IsThisField::encode(var->is_this()) |
                  IsAssignedField::encode(false) |
                  IsResolvedField::encode(false)),
@@ -191,18 +182,16 @@ VariableProxy::VariableProxy(Zone* zone, Variable* var, int start_position,
   BindTo(var);
 }
 
-
 VariableProxy::VariableProxy(Zone* zone, const AstRawString* name,
                              Variable::Kind variable_kind, int start_position,
                              int end_position)
-    : Expression(zone, start_position),
+    : Expression(zone, start_position, kVariableProxy),
       bit_field_(IsThisField::encode(variable_kind == Variable::THIS) |
                  IsAssignedField::encode(false) |
                  IsResolvedField::encode(false)),
       raw_name_(name),
       end_position_(end_position) {}
 
-
 void VariableProxy::BindTo(Variable* var) {
   DCHECK((is_this() && var->is_this()) || raw_name() == var->raw_name());
   set_var(var);
@@ -255,10 +244,9 @@ void ForInStatement::AssignFeedbackVectorSlots(Isolate* isolate,
   for_in_feedback_slot_ = spec->AddGeneralSlot();
 }
 
-
 Assignment::Assignment(Zone* zone, Token::Value op, Expression* target,
                        Expression* value, int pos)
-    : Expression(zone, pos),
+    : Expression(zone, pos, kAssignment),
       bit_field_(
           IsUninitializedField::encode(false) | KeyTypeField::encode(ELEMENT) |
           StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
@@ -266,7 +254,6 @@ Assignment::Assignment(Zone* zone, Token::Value op, Expression* target,
       value_(value),
       binary_operation_(NULL) {}
 
-
 void Assignment::AssignFeedbackVectorSlots(Isolate* isolate,
                                            FeedbackVectorSpec* spec,
                                            FeedbackVectorSlotCache* cache) {
@@ -930,36 +917,6 @@ Call::CallType Call::GetCallType(Isolate* isolate) const {
 }
 
 
-// ----------------------------------------------------------------------------
-// Implementation of AstVisitor
-
-void AstVisitor::VisitDeclarations(ZoneList<Declaration*>* declarations) {
-  for (int i = 0; i < declarations->length(); i++) {
-    Visit(declarations->at(i));
-  }
-}
-
-
-void AstVisitor::VisitStatements(ZoneList<Statement*>* statements) {
-  for (int i = 0; i < statements->length(); i++) {
-    Statement* stmt = statements->at(i);
-    Visit(stmt);
-    if (stmt->IsJump()) break;
-  }
-}
-
-
-void AstVisitor::VisitExpressions(ZoneList<Expression*>* expressions) {
-  for (int i = 0; i < expressions->length(); i++) {
-    // The variable statement visiting code may pass NULL expressions
-    // to this code. Maybe this should be handled by introducing an
-    // undefined expression or literal?  Revisit this code if this
-    // changes
-    Expression* expression = expressions->at(i);
-    if (expression != NULL) Visit(expression);
-  }
-}
-
 // ----------------------------------------------------------------------------
 // Implementation of AstTraversalVisitor
 
@@ -1263,7 +1220,7 @@ void AstTraversalVisitor::VisitRewritableExpression(
 
 CaseClause::CaseClause(Zone* zone, Expression* label,
                        ZoneList<Statement*>* statements, int pos)
-    : Expression(zone, pos),
+    : Expression(zone, pos, kCaseClause),
       label_(label),
       statements_(statements),
       compare_type_(Type::None()) {}

src/ast/prettyprinter.h

@@ -12,10 +12,10 @@
 namespace v8 {
 namespace internal {
 
-class CallPrinter : public AstVisitor {
+class CallPrinter final : public AstVisitor<CallPrinter> {
  public:
   explicit CallPrinter(Isolate* isolate, bool is_builtin);
-  virtual ~CallPrinter();
+  ~CallPrinter();
 
   // The following routine prints the node with position |position| into a
   // string. The result string is alive as long as the CallPrinter is alive.
@@ -26,7 +26,7 @@ class CallPrinter : public AstVisitor {
   void Find(AstNode* node, bool print = false);
 
 // Individual nodes
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
@@ -53,14 +53,13 @@ class CallPrinter : public AstVisitor {
 
 #ifdef DEBUG
 
-// Prints the AST structure
-class AstPrinter : public AstVisitor {
+class AstPrinter final : public AstVisitor<AstPrinter> {
  public:
   explicit AstPrinter(Isolate* isolate);
-  virtual ~AstPrinter();
+  ~AstPrinter();
 
   // The following routines print a node into a string.
-  // The result string is alive as long as the PrettyPrinter is alive.
+  // The result string is alive as long as the AstPrinter is alive.
   const char* Print(AstNode* node);
   const char* PrintProgram(FunctionLiteral* program);
 
@@ -70,7 +69,7 @@ class AstPrinter : public AstVisitor {
   static void PrintOut(Isolate* isolate, AstNode* node);
 
   // Individual nodes
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/compiler/ast-graph-builder.cc

@@ -1112,7 +1112,7 @@ void AstGraphBuilder::VisitForValues(ZoneList<Expression*>* exprs) {
 void AstGraphBuilder::VisitForValue(Expression* expr) {
   AstValueContext for_value(this);
   if (!CheckStackOverflow()) {
-    expr->Accept(this);
+    AstVisitor<AstGraphBuilder>::Visit(expr);
   } else {
     ast_context()->ProduceValue(expr, jsgraph()->UndefinedConstant());
   }
@@ -1122,7 +1122,7 @@ void AstGraphBuilder::VisitForValue(Expression* expr) {
 void AstGraphBuilder::VisitForEffect(Expression* expr) {
   AstEffectContext for_effect(this);
   if (!CheckStackOverflow()) {
-    expr->Accept(this);
+    AstVisitor<AstGraphBuilder>::Visit(expr);
   } else {
     ast_context()->ProduceValue(expr, jsgraph()->UndefinedConstant());
   }
@@ -1132,7 +1132,7 @@ void AstGraphBuilder::VisitForEffect(Expression* expr) {
 void AstGraphBuilder::VisitForTest(Expression* expr) {
   AstTestContext for_condition(this, expr->test_id());
   if (!CheckStackOverflow()) {
-    expr->Accept(this);
+    AstVisitor<AstGraphBuilder>::Visit(expr);
   } else {
     ast_context()->ProduceValue(expr, jsgraph()->UndefinedConstant());
   }
@@ -1142,7 +1142,7 @@ void AstGraphBuilder::VisitForTest(Expression* expr) {
 void AstGraphBuilder::Visit(Expression* expr) {
   // Reuses enclosing AstContext.
   if (!CheckStackOverflow()) {
-    expr->Accept(this);
+    AstVisitor<AstGraphBuilder>::Visit(expr);
   } else {
     ast_context()->ProduceValue(expr, jsgraph()->UndefinedConstant());
   }
@@ -2982,7 +2982,7 @@ void AstGraphBuilder::VisitCaseClause(CaseClause* expr) {
 
 void AstGraphBuilder::VisitDeclarations(ZoneList<Declaration*>* declarations) {
   DCHECK(globals()->empty());
-  AstVisitor::VisitDeclarations(declarations);
+  AstVisitor<AstGraphBuilder>::VisitDeclarations(declarations);
   if (globals()->empty()) return;
   int array_index = 0;
   Handle<TypeFeedbackVector> feedback_vector(

src/compiler/ast-graph-builder.h

@@ -32,11 +32,14 @@ class TypeHintAnalysis;
 // underlying AST. The produced graph can either be compiled into a
 // stand-alone function or be wired into another graph for the purposes
 // of function inlining.
-class AstGraphBuilder : public AstVisitor {
+// This AstVistor is not final, and provides the AstVisitor methods as virtual
+// methods so they can be specialized by subclasses.
+class AstGraphBuilder : public AstVisitor<AstGraphBuilder> {
  public:
   AstGraphBuilder(Zone* local_zone, CompilationInfo* info, JSGraph* jsgraph,
                   LoopAssignmentAnalysis* loop_assignment = nullptr,
                   TypeHintAnalysis* type_hint_analysis = nullptr);
+  virtual ~AstGraphBuilder() {}
 
   // Creates a graph by visiting the entire AST.
   bool CreateGraph(bool stack_check = true);
@@ -51,13 +54,13 @@ class AstGraphBuilder : public AstVisitor {
   }
 
  protected:
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   // Visiting functions for AST nodes make this an AstVisitor.
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   // Visiting function for declarations list is overridden.
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
 
  private:
   class AstContext;

src/compiler/ast-loop-assignment-analyzer.h

@@ -40,13 +40,14 @@ class LoopAssignmentAnalysis : public ZoneObject {
 
 
 // The class that performs loop assignment analysis by walking the AST.
-class AstLoopAssignmentAnalyzer : public AstVisitor {
+class AstLoopAssignmentAnalyzer final
+    : public AstVisitor<AstLoopAssignmentAnalyzer> {
  public:
   AstLoopAssignmentAnalyzer(Zone* zone, CompilationInfo* info);
 
   LoopAssignmentAnalysis* Analyze();
 
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/crankshaft/hydrogen.cc

@@ -12141,7 +12141,7 @@ void HOptimizedGraphBuilder::VisitSuperCallReference(SuperCallReference* expr) {
 void HOptimizedGraphBuilder::VisitDeclarations(
     ZoneList<Declaration*>* declarations) {
   DCHECK(globals_.is_empty());
-  AstVisitor::VisitDeclarations(declarations);
+  AstVisitor<HOptimizedGraphBuilder>::VisitDeclarations(declarations);
   if (!globals_.is_empty()) {
     Handle<FixedArray> array =
        isolate()->factory()->NewFixedArray(globals_.length(), TENURED);

src/crankshaft/hydrogen.h

@@ -2062,8 +2062,10 @@ inline HContext* HGraphBuilder::New<HContext>() {
   return HContext::New(zone());
 }
 
-
-class HOptimizedGraphBuilder : public HGraphBuilder, public AstVisitor {
+// This AstVistor is not final, and provides the AstVisitor methods as virtual
+// methods so they can be specialized by subclasses.
+class HOptimizedGraphBuilder : public HGraphBuilder,
+                               public AstVisitor<HOptimizedGraphBuilder> {
  public:
   // A class encapsulating (lazily-allocated) break and continue blocks for
   // a breakable statement.  Separated from BreakAndContinueScope so that it
@@ -2143,7 +2145,7 @@ class HOptimizedGraphBuilder : public HGraphBuilder, public AstVisitor {
 
   FunctionState* function_state() const { return function_state_; }
 
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
 
   AstTypeBounds* bounds() { return &bounds_; }
 
@@ -2351,7 +2353,7 @@ class HOptimizedGraphBuilder : public HGraphBuilder, public AstVisitor {
                        HBasicBlock* false_block);
 
   // Visit a list of expressions from left to right, each in a value context.
-  void VisitExpressions(ZoneList<Expression*>* exprs) override;
+  void VisitExpressions(ZoneList<Expression*>* exprs);
   void VisitExpressions(ZoneList<Expression*>* exprs,
                         ArgumentsAllowedFlag flag);
 
@@ -2361,9 +2363,9 @@ class HOptimizedGraphBuilder : public HGraphBuilder, public AstVisitor {
   void PushArgumentsFromEnvironment(int count);
 
   void SetUpScope(Scope* scope);
-  void VisitStatements(ZoneList<Statement*>* statements) override;
+  void VisitStatements(ZoneList<Statement*>* statements);
 
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/crankshaft/typing.h

@@ -17,7 +17,7 @@
 namespace v8 {
 namespace internal {
 
-class AstTyper: public AstVisitor {
+class AstTyper final : public AstVisitor<AstTyper> {
  public:
   AstTyper(Isolate* isolate, Zone* zone, Handle<JSFunction> closure,
            Scope* scope, BailoutId osr_ast_id, FunctionLiteral* root,
@@ -71,10 +71,10 @@ class AstTyper: public AstVisitor {
            var->IsParameter() ? parameter_index(var->index()) : kNoVar;
   }
 
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
-  void VisitStatements(ZoneList<Statement*>* statements) override;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
+  void VisitStatements(ZoneList<Statement*>* statements);
 
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/full-codegen/full-codegen.cc

@@ -390,7 +390,7 @@ void FullCodeGenerator::VisitDeclarations(
   ZoneList<Handle<Object> > inner_globals(10, zone());
   globals_ = &inner_globals;
 
-  AstVisitor::VisitDeclarations(declarations);
+  AstVisitor<FullCodeGenerator>::VisitDeclarations(declarations);
 
   if (!globals_->is_empty()) {
     // Invoke the platform-dependent code generator to do the actual

src/full-codegen/full-codegen.h

@@ -27,7 +27,7 @@ class JumpPatchSite;
 // -----------------------------------------------------------------------------
 // Full code generator.
 
-class FullCodeGenerator: public AstVisitor {
+class FullCodeGenerator final : public AstVisitor<FullCodeGenerator> {
  public:
   FullCodeGenerator(MacroAssembler* masm, CompilationInfo* info)
       : masm_(masm),
@@ -387,7 +387,7 @@ class FullCodeGenerator: public AstVisitor {
 
   void VisitInDuplicateContext(Expression* expr);
 
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
   void DeclareGlobals(Handle<FixedArray> pairs);
   int DeclareGlobalsFlags();
 
@@ -737,7 +737,7 @@ class FullCodeGenerator: public AstVisitor {
   void PushCalleeAndWithBaseObject(Call* expr);
 
   // AST node visit functions.
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 

src/interpreter/bytecode-generator.h

@@ -19,19 +19,19 @@ namespace interpreter {
 
 class LoopBuilder;
 
-class BytecodeGenerator final : public AstVisitor {
+class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
  public:
   explicit BytecodeGenerator(CompilationInfo* info);
 
   Handle<BytecodeArray> MakeBytecode();
 
-#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   // Visiting function for declarations list and statements are overridden.
-  void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
-  void VisitStatements(ZoneList<Statement*>* statments) override;
+  void VisitDeclarations(ZoneList<Declaration*>* declarations);
+  void VisitStatements(ZoneList<Statement*>* statments);
 
  private:
   class ContextScope;

src/parsing/parser-base.h

@@ -3062,7 +3062,7 @@ ParserBase<Traits>::ParseSuperExpression(bool is_new,
       IsClassConstructor(kind)) {
     if (peek() == Token::PERIOD || peek() == Token::LBRACK) {
       scope->RecordSuperPropertyUsage();
-      return this->SuperPropertyReference(scope_, factory(), pos);
+      return this->NewSuperPropertyReference(scope_, factory(), pos);
     }
     // new super() is never allowed.
     // super() is only allowed in derived constructor
@@ -3070,7 +3070,7 @@ ParserBase<Traits>::ParseSuperExpression(bool is_new,
       // TODO(rossberg): This might not be the correct FunctionState for the
       // method here.
       function_state_->set_super_location(scanner()->location());
-      return this->SuperCallReference(scope_, factory(), pos);
+      return this->NewSuperCallReference(scope_, factory(), pos);
     }
   }
 

src/parsing/parser.cc

@@ -634,8 +634,7 @@ Expression* ParserTraits::ThisExpression(Scope* scope, AstNodeFactory* factory,
                               Variable::THIS, pos, pos + 4);
 }
 
-
-Expression* ParserTraits::SuperPropertyReference(Scope* scope,
+Expression* ParserTraits::NewSuperPropertyReference(Scope* scope,
                                                     AstNodeFactory* factory,
                                                     int pos) {
   // this_function[home_object_symbol]
@@ -650,9 +649,9 @@ Expression* ParserTraits::SuperPropertyReference(Scope* scope,
       ThisExpression(scope, factory, pos)->AsVariableProxy(), home_object, pos);
 }
 
-
-Expression* ParserTraits::SuperCallReference(Scope* scope,
-                                             AstNodeFactory* factory, int pos) {
+Expression* ParserTraits::NewSuperCallReference(Scope* scope,
+                                                AstNodeFactory* factory,
+                                                int pos) {
   VariableProxy* new_target_proxy = scope->NewUnresolved(
       factory, parser_->ast_value_factory()->new_target_string(),
       Variable::NORMAL, pos);

src/parsing/parser.h

@@ -507,9 +507,9 @@ class ParserTraits {
 
   Expression* ThisExpression(Scope* scope, AstNodeFactory* factory,
                              int pos = kNoSourcePosition);
-  Expression* SuperPropertyReference(Scope* scope, AstNodeFactory* factory,
+  Expression* NewSuperPropertyReference(Scope* scope, AstNodeFactory* factory,
                                         int pos);
-  Expression* SuperCallReference(Scope* scope, AstNodeFactory* factory,
+  Expression* NewSuperCallReference(Scope* scope, AstNodeFactory* factory,
                                     int pos);
   Expression* NewTargetExpression(Scope* scope, AstNodeFactory* factory,
                                   int pos);
@@ -840,7 +840,7 @@ class Parser : public ParserBase<ParserTraits> {
     Scanner::Location bindings_loc;
   };
 
-  class PatternRewriter : private AstVisitor {
+  class PatternRewriter final : private AstVisitor<PatternRewriter> {
    public:
     static void DeclareAndInitializeVariables(
         Block* block, const DeclarationDescriptor* declaration_descriptor,
@@ -858,11 +858,10 @@ class Parser : public ParserBase<ParserTraits> {
    private:
     PatternRewriter() {}
 
-#define DECLARE_VISIT(type) void Visit##type(v8::internal::type* node) override;
+#define DECLARE_VISIT(type) void Visit##type(v8::internal::type* node);
     // Visiting functions for AST nodes make this an AstVisitor.
     AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
-    void Visit(AstNode* node) override;
 
     enum PatternContext {
       BINDING,
@@ -878,7 +877,7 @@ class Parser : public ParserBase<ParserTraits> {
       Expression* old_value = current_value_;
       current_value_ = value;
       recursion_level_++;
-      pattern->Accept(this);
+      Visit(pattern);
       recursion_level_--;
       current_value_ = old_value;
     }
@@ -917,6 +916,8 @@ class Parser : public ParserBase<ParserTraits> {
     Expression* current_value_;
     int recursion_level_;
     bool* ok_;
+
+    DEFINE_AST_VISITOR_MEMBERS_WITHOUT_STACKOVERFLOW()
   };
 
   Block* ParseVariableDeclarations(VariableDeclarationContext var_context,

src/parsing/pattern-rewriter.cc

@@ -328,7 +328,7 @@ void Parser::PatternRewriter::VisitRewritableExpression(
     // perform BindingPattern rewriting
     DCHECK(!node->is_rewritten());
     node->Rewrite(node->expression());
-    return node->expression()->Accept(this);
+    return Visit(node->expression());
   }
 
   if (node->is_rewritten()) return;
@@ -730,8 +730,6 @@ void Parser::PatternRewriter::VisitProperty(v8::internal::Property* node) {
 
 // =============== UNREACHABLE =============================
 
-void Parser::PatternRewriter::Visit(AstNode* node) { UNREACHABLE(); }
-
 #define NOT_A_PATTERN(Node)                                        \
   void Parser::PatternRewriter::Visit##Node(v8::internal::Node*) { \
     UNREACHABLE();                                                 \

src/parsing/preparser.h

@@ -802,13 +802,12 @@ class PreParserTraits {
     return PreParserExpression::This();
   }
 
-  static PreParserExpression SuperPropertyReference(Scope* scope,
-                                                    PreParserFactory* factory,
-                                                    int pos) {
+  static PreParserExpression NewSuperPropertyReference(
+      Scope* scope, PreParserFactory* factory, int pos) {
     return PreParserExpression::Default();
   }
 
-  static PreParserExpression SuperCallReference(Scope* scope,
+  static PreParserExpression NewSuperCallReference(Scope* scope,
                                                    PreParserFactory* factory,
                                                    int pos) {
     return PreParserExpression::SuperCallReference();

src/parsing/rewriter.cc

@@ -11,7 +11,7 @@
 namespace v8 {
 namespace internal {
 
-class Processor: public AstVisitor {
+class Processor final : public AstVisitor<Processor> {
  public:
   Processor(Isolate* isolate, Scope* scope, Variable* result,
             AstValueFactory* ast_value_factory)
@@ -37,8 +37,6 @@ class Processor: public AstVisitor {
     InitializeAstVisitor(parser->stack_limit());
   }
 
-  ~Processor() override {}
-
   void Process(ZoneList<Statement*>* statements);
   bool result_assigned() const { return result_assigned_; }
 
@@ -81,7 +79,7 @@ class Processor: public AstVisitor {
   AstNodeFactory factory_;
 
   // Node visitors.
-#define DEF_VISIT(type) void Visit##type(type* node) override;
+#define DEF_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT