[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 <algorithm>
 #include <utility>
 #include <vector>
 
-#include "src/ast/ast.h"
-#include "src/ast/ast-expression-visitor.h"
-#include "src/ast/scopes.h"
+#include "src/ast/ast-traversal-visitor.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* old_scope,
            Scope* new_scope)
-      : AstExpressionVisitor(stack_limit, initializer),
+      : AstTraversalVisitor(stack_limit, initializer),
         old_scope_(old_scope),
         new_scope_(new_scope),
         old_scope_closure_(old_scope->ClosureScope()),
         new_scope_closure_(new_scope->ClosureScope()) {}
   ~Rewriter();
 
+ protected:

[adamk, 2016/07/21 18:11:57]

"protected" + "final" doesn't make sense to me. Presumably these methods could
stay private; if you want to mark them in some way, a comment seems better than
this use of "protected"

[nickie, 2016/07/22 08:40:18]

You're right.  I'm making them private again.  These are the only ones that the
friend class needs to be able to call and I'm adding a comment explaining that.

+  friend class AstTraversalVisitor<Rewriter>;
+
+  void VisitFunctionLiteral(FunctionLiteral* expr);
+  void VisitClassLiteral(ClassLiteral* expr);
+  void VisitVariableProxy(VariableProxy* expr);
+
+  void VisitBlock(Block* stmt);
+  void VisitTryCatchStatement(TryCatchStatement* stmt);
+  void VisitWithStatement(WithStatement* stmt);
+
  private:
-  void VisitExpression(Expression* expr) override {}
-
-  void VisitFunctionLiteral(FunctionLiteral* expr) override;
-  void VisitClassLiteral(ClassLiteral* expr) override;
-  void VisitVariableProxy(VariableProxy* expr) override;
-
-  void VisitBlock(Block* stmt) override;
-  void VisitTryCatchStatement(TryCatchStatement* stmt) override;
-  void VisitWithStatement(WithStatement* stmt) override;
-
   Scope* old_scope_;
   Scope* new_scope_;
   Scope* old_scope_closure_;
   Scope* new_scope_closure_;
   std::vector<std::pair<Variable*, int>> temps_;
 };
 
 struct LessThanSecond {
   bool operator()(const std::pair<Variable*, int>& left,
                   const std::pair<Variable*, int>& right) {
@@ skipping 81 matching lines @@
 void RewriteParameterInitializerScope(uintptr_t stack_limit,
                                       Expression* initializer, Scope* old_scope,
                                       Scope* new_scope) {
   Rewriter rewriter(stack_limit, initializer, old_scope, new_scope);
   rewriter.Run();
 }
 
 
 }  // namespace internal
 }  // namespace v8