Changed statement ZoneList to a ZoneChunkList

src/parsing/rewriter.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/rewriter.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parse-info.h"
 #include "src/parsing/parser.h"
@@ skipping 24 matching lines @@
         replacement_(nullptr),
         is_set_(false),
         breakable_(false),
         zone_(ast_value_factory->zone()),
         closure_scope_(closure_scope),
         factory_(ast_value_factory) {
     DCHECK_EQ(closure_scope, closure_scope->GetClosureScope());
     InitializeAstVisitor(parser->stack_limit());
   }
 
-  void Process(ZoneList<Statement*>* statements);
+  void Process(ZoneChunkList<Statement*>* statements);
   bool result_assigned() const { return result_assigned_; }
 
   Zone* zone() { return zone_; }
   DeclarationScope* closure_scope() { return closure_scope_; }
   AstNodeFactory* factory() { return &factory_; }
 
   // Returns ".result = value"
   Expression* SetResult(Expression* value) {
     result_assigned_ = true;
     VariableProxy* result_proxy = factory()->NewVariableProxy(result_);
@@ skipping 52 matching lines @@
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 };
 
 
 Statement* Processor::AssignUndefinedBefore(Statement* s) {
   Expression* result_proxy = factory()->NewVariableProxy(result_);
   Expression* undef = factory()->NewUndefinedLiteral(kNoSourcePosition);
   Expression* assignment = factory()->NewAssignment(Token::ASSIGN, result_proxy,
                                                     undef, kNoSourcePosition);
-  Block* b = factory()->NewBlock(NULL, 2, false, kNoSourcePosition);
-  b->statements()->Add(
-      factory()->NewExpressionStatement(assignment, kNoSourcePosition), zone());
-  b->statements()->Add(s, zone());
+  Block* b = factory()->NewBlock(NULL, false, kNoSourcePosition);
+  b->statements()->push_back(
+      factory()->NewExpressionStatement(assignment, kNoSourcePosition));
+  b->statements()->push_back(s);
   return b;
 }
 
-
-void Processor::Process(ZoneList<Statement*>* statements) {
+void Processor::Process(ZoneChunkList<Statement*>* statements) {
   // If we're in a breakable scope (named block, iteration, or switch), we walk
   // all statements. The last value producing statement before the break needs
   // to assign to .result. If we're not in a breakable scope, only the last
   // value producing statement in the block assigns to .result, so we can stop
   // early.
-  for (int i = statements->length() - 1; i >= 0 && (breakable_ || !is_set_);
-       --i) {
-    Visit(statements->at(i));
-    statements->Set(i, replacement_);
+  for (auto it = statements->rbegin();
+       it != statements->rend() && (breakable_ || !is_set_); ++it) {
+    Visit(*it);
+    *it = replacement_;
   }
 }
 
 
 void Processor::VisitBlock(Block* node) {
   // An initializer block is the rewritten form of a variable declaration
   // with initialization expressions. The initializer block contains the
   // list of assignments corresponding to the initialization expressions.
   // While unclear from the spec (ECMA-262, 3rd., 12.2), the value of
   // a variable declaration with initialization expression is 'undefined'
@@ skipping 108 matching lines @@
     // to the completion value.
     CHECK_NOT_NULL(closure_scope());
     Variable* backup = closure_scope()->NewTemporary(
         factory()->ast_value_factory()->dot_result_string());
     Expression* backup_proxy = factory()->NewVariableProxy(backup);
     Expression* result_proxy = factory()->NewVariableProxy(result_);
     Expression* save = factory()->NewAssignment(
         Token::ASSIGN, backup_proxy, result_proxy, kNoSourcePosition);
     Expression* restore = factory()->NewAssignment(
         Token::ASSIGN, result_proxy, backup_proxy, kNoSourcePosition);
-    node->finally_block()->statements()->InsertAt(
-        0, factory()->NewExpressionStatement(save, kNoSourcePosition), zone());
-    node->finally_block()->statements()->Add(
-        factory()->NewExpressionStatement(restore, kNoSourcePosition), zone());
+    node->finally_block()->statements()->push_front(
+        factory()->NewExpressionStatement(save, kNoSourcePosition));
+    node->finally_block()->statements()->push_back(
+        factory()->NewExpressionStatement(restore, kNoSourcePosition));
     is_set_ = set_after;
   }
   Visit(node->try_block());
   node->set_try_block(replacement_->AsBlock());
 
   replacement_ = is_set_ ? node : AssignUndefinedBefore(node);
   is_set_ = true;
 }
 
 
@@ skipping 78 matching lines @@
 // Assumes code has been parsed.  Mutates the AST, so the AST should not
 // continue to be used in the case of failure.
 bool Rewriter::Rewrite(ParseInfo* info) {
   FunctionLiteral* function = info->literal();
   DCHECK_NOT_NULL(function);
   Scope* scope = function->scope();
   DCHECK_NOT_NULL(scope);
   if (!scope->is_script_scope() && !scope->is_eval_scope()) return true;
   DeclarationScope* closure_scope = scope->GetClosureScope();
 
-  ZoneList<Statement*>* body = function->body();
-  if (!body->is_empty()) {
+  ZoneChunkList<Statement*>* body = function->body();
+  if (body->size() > 0) {
     Variable* result = closure_scope->NewTemporary(
         info->ast_value_factory()->dot_result_string());
     // The name string must be internalized at this point.
     info->ast_value_factory()->Internalize(info->isolate());
     DCHECK(!result->name().is_null());
     Processor processor(info->isolate(), closure_scope, result,
                         info->ast_value_factory());
     processor.Process(body);
     // Internalize any values created during rewriting.
     info->ast_value_factory()->Internalize(info->isolate());
     if (processor.HasStackOverflow()) return false;
 
     if (processor.result_assigned()) {
       int pos = kNoSourcePosition;
       VariableProxy* result_proxy =
           processor.factory()->NewVariableProxy(result, pos);
       Statement* result_statement =
           processor.factory()->NewReturnStatement(result_proxy, pos);
-      body->Add(result_statement, info->zone());
+      body->push_back(result_statement);
     }
   }
 
   return true;
 }
 
 bool Rewriter::Rewrite(Parser* parser, DeclarationScope* closure_scope,
                        DoExpression* expr, AstValueFactory* factory) {
   Block* block = expr->block();
   DCHECK_EQ(closure_scope, closure_scope->GetClosureScope());
   DCHECK(block->scope() == nullptr ||
          block->scope()->GetClosureScope() == closure_scope);
-  ZoneList<Statement*>* body = block->statements();
+  ZoneChunkList<Statement*>* body = block->statements();
   VariableProxy* result = expr->result();
   Variable* result_var = result->var();
 
-  if (!body->is_empty()) {
+  if (body->size() > 0) {
     Processor processor(parser, closure_scope, result_var, factory);
     processor.Process(body);
     if (processor.HasStackOverflow()) return false;
 
     if (!processor.result_assigned()) {
       AstNodeFactory* node_factory = processor.factory();
       Expression* undef = node_factory->NewUndefinedLiteral(kNoSourcePosition);
       Statement* completion = node_factory->NewExpressionStatement(
           processor.SetResult(undef), expr->position());
-      body->Add(completion, factory->zone());
+      body->push_back(completion);
     }
   }
   return true;
 }
 
 
 }  // namespace internal
 }  // namespace v8