[parser] Refactor AstTraversalVisitor

src/parsing/parameter-initializer-rewriter.cc

 // Copyright 2015 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/parameter-initializer-rewriter.h"
 
 #include "src/ast/ast.h"
-#include "src/ast/ast-expression-visitor.h"
+#include "src/ast/ast-traversal-visitor.h"
 #include "src/ast/scopes.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 
-class Rewriter final : public AstExpressionVisitor {
+class Rewriter final : public AstTraversalVisitor<Rewriter> {
  public:
   Rewriter(uintptr_t stack_limit, Expression* initializer, Scope* param_scope)
-      : AstExpressionVisitor(stack_limit, initializer),
+      : AstTraversalVisitor(stack_limit, initializer),
         param_scope_(param_scope) {}
 
  private:
-  void VisitExpression(Expression* expr) override {}
+  // This is required so that the overriden Visit* methods can be
+  // called by the base class (template).
+  friend class AstTraversalVisitor<Rewriter>;
 
-  void VisitFunctionLiteral(FunctionLiteral* expr) override;
-  void VisitClassLiteral(ClassLiteral* expr) override;
-  void VisitVariableProxy(VariableProxy* expr) override;
+  void VisitFunctionLiteral(FunctionLiteral* expr);
+  void VisitClassLiteral(ClassLiteral* expr);
+  void VisitVariableProxy(VariableProxy* expr);
 
-  void VisitBlock(Block* stmt) override;
-  void VisitTryCatchStatement(TryCatchStatement* stmt) override;
-  void VisitWithStatement(WithStatement* stmt) override;
+  void VisitBlock(Block* stmt);
+  void VisitTryCatchStatement(TryCatchStatement* stmt);
+  void VisitWithStatement(WithStatement* stmt);
 
   Scope* param_scope_;
 };
 
 void Rewriter::VisitFunctionLiteral(FunctionLiteral* function_literal) {
   function_literal->scope()->ReplaceOuterScope(param_scope_);
 }
 
 
 void Rewriter::VisitClassLiteral(ClassLiteral* class_literal) {
@@ skipping 60 matching lines @@
   DCHECK(param_scope->calls_sloppy_eval());
   DCHECK(param_scope->outer_scope()->is_function_scope());
 
   Rewriter rewriter(stack_limit, expr, param_scope);
   rewriter.Run();
 }
 
 
 }  // namespace internal
 }  // namespace v8