Remove unused Zone argument from InitializeAstVisitor

src/prettyprinter.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/prettyprinter.h"
 
 #include <stdarg.h>
 
 #include "src/ast-value-factory.h"
 #include "src/base/platform/platform.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 
-CallPrinter::CallPrinter(Isolate* isolate, Zone* zone) {
+CallPrinter::CallPrinter(Isolate* isolate) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
   position_ = 0;
   found_ = false;
   done_ = false;
-  InitializeAstVisitor(isolate, zone);
+  InitializeAstVisitor(isolate);
 }
 
 
 CallPrinter::~CallPrinter() { DeleteArray(output_); }
 
 
 const char* CallPrinter::Print(FunctionLiteral* program, int position) {
   Init();
   position_ = position;
   Find(program);
@@ skipping 399 matching lines @@
 static int FormatSlotNode(Vector<char>* buf, Expression* node,
                           const char* node_name, FeedbackVectorSlot slot) {
   int pos = SNPrintF(*buf, "%s", node_name);
   if (!slot.IsInvalid()) {
     pos = SNPrintF(*buf + pos, " Slot(%d)", slot.ToInt());
   }
   return pos;
 }
 
 
-PrettyPrinter::PrettyPrinter(Isolate* isolate, Zone* zone) {
+PrettyPrinter::PrettyPrinter(Isolate* isolate) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
-  InitializeAstVisitor(isolate, zone);
+  InitializeAstVisitor(isolate);
 }
 
 
 PrettyPrinter::~PrettyPrinter() {
   DeleteArray(output_);
 }
 
 
 void PrettyPrinter::VisitBlock(Block* node) {
   if (!node->ignore_completion_value()) Print("{ ");
@@ skipping 439 matching lines @@
 
 
 const char* PrettyPrinter::PrintProgram(FunctionLiteral* program) {
   Init();
   PrintStatements(program->body());
   Print("\n");
   return output_;
 }
 
 
-void PrettyPrinter::PrintOut(Isolate* isolate, Zone* zone, AstNode* node) {
-  PrettyPrinter printer(isolate, zone);
+void PrettyPrinter::PrintOut(Isolate* isolate, AstNode* node) {
+  PrettyPrinter printer(isolate);
   PrintF("%s\n", printer.Print(node));
 }
 
 
 void PrettyPrinter::Init() {
   if (size_ == 0) {
     DCHECK(output_ == NULL);
     const int initial_size = 256;
     output_ = NewArray<char>(initial_size);
     size_ = initial_size;
@@ skipping 154 matching lines @@
   }
 
  private:
   AstPrinter* ast_printer_;
 };
 
 
 //-----------------------------------------------------------------------------
 
 
-AstPrinter::AstPrinter(Isolate* isolate, Zone* zone)
-    : PrettyPrinter(isolate, zone), indent_(0) {}
+AstPrinter::AstPrinter(Isolate* isolate) : PrettyPrinter(isolate), indent_(0) {}
 
 
 AstPrinter::~AstPrinter() {
   DCHECK(indent_ == 0);
 }
 
 
 void AstPrinter::PrintIndented(const char* txt) {
   for (int i = 0; i < indent_; i++) {
     Print(". ");
@@ skipping 519 matching lines @@
 
 void AstPrinter::VisitSuperCallReference(SuperCallReference* node) {
   IndentedScope indent(this, "SUPER-CALL-REFERENCE", node->position());
 }
 
 
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8