Changed statement ZoneList to a ZoneChunkList

src/parsing/parser.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/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 174 matching lines @@
   // This turns a super call `super()` into a do expression of the form
   // do {
   //   tmp x = super();
   //   if (.class-field-init)
   //     .class-field-init(x)
   //   x; // This isn't actually present; our do-expression representation
   // allows specifying that the expression returns x directly.
   // }
   Variable* var_tmp =
       scope()->NewTemporary(ast_value_factory()->empty_string());
-  Block* block = factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
+  Block* block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
   Assignment* assignment = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(var_tmp), super_call,
       kNoSourcePosition);
-  block->statements()->Add(
-      factory()->NewExpressionStatement(assignment, kNoSourcePosition), zone());
+  block->statements()->push_back(
+      factory()->NewExpressionStatement(assignment, kNoSourcePosition));
   const AstRawString* init_fn_name =
       ast_value_factory()->dot_class_field_init_string();
   VariableProxy* init_fn_proxy =
       scope()->NewUnresolved(factory(), init_fn_name);
   Expression* condition = init_fn_proxy;
   Statement* initialize = factory()->NewExpressionStatement(
       CallClassFieldInitializer(scope(), factory()->NewVariableProxy(var_tmp)),
       kNoSourcePosition);
   IfStatement* if_statement = factory()->NewIfStatement(
       condition, initialize, factory()->NewEmptyStatement(kNoSourcePosition),
       kNoSourcePosition);
-  block->statements()->Add(if_statement, zone());
+  block->statements()->push_back(if_statement);
   return factory()->NewDoExpression(block, var_tmp, kNoSourcePosition);
 }
 
 FunctionLiteral* Parser::DefaultConstructor(const AstRawString* name,
                                             bool call_super,
                                             bool requires_class_field_init,
                                             int pos, int end_pos,
                                             LanguageMode language_mode) {
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   const int parameter_count = 0;
   if (name == nullptr) name = ast_value_factory()->empty_string();
 
   FunctionKind kind = call_super ? FunctionKind::kDefaultSubclassConstructor
                                  : FunctionKind::kDefaultBaseConstructor;
   DeclarationScope* function_scope = NewFunctionScope(kind);
   SetLanguageMode(function_scope,
                   static_cast<LanguageMode>(language_mode | STRICT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
-  ZoneList<Statement*>* body = NULL;
+  ZoneChunkList<Statement*>* body = NULL;
 
   {
     FunctionState function_state(&function_state_, &scope_state_,
                                  function_scope);
 
-    body = new (zone()) ZoneList<Statement*>(call_super ? 2 : 1, zone());
+    body = new (zone()) ZoneChunkList<Statement*>(zone());
     if (call_super) {
       // $super_constructor = %_GetSuperConstructor(<this-function>)
       // %reflect_construct(
       //     $super_constructor, InternalArray(...args), new.target)
       auto constructor_args_name = ast_value_factory()->empty_string();
       bool is_duplicate;
       bool is_rest = true;
       bool is_optional = false;
       Variable* constructor_args = function_scope->DeclareParameter(
           constructor_args_name, TEMPORARY, is_optional, is_rest, &is_duplicate,
@@ skipping 16 matching lines @@
       spread_args_expr->Add(spread_args, zone());
       args->AddAll(*PrepareSpreadArguments(spread_args_expr), zone());
       VariableProxy* new_target_proxy =
           NewUnresolved(ast_value_factory()->new_target_string(), pos);
       args->Add(new_target_proxy, zone());
       Expression* call = factory()->NewCallRuntime(
           Context::REFLECT_CONSTRUCT_INDEX, args, pos);
       if (requires_class_field_init) {
         call = CallClassFieldInitializer(scope(), call);
       }
-      body->Add(factory()->NewReturnStatement(call, pos), zone());
+      body->push_back(factory()->NewReturnStatement(call, pos));
     }
 
     materialized_literal_count = function_state.materialized_literal_count();
     expected_property_count = function_state.expected_property_count();
   }
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       name, function_scope, body, materialized_literal_count,
       expected_property_count, parameter_count, parameter_count,
       FunctionLiteral::kNoDuplicateParameters,
@@ skipping 461 matching lines @@
       DCHECK_EQ(outer, info->script_scope());
       outer = NewModuleScope(info->script_scope());
     }
 
     DeclarationScope* scope = outer->AsDeclarationScope();
 
     scope->set_start_position(0);
 
     FunctionState function_state(&function_state_, &scope_state_, scope);
 
-    ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
+    ZoneChunkList<Statement*>* body =
+        new (zone()) ZoneChunkList<Statement*>(zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     if (parsing_module_) {
       // Declare the special module parameter.
       auto name = ast_value_factory()->empty_string();
       bool is_duplicate;
       bool is_rest = false;
       bool is_optional = false;
       auto var = scope->DeclareParameter(name, VAR, is_optional, is_rest,
                                          &is_duplicate, ast_value_factory());
       DCHECK(!is_duplicate);
       var->AllocateTo(VariableLocation::PARAMETER, 0);
 
       PrepareGeneratorVariables(&function_state);
       Expression* initial_yield =
           BuildInitialYield(kNoSourcePosition, kGeneratorFunction);
-      body->Add(
-          factory()->NewExpressionStatement(initial_yield, kNoSourcePosition),
-          zone());
+      body->push_back(
+          factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
 
       ParseModuleItemList(body, &ok);
       ok = ok &&
            module()->Validate(this->scope()->AsModuleScope(),
                               &pending_error_handler_, zone());
     } else {
       // Don't count the mode in the use counters--give the program a chance
       // to enable script-wide strict mode below.
       this->scope()->SetLanguageMode(info->language_mode());
       ParseStatementList(body, Token::EOS, &ok);
@@ skipping 13 matching lines @@
       // pre-existing bindings should be made writable, enumerable and
       // nonconfigurable if possible, whereas this code will leave attributes
       // unchanged if the property already exists.
       InsertSloppyBlockFunctionVarBindings(scope);
     }
     if (ok) {
       CheckConflictingVarDeclarations(scope, &ok);
     }
 
     if (ok && info->parse_restriction() == ONLY_SINGLE_FUNCTION_LITERAL) {
-      if (body->length() != 1 ||
-          !body->at(0)->IsExpressionStatement() ||
-          !body->at(0)->AsExpressionStatement()->
-              expression()->IsFunctionLiteral()) {
+      if (body->size() != 1 || !body->front()->IsExpressionStatement() ||
+          !body->front()
+               ->AsExpressionStatement()
+               ->expression()
+               ->IsFunctionLiteral()) {
         ReportMessage(MessageTemplate::kSingleFunctionLiteral);
         ok = false;
       }
     }
 
     if (ok) {
       RewriteDestructuringAssignments();
       int parameter_count = parsing_module_ ? 1 : 0;
       result = factory()->NewScriptOrEvalFunctionLiteral(
           scope, body, function_state.materialized_literal_count(),
@@ skipping 203 matching lines @@
     case Token::IMPORT:
       ParseImportDeclaration(CHECK_OK);
       return factory()->NewEmptyStatement(kNoSourcePosition);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
     default:
       return ParseStatementListItem(ok);
   }
 }
 
-
-void Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
+void Parser::ParseModuleItemList(ZoneChunkList<Statement*>* body, bool* ok) {
   // ecma262/#prod-Module
   // Module :
   //    ModuleBody?
   //
   // ecma262/#prod-ModuleItemList
   // ModuleBody :
   //    ModuleItem*
 
   DCHECK(scope()->is_module_scope());
   while (peek() != Token::EOS) {
     Statement* stat = ParseModuleItem(CHECK_OK_VOID);
     if (stat && !stat->IsEmpty()) {
-      body->Add(stat, zone());
+      body->push_back(stat);
     }
   }
 }
 
 
 const AstRawString* Parser::ParseModuleSpecifier(bool* ok) {
   // ModuleSpecifier :
   //    StringLiteral
 
   Expect(Token::STRING, CHECK_OK);
@@ skipping 449 matching lines @@
   if (sloppy_mode_block_scope_function_redefinition) {
     ++use_counts_[v8::Isolate::kSloppyModeBlockScopedFunctionRedefinition];
   }
   return variable;
 }
 
 Block* Parser::BuildInitializationBlock(
     DeclarationParsingResult* parsing_result,
     ZoneList<const AstRawString*>* names, bool* ok) {
   Block* result = factory()->NewBlock(
-      NULL, 1, true, parsing_result->descriptor.declaration_pos);
+      NULL, true, parsing_result->descriptor.declaration_pos);
   for (auto declaration : parsing_result->declarations) {
     PatternRewriter::DeclareAndInitializeVariables(
         this, result, &(parsing_result->descriptor), &declaration, names,
         CHECK_OK);
   }
   return result;
 }
 
 void Parser::DeclareAndInitializeVariables(
     Block* block, const DeclarationDescriptor* declaration_descriptor,
@@ skipping 170 matching lines @@
   // In order to get the CaseClauses to execute in their own lexical scope,
   // but without requiring downstream code to have special scope handling
   // code for switch statements, desugar into blocks as follows:
   // {  // To group the statements--harmless to evaluate Expression in scope
   //   .tag_variable = Expression;
   //   {  // To give CaseClauses a scope
   //     switch (.tag_variable) { CaseClause* }
   //   }
   // }
 
-  Block* switch_block = factory()->NewBlock(NULL, 2, false, kNoSourcePosition);
+  Block* switch_block = factory()->NewBlock(NULL, false, kNoSourcePosition);
 
   Variable* tag_variable =
       NewTemporary(ast_value_factory()->dot_switch_tag_string());
   Assignment* tag_assign = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(tag_variable), tag,
       tag->position());
   Statement* tag_statement =
       factory()->NewExpressionStatement(tag_assign, kNoSourcePosition);
-  switch_block->statements()->Add(tag_statement, zone());
+  switch_block->statements()->push_back(tag_statement);
 
   // make statement: undefined;
   // This is needed so the tag isn't returned as the value, in case the switch
   // statements don't have a value.
-  switch_block->statements()->Add(
-      factory()->NewExpressionStatement(
-          factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition),
-      zone());
+  switch_block->statements()->push_back(factory()->NewExpressionStatement(
+      factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition));
 
   Expression* tag_read = factory()->NewVariableProxy(tag_variable);
   switch_statement->Initialize(tag_read, cases);
-  Block* cases_block = factory()->NewBlock(NULL, 1, false, kNoSourcePosition);
-  cases_block->statements()->Add(switch_statement, zone());
+  Block* cases_block = factory()->NewBlock(NULL, false, kNoSourcePosition);
+  cases_block->statements()->push_back(switch_statement);
   cases_block->set_scope(scope);
-  switch_block->statements()->Add(cases_block, zone());
+  switch_block->statements()->push_back(cases_block);
   return switch_block;
 }
 
 void Parser::RewriteCatchPattern(CatchInfo* catch_info, bool* ok) {
   if (catch_info->name == nullptr) {
     DCHECK_NOT_NULL(catch_info->pattern);
     catch_info->name = ast_value_factory()->dot_catch_string();
   }
   catch_info->variable = catch_info->scope->DeclareLocal(
       catch_info->name, VAR, kCreatedInitialized, NORMAL_VARIABLE);
   if (catch_info->pattern != nullptr) {
     DeclarationDescriptor descriptor;
     descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
     descriptor.scope = scope();
     descriptor.hoist_scope = nullptr;
     descriptor.mode = LET;
     descriptor.declaration_pos = catch_info->pattern->position();
     descriptor.initialization_pos = catch_info->pattern->position();
 
     // Initializer position for variables declared by the pattern.
     const int initializer_position = position();
 
     DeclarationParsingResult::Declaration decl(
         catch_info->pattern, initializer_position,
         factory()->NewVariableProxy(catch_info->variable));
 
     catch_info->init_block =
-        factory()->NewBlock(nullptr, 8, true, kNoSourcePosition);
+        factory()->NewBlock(nullptr, true, kNoSourcePosition);
     PatternRewriter::DeclareAndInitializeVariables(
         this, catch_info->init_block, &descriptor, &decl,
         &catch_info->bound_names, ok);
   } else {
     catch_info->bound_names.Add(catch_info->name, zone());
   }
 }
 
 void Parser::ValidateCatchBlock(const CatchInfo& catch_info, bool* ok) {
   // Check for `catch(e) { let e; }` and similar errors.
@@ skipping 30 matching lines @@
     if (catch_info.for_promise_reject) {
       statement = factory()->NewTryCatchStatementForPromiseReject(
           try_block, catch_info.scope, catch_info.variable, catch_block,
           kNoSourcePosition);
     } else {
       statement = factory()->NewTryCatchStatement(
           try_block, catch_info.scope, catch_info.variable, catch_block,
           kNoSourcePosition);
     }
 
-    try_block = factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
-    try_block->statements()->Add(statement, zone());
+    try_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
+    try_block->statements()->push_back(statement);
     catch_block = nullptr;  // Clear to indicate it's been handled.
   }
 
   if (catch_block != nullptr) {
     // For a try-catch construct append return expressions from the catch block
     // to the list of return expressions.
     function_state_->tail_call_expressions().Append(
         catch_info.tail_call_expressions);
 
     DCHECK_NULL(finally_block);
@@ skipping 55 matching lines @@
     return InitializeForOfStatement(for_of, each, subject, body, finalize,
                                     each_keyword_pos);
   } else {
     if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
       Variable* temp = NewTemporary(ast_value_factory()->empty_string());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
       Expression* assign_each = PatternRewriter::RewriteDestructuringAssignment(
           this, factory()->NewAssignment(Token::ASSIGN, each, temp_proxy,
                                          kNoSourcePosition),
           scope());
-      auto block = factory()->NewBlock(nullptr, 2, false, kNoSourcePosition);
-      block->statements()->Add(
-          factory()->NewExpressionStatement(assign_each, kNoSourcePosition),
-          zone());
-      block->statements()->Add(body, zone());
+      auto block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
+      block->statements()->push_back(
+          factory()->NewExpressionStatement(assign_each, kNoSourcePosition));
+      block->statements()->push_back(body);
       body = block;
       each = factory()->NewVariableProxy(temp);
     }
     stmt->AsForInStatement()->Initialize(each, subject, body);
   }
   return stmt;
 }
 
 // Special case for legacy for
 //
@@ skipping 13 matching lines @@
 // is added as a second statement to it.
 Block* Parser::RewriteForVarInLegacy(const ForInfo& for_info) {
   const DeclarationParsingResult::Declaration& decl =
       for_info.parsing_result.declarations[0];
   if (!IsLexicalVariableMode(for_info.parsing_result.descriptor.mode) &&
       decl.pattern->IsVariableProxy() && decl.initializer != nullptr) {
     ++use_counts_[v8::Isolate::kForInInitializer];
     const AstRawString* name = decl.pattern->AsVariableProxy()->raw_name();
     VariableProxy* single_var = NewUnresolved(name);
     Block* init_block = factory()->NewBlock(
-        nullptr, 2, true, for_info.parsing_result.descriptor.declaration_pos);
-    init_block->statements()->Add(
-        factory()->NewExpressionStatement(
-            factory()->NewAssignment(Token::ASSIGN, single_var,
-                                     decl.initializer, kNoSourcePosition),
-            kNoSourcePosition),
-        zone());
+        nullptr, true, for_info.parsing_result.descriptor.declaration_pos);
+    init_block->statements()->push_back(factory()->NewExpressionStatement(
+        factory()->NewAssignment(Token::ASSIGN, single_var, decl.initializer,
+                                 kNoSourcePosition),
+        kNoSourcePosition));
     return init_block;
   }
   return nullptr;
 }
 
 // Rewrite a for-in/of statement of the form
 //
 //   for (let/const/var x in/of e) b
 //
 // into
 //
 //   {
 //     <let x' be a temporary variable>
 //     for (x' in/of e) {
 //       let/const/var x;
 //       x = x';
 //       b;
 //     }
 //     let x;  // for TDZ
 //   }
 void Parser::DesugarBindingInForEachStatement(ForInfo* for_info,
                                               Block** body_block,
                                               Expression** each_variable,
                                               bool* ok) {
   DeclarationParsingResult::Declaration& decl =
       for_info->parsing_result.declarations[0];
   Variable* temp = NewTemporary(ast_value_factory()->dot_for_string());
   auto each_initialization_block =
-      factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
+      factory()->NewBlock(nullptr, true, kNoSourcePosition);
   {
     auto descriptor = for_info->parsing_result.descriptor;
     descriptor.declaration_pos = kNoSourcePosition;
     descriptor.initialization_pos = kNoSourcePosition;
     decl.initializer = factory()->NewVariableProxy(temp);
 
     bool is_for_var_of =
         for_info->mode == ForEachStatement::ITERATE &&
         for_info->parsing_result.descriptor.mode == VariableMode::VAR;
 
@@ skipping 24 matching lines @@
                             MessageTemplate::kVarRedeclaration, name);
             *ok = false;
             return;
           }
         }
         catch_scope = catch_scope->outer_scope();
       }
     }
   }
 
-  *body_block = factory()->NewBlock(nullptr, 3, false, kNoSourcePosition);
-  (*body_block)->statements()->Add(each_initialization_block, zone());
+  *body_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
+  (*body_block)->statements()->push_back(each_initialization_block);
   *each_variable = factory()->NewVariableProxy(temp, for_info->position);
 }
 
 // Create a TDZ for any lexically-bound names in for in/of statements.
 Block* Parser::CreateForEachStatementTDZ(Block* init_block,
                                          const ForInfo& for_info, bool* ok) {
   if (IsLexicalVariableMode(for_info.parsing_result.descriptor.mode)) {
     DCHECK_NULL(init_block);
 
-    init_block = factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
+    init_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
 
     for (int i = 0; i < for_info.bound_names.length(); ++i) {
       // TODO(adamk): This needs to be some sort of special
       // INTERNAL variable that's invisible to the debugger
       // but visible to everything else.
       Declaration* tdz_decl = DeclareVariable(for_info.bound_names[i], LET,
                                               kNoSourcePosition, CHECK_OK);
       tdz_decl->proxy()->var()->set_initializer_position(position());
     }
   }
@@ skipping 55 matching lines @@
   }
 
   // {{completion = kAbruptCompletion;}}
   Statement* set_completion_abrupt;
   if (finalize) {
     Expression* proxy = factory()->NewVariableProxy(completion);
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, proxy,
         factory()->NewSmiLiteral(Parser::kAbruptCompletion, nopos), nopos);
 
-    Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
-    block->statements()->Add(
-        factory()->NewExpressionStatement(assignment, nopos), zone());
+    Block* block = factory()->NewBlock(nullptr, true, nopos);
+    block->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, nopos));
     set_completion_abrupt = block;
   }
 
   // do { let tmp = #result_value; #set_completion_abrupt; tmp }
   // Expression* result_value (gets overwritten)
   if (finalize) {
     Variable* var_tmp = NewTemporary(avfactory->empty_string());
     Expression* tmp = factory()->NewVariableProxy(var_tmp);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, tmp, result_value, nopos);
 
-    Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
-    block->statements()->Add(
-        factory()->NewExpressionStatement(assignment, nopos), zone());
-    block->statements()->Add(set_completion_abrupt, zone());
+    Block* block = factory()->NewBlock(nullptr, false, nopos);
+    block->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, nopos));
+    block->statements()->push_back(set_completion_abrupt);
 
     result_value = factory()->NewDoExpression(block, var_tmp, nopos);
   }
 
   // each = #result_value;
   Expression* assign_each;
   {
     assign_each =
         factory()->NewAssignment(Token::ASSIGN, each, result_value, nopos);
     if (each->IsArrayLiteral() || each->IsObjectLiteral()) {
       assign_each = PatternRewriter::RewriteDestructuringAssignment(
           this, assign_each->AsAssignment(), scope());
     }
   }
 
   // {{completion = kNormalCompletion;}}
   Statement* set_completion_normal;
   if (finalize) {
     Expression* proxy = factory()->NewVariableProxy(completion);
     Expression* assignment = factory()->NewAssignment(
         Token::ASSIGN, proxy,
         factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
 
-    Block* block = factory()->NewBlock(nullptr, 1, true, nopos);
-    block->statements()->Add(
-        factory()->NewExpressionStatement(assignment, nopos), zone());
+    Block* block = factory()->NewBlock(nullptr, true, nopos);
+    block->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, nopos));
     set_completion_normal = block;
   }
 
   // { #loop-body; #set_completion_normal }
   // Statement* body (gets overwritten)
   if (finalize) {
-    Block* block = factory()->NewBlock(nullptr, 2, false, nopos);
-    block->statements()->Add(body, zone());
-    block->statements()->Add(set_completion_normal, zone());
+    Block* block = factory()->NewBlock(nullptr, false, nopos);
+    block->statements()->push_back(body);
+    block->statements()->push_back(set_completion_normal);
     body = block;
   }
 
   for_of->Initialize(body, iterator, assign_iterator, next_result, result_done,
                      assign_each);
   return finalize ? FinalizeForOfStatement(for_of, completion, nopos) : for_of;
 }
 
 Statement* Parser::DesugarLexicalBindingsInForStatement(
     ForStatement* loop, Statement* init, Expression* cond, Statement* next,
@@ skipping 31 matching lines @@
   //      }
   //      {{ if (flag == 1)  // Body used break.
   //           break;
   //      }}
   //    }
   //  }
 
   DCHECK(for_info.bound_names.length() > 0);
   ZoneList<Variable*> temps(for_info.bound_names.length(), zone());
 
-  Block* outer_block = factory()->NewBlock(
-      nullptr, for_info.bound_names.length() + 4, false, kNoSourcePosition);
+  Block* outer_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
 
   // Add statement: let/const x = i.
-  outer_block->statements()->Add(init, zone());
+  outer_block->statements()->push_back(init);
 
   const AstRawString* temp_name = ast_value_factory()->dot_for_string();
 
   // For each lexical variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < for_info.bound_names.length(); i++) {
     VariableProxy* proxy = NewUnresolved(for_info.bound_names[i]);
     Variable* temp = NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(Token::ASSIGN, temp_proxy,
                                                       proxy, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-    outer_block->statements()->Add(assignment_statement, zone());
+    outer_block->statements()->push_back(assignment_statement);
     temps.Add(temp, zone());
   }
 
   Variable* first = NULL;
   // Make statement: first = 1.
   if (next) {
     first = NewTemporary(temp_name);
     VariableProxy* first_proxy = factory()->NewVariableProxy(first);
     Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, first_proxy, const1, kNoSourcePosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-    outer_block->statements()->Add(assignment_statement, zone());
+    outer_block->statements()->push_back(assignment_statement);
   }
 
   // make statement: undefined;
-  outer_block->statements()->Add(
-      factory()->NewExpressionStatement(
-          factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition),
-      zone());
+  outer_block->statements()->push_back(factory()->NewExpressionStatement(
+      factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition));
 
   // Make statement: outer: for (;;)
   // Note that we don't actually create the label, or set this loop up as an
   // explicit break target, instead handing it directly to those nodes that
   // need to know about it. This should be safe because we don't run any code
   // in this function that looks up break targets.
   ForStatement* outer_loop =
       factory()->NewForStatement(NULL, kNoSourcePosition);
-  outer_block->statements()->Add(outer_loop, zone());
+  outer_block->statements()->push_back(outer_loop);
   outer_block->set_scope(scope());
 
-  Block* inner_block = factory()->NewBlock(NULL, 3, false, kNoSourcePosition);
+  Block* inner_block = factory()->NewBlock(NULL, false, kNoSourcePosition);
   {
     BlockState block_state(&scope_state_, inner_scope);
 
-    Block* ignore_completion_block = factory()->NewBlock(
-        nullptr, for_info.bound_names.length() + 3, true, kNoSourcePosition);
+    Block* ignore_completion_block =
+        factory()->NewBlock(nullptr, true, kNoSourcePosition);
     ZoneList<Variable*> inner_vars(for_info.bound_names.length(), zone());
     // For each let variable x:
     //    make statement: let/const x = temp_x.
     for (int i = 0; i < for_info.bound_names.length(); i++) {
       Declaration* decl = DeclareVariable(
           for_info.bound_names[i], for_info.parsing_result.descriptor.mode,
           kNoSourcePosition, CHECK_OK);
       inner_vars.Add(decl->proxy()->var(), zone());
       VariableProxy* temp_proxy = factory()->NewVariableProxy(temps.at(i));
       Assignment* assignment = factory()->NewAssignment(
           Token::INIT, decl->proxy(), temp_proxy, kNoSourcePosition);
       Statement* assignment_statement =
           factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       DCHECK(init->position() != kNoSourcePosition);
       decl->proxy()->var()->set_initializer_position(init->position());
-      ignore_completion_block->statements()->Add(assignment_statement, zone());
+      ignore_completion_block->statements()->push_back(assignment_statement);
     }
 
     // Make statement: if (first == 1) { first = 0; } else { next; }
     if (next) {
       DCHECK(first);
       Expression* compare = NULL;
       // Make compare expression: first == 1.
       {
         Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
         VariableProxy* first_proxy = factory()->NewVariableProxy(first);
         compare = factory()->NewCompareOperation(Token::EQ, first_proxy, const1,
                                                  kNoSourcePosition);
       }
       Statement* clear_first = NULL;
       // Make statement: first = 0.
       {
         VariableProxy* first_proxy = factory()->NewVariableProxy(first);
         Expression* const0 = factory()->NewSmiLiteral(0, kNoSourcePosition);
         Assignment* assignment = factory()->NewAssignment(
             Token::ASSIGN, first_proxy, const0, kNoSourcePosition);
         clear_first =
             factory()->NewExpressionStatement(assignment, kNoSourcePosition);
       }
       Statement* clear_first_or_next = factory()->NewIfStatement(
           compare, clear_first, next, kNoSourcePosition);
-      ignore_completion_block->statements()->Add(clear_first_or_next, zone());
+      ignore_completion_block->statements()->push_back(clear_first_or_next);
     }
 
     Variable* flag = NewTemporary(temp_name);
     // Make statement: flag = 1.
     {
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, flag_proxy, const1, kNoSourcePosition);
       Statement* assignment_statement =
           factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-      ignore_completion_block->statements()->Add(assignment_statement, zone());
+      ignore_completion_block->statements()->push_back(assignment_statement);
     }
 
     // Make statement: if (!cond) break.
     if (cond) {
       Statement* stop =
           factory()->NewBreakStatement(outer_loop, kNoSourcePosition);
       Statement* noop = factory()->NewEmptyStatement(kNoSourcePosition);
-      ignore_completion_block->statements()->Add(
-          factory()->NewIfStatement(cond, noop, stop, cond->position()),
-          zone());
+      ignore_completion_block->statements()->push_back(
+          factory()->NewIfStatement(cond, noop, stop, cond->position()));
     }
 
-    inner_block->statements()->Add(ignore_completion_block, zone());
+    inner_block->statements()->push_back(ignore_completion_block);
     // Make cond expression for main loop: flag == 1.
     Expression* flag_cond = NULL;
     {
       Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
       VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
       flag_cond = factory()->NewCompareOperation(Token::EQ, flag_proxy, const1,
                                                  kNoSourcePosition);
     }
 
     // Create chain of expressions "flag = 0, temp_x = x, ..."
@@ skipping 22 matching lines @@
 
       compound_next_statement =
           factory()->NewExpressionStatement(compound_next, kNoSourcePosition);
     }
 
     // Make statement: labels: for (; flag == 1; flag = 0, temp_x = x)
     // Note that we re-use the original loop node, which retains its labels
     // and ensures that any break or continue statements in body point to
     // the right place.
     loop->Initialize(NULL, flag_cond, compound_next_statement, body);
-    inner_block->statements()->Add(loop, zone());
+    inner_block->statements()->push_back(loop);
 
     // Make statement: {{if (flag == 1) break;}}
     {
       Expression* compare = NULL;
       // Make compare expresion: flag == 1.
       {
         Expression* const1 = factory()->NewSmiLiteral(1, kNoSourcePosition);
         VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
         compare = factory()->NewCompareOperation(Token::EQ, flag_proxy, const1,
                                                  kNoSourcePosition);
       }
       Statement* stop =
           factory()->NewBreakStatement(outer_loop, kNoSourcePosition);
       Statement* empty = factory()->NewEmptyStatement(kNoSourcePosition);
       Statement* if_flag_break =
           factory()->NewIfStatement(compare, stop, empty, kNoSourcePosition);
       Block* ignore_completion_block =
-          factory()->NewBlock(NULL, 1, true, kNoSourcePosition);
-      ignore_completion_block->statements()->Add(if_flag_break, zone());
-      inner_block->statements()->Add(ignore_completion_block, zone());
+          factory()->NewBlock(NULL, true, kNoSourcePosition);
+      ignore_completion_block->statements()->push_back(if_flag_break);
+      inner_block->statements()->push_back(ignore_completion_block);
     }
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     inner_block->set_scope(inner_scope);
   }
 
   outer_loop->Initialize(NULL, NULL, NULL, inner_block);
   return outer_block;
 }
 
@@ skipping 212 matching lines @@
               (allow_lazy() && function_type == FunctionLiteral::kDeclaration &&
                eager_compile_hint == FunctionLiteral::kShouldLazyCompile))) &&
       !(FLAG_validate_asm && scope()->IsAsmModule());
   bool is_lazy_inner_function =
       use_temp_zone && FLAG_lazy_inner_functions && !is_lazy_top_level_function;
 
   // This Scope lives in the main zone. We'll migrate data into that zone later.
   DeclarationScope* scope = NewFunctionScope(kind);
   SetLanguageMode(scope, language_mode);
 
-  ZoneList<Statement*>* body = nullptr;
+  ZoneChunkList<Statement*>* body = nullptr;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   DuplicateFinder duplicate_finder(scanner()->unicode_cache());
   bool should_be_used_once_hint = false;
   bool has_duplicate_parameters;
 
   FunctionState function_state(&function_state_, &scope_state_, scope);
 #ifdef DEBUG
   scope->SetScopeName(function_name);
 #endif
@@ skipping 268 matching lines @@
 void Parser::RewriteParameterInitializer(Expression* expr, Scope* scope) {
   InitializerRewriter rewriter(stack_limit_, expr, this, scope);
   rewriter.Run();
 }
 
 
 Block* Parser::BuildParameterInitializationBlock(
     const ParserFormalParameters& parameters, bool* ok) {
   DCHECK(!parameters.is_simple);
   DCHECK(scope()->is_function_scope());
-  Block* init_block = factory()->NewBlock(NULL, 1, true, kNoSourcePosition);
+  Block* init_block = factory()->NewBlock(NULL, true, kNoSourcePosition);
   for (int i = 0; i < parameters.params.length(); ++i) {
     auto parameter = parameters.params[i];
     if (parameter.is_rest && parameter.pattern->IsVariableProxy()) break;
     DeclarationDescriptor descriptor;
     descriptor.declaration_kind = DeclarationDescriptor::PARAMETER;
     descriptor.scope = scope();
     descriptor.hoist_scope = nullptr;
     descriptor.mode = LET;
     descriptor.declaration_pos = parameter.pattern->position();
     // The position that will be used by the AssignmentExpression
@@ skipping 19 matching lines @@
       descriptor.initialization_pos = parameter.initializer->position();
     }
 
     Scope* param_scope = scope();
     Block* param_block = init_block;
     if (!parameter.is_simple() && scope()->calls_sloppy_eval()) {
       param_scope = NewVarblockScope();
       param_scope->set_start_position(descriptor.initialization_pos);
       param_scope->set_end_position(parameter.initializer_end_position);
       param_scope->RecordEvalCall();
-      param_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
+      param_block = factory()->NewBlock(NULL, true, kNoSourcePosition);
       param_block->set_scope(param_scope);
       descriptor.hoist_scope = scope();
       // Pass the appropriate scope in so that PatternRewriter can appropriately
       // rewrite inner initializers of the pattern to param_scope
       descriptor.scope = param_scope;
       // Rewrite the outer initializer to point to param_scope
       ReparentParameterExpressionScope(stack_limit(), initial_value,
                                        param_scope);
     }
 
     BlockState block_state(&scope_state_, param_scope);
     DeclarationParsingResult::Declaration decl(
         parameter.pattern, parameter.initializer_end_position, initial_value);
     PatternRewriter::DeclareAndInitializeVariables(
         this, param_block, &descriptor, &decl, nullptr, CHECK_OK);
 
     if (param_block != init_block) {
       param_scope = block_state.FinalizedBlockScope();
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);
       }
-      init_block->statements()->Add(param_block, zone());
+      init_block->statements()->push_back(param_block);
     }
   }
   return init_block;
 }
 
 Block* Parser::BuildRejectPromiseOnException(Block* inner_block, bool* ok) {
   // .promise = %AsyncFunctionPromiseCreate();
   // try {
   //   <inner_block>
   // } catch (.catch) {
   //   %RejectPromise(.promise, .catch);
   //   return .promise;
   // } finally {
   //   %AsyncFunctionPromiseRelease(.promise);
   // }
-  Block* result = factory()->NewBlock(nullptr, 2, true, kNoSourcePosition);
+  Block* result = factory()->NewBlock(nullptr, true, kNoSourcePosition);
 
   // .promise = %AsyncFunctionPromiseCreate();
   Statement* set_promise;
   {
     Expression* create_promise = factory()->NewCallRuntime(
         Context::ASYNC_FUNCTION_PROMISE_CREATE_INDEX,
         new (zone()) ZoneList<Expression*>(0, zone()), kNoSourcePosition);
     Assignment* assign_promise = factory()->NewAssignment(
         Token::INIT, factory()->NewVariableProxy(PromiseVariable()),
         create_promise, kNoSourcePosition);
     set_promise =
         factory()->NewExpressionStatement(assign_promise, kNoSourcePosition);
   }
-  result->statements()->Add(set_promise, zone());
+  result->statements()->push_back(set_promise);
 
   // catch (.catch) { return %RejectPromise(.promise, .catch), .promise }
   Scope* catch_scope = NewScope(CATCH_SCOPE);
   catch_scope->set_is_hidden();
   Variable* catch_variable =
       catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                 kCreatedInitialized, NORMAL_VARIABLE);
-  Block* catch_block = factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
+  Block* catch_block = factory()->NewBlock(nullptr, true, kNoSourcePosition);
 
   Expression* promise_reject = BuildRejectPromise(
       factory()->NewVariableProxy(catch_variable), kNoSourcePosition);
   ReturnStatement* return_promise_reject =
       factory()->NewReturnStatement(promise_reject, kNoSourcePosition);
-  catch_block->statements()->Add(return_promise_reject, zone());
+  catch_block->statements()->push_back(return_promise_reject);
 
   TryStatement* try_catch_statement =
       factory()->NewTryCatchStatementForAsyncAwait(inner_block, catch_scope,
                                                    catch_variable, catch_block,
                                                    kNoSourcePosition);
 
   // There is no TryCatchFinally node, so wrap it in an outer try/finally
   Block* outer_try_block =
-      factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
-  outer_try_block->statements()->Add(try_catch_statement, zone());
+      factory()->NewBlock(nullptr, true, kNoSourcePosition);
+  outer_try_block->statements()->push_back(try_catch_statement);
 
   // finally { %AsyncFunctionPromiseRelease(.promise) }
-  Block* finally_block =
-      factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
+  Block* finally_block = factory()->NewBlock(nullptr, true, kNoSourcePosition);
   {
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
     args->Add(factory()->NewVariableProxy(PromiseVariable()), zone());
     Expression* call_promise_release = factory()->NewCallRuntime(
         Context::ASYNC_FUNCTION_PROMISE_RELEASE_INDEX, args, kNoSourcePosition);
     Statement* promise_release = factory()->NewExpressionStatement(
         call_promise_release, kNoSourcePosition);
-    finally_block->statements()->Add(promise_release, zone());
+    finally_block->statements()->push_back(promise_release);
   }
 
   Statement* try_finally_statement = factory()->NewTryFinallyStatement(
       outer_try_block, finally_block, kNoSourcePosition);
 
-  result->statements()->Add(try_finally_statement, zone());
+  result->statements()->push_back(try_finally_statement);
   return result;
 }
 
 Expression* Parser::BuildCreateJSGeneratorObject(int pos, FunctionKind kind) {
   DCHECK_NOT_NULL(function_state_->generator_object_variable());
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(factory()->NewThisFunction(pos), zone());
   args->Add(IsArrowFunction(kind) ? GetLiteralUndefined(pos)
                                   : ThisExpression(kNoSourcePosition),
             zone());
@@ skipping 48 matching lines @@
       Token::INIT, init_proxy, allocation, kNoSourcePosition);
   VariableProxy* get_proxy =
       factory()->NewVariableProxy(function_state_->generator_object_variable());
   // The position of the yield is important for reporting the exception
   // caused by calling the .throw method on a generator suspended at the
   // initial yield (i.e. right after generator instantiation).
   return factory()->NewYield(get_proxy, assignment, scope()->start_position(),
                              Yield::kOnExceptionThrow);
 }
 
-ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
+ZoneChunkList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos,
     const ParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   ParsingModeScope mode(this, allow_lazy() ? PARSE_LAZILY : PARSE_EAGERLY);
-  ZoneList<Statement*>* result = new(zone()) ZoneList<Statement*>(8, zone());
+  ZoneChunkList<Statement*>* result =
+      new (zone()) ZoneChunkList<Statement*>(zone());
 
   static const int kFunctionNameAssignmentIndex = 0;
   if (function_type == FunctionLiteral::kNamedExpression) {
     DCHECK(function_name != NULL);
     // If we have a named function expression, we add a local variable
     // declaration to the body of the function with the name of the
     // function and let it refer to the function itself (closure).
     // Not having parsed the function body, the language mode may still change,
     // so we reserve a spot and create the actual const assignment later.
-    DCHECK_EQ(kFunctionNameAssignmentIndex, result->length());
-    result->Add(NULL, zone());
+    DCHECK_EQ(kFunctionNameAssignmentIndex, result->size());
+    result->push_back(NULL);
   }
 
-  ZoneList<Statement*>* body = result;
+  ZoneChunkList<Statement*>* body = result;
   DeclarationScope* function_scope = scope()->AsDeclarationScope();
   DeclarationScope* inner_scope = function_scope;
   Block* inner_block = nullptr;
   if (!parameters.is_simple) {
     inner_scope = NewVarblockScope();
     inner_scope->set_start_position(scanner()->location().beg_pos);
-    inner_block = factory()->NewBlock(NULL, 8, true, kNoSourcePosition);
+    inner_block = factory()->NewBlock(NULL, true, kNoSourcePosition);
     inner_block->set_scope(inner_scope);
     body = inner_block->statements();
   }
 
   {
     BlockState block_state(&scope_state_, inner_scope);
 
     if (IsGeneratorFunction(kind)) {
       // We produce:
       //
       // try { InitialYield; ...body...; return {value: undefined, done: true} }
       // finally { %_GeneratorClose(generator) }
       //
       // - InitialYield yields the actual generator object.
       // - Any return statement inside the body will have its argument wrapped
       //   in a "done" iterator result object.
       // - If the generator terminates for whatever reason, we must close it.
       //   Hence the finally clause.
 
-      Block* try_block =
-          factory()->NewBlock(nullptr, 3, false, kNoSourcePosition);
+      Block* try_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
       Expression* initial_yield = BuildInitialYield(pos, kind);
-      try_block->statements()->Add(
-          factory()->NewExpressionStatement(initial_yield, kNoSourcePosition),
-          zone());
+      try_block->statements()->push_back(
+          factory()->NewExpressionStatement(initial_yield, kNoSourcePosition));
       ParseStatementList(try_block->statements(), Token::RBRACE, CHECK_OK);
 
       Statement* final_return = factory()->NewReturnStatement(
           BuildIteratorResult(nullptr, true), kNoSourcePosition);
-      try_block->statements()->Add(final_return, zone());
+      try_block->statements()->push_back(final_return);
 
       Block* finally_block =
-          factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
+          factory()->NewBlock(nullptr, false, kNoSourcePosition);
       ZoneList<Expression*>* args =
           new (zone()) ZoneList<Expression*>(1, zone());
       VariableProxy* call_proxy = factory()->NewVariableProxy(
           function_state_->generator_object_variable());
       args->Add(call_proxy, zone());
       Expression* call = factory()->NewCallRuntime(
           Runtime::kInlineGeneratorClose, args, kNoSourcePosition);
-      finally_block->statements()->Add(
-          factory()->NewExpressionStatement(call, kNoSourcePosition), zone());
+      finally_block->statements()->push_back(
+          factory()->NewExpressionStatement(call, kNoSourcePosition));
 
-      body->Add(factory()->NewTryFinallyStatement(try_block, finally_block,
-                                                  kNoSourcePosition),
-                zone());
+      body->push_back(factory()->NewTryFinallyStatement(
+          try_block, finally_block, kNoSourcePosition));
     } else if (IsAsyncFunction(kind)) {
       const bool accept_IN = true;
       ParseAsyncFunctionBody(inner_scope, body, kind, FunctionBodyType::kNormal,
                              accept_IN, pos, CHECK_OK);
     } else {
       ParseStatementList(body, Token::RBRACE, CHECK_OK);
     }
 
     if (IsSubclassConstructor(kind)) {
-      body->Add(factory()->NewReturnStatement(ThisExpression(kNoSourcePosition),
-                                              kNoSourcePosition),
-                zone());
+      body->push_back(factory()->NewReturnStatement(
+          ThisExpression(kNoSourcePosition), kNoSourcePosition));
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope()->set_end_position(scanner()->location().end_pos);
 
   if (!parameters.is_simple) {
     DCHECK_NOT_NULL(inner_scope);
     DCHECK_EQ(function_scope, scope());
     DCHECK_EQ(function_scope, inner_scope->outer_scope());
@@ skipping 12 matching lines @@
 
     DCHECK_NOT_NULL(init_block);
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     if (inner_scope->FinalizeBlockScope() != nullptr) {
       CheckConflictingVarDeclarations(inner_scope, CHECK_OK);
       InsertShadowingVarBindingInitializers(inner_block);
     }
     inner_scope = nullptr;
 
-    result->Add(init_block, zone());
-    result->Add(inner_block, zone());
+    result->push_back(init_block);
+    result->push_back(inner_block);
   } else {
     DCHECK_EQ(inner_scope, function_scope);
     if (is_sloppy(function_scope->language_mode())) {
       InsertSloppyBlockFunctionVarBindings(function_scope);
     }
   }
 
   if (!IsArrowFunction(kind)) {
     // Declare arguments after parsing the function since lexical 'arguments'
     // masks the arguments object. Declare arguments before declaring the
@@ skipping 10 matching lines @@
       Variable* fvar = function_scope->DeclareFunctionVar(function_name);
       VariableProxy* fproxy = factory()->NewVariableProxy(fvar);
       statement = factory()->NewExpressionStatement(
           factory()->NewAssignment(Token::INIT, fproxy,
                                    factory()->NewThisFunction(pos),
                                    kNoSourcePosition),
           kNoSourcePosition);
     } else {
       statement = factory()->NewEmptyStatement(kNoSourcePosition);
     }
-    result->Set(kFunctionNameAssignmentIndex, statement);
+
+    {
+      auto it = result->begin();
+      for (int i = 0; i < kFunctionNameAssignmentIndex; i++) it++;
+      *it = statement;
+    }
   }
 
   MarkCollectedTailCallExpressions();
   return result;
 }
 
 PreParser::PreParseResult Parser::ParseFunctionBodyWithPreParser(
     SingletonLogger* logger, bool is_inner_function, bool may_abort) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.PreParse");
 
@@ skipping 19 matching lines @@
 
   DeclarationScope* function_scope = function_state_->scope();
   PreParser::PreParseResult result = reusable_preparser_->PreParseFunction(
       function_scope, parsing_module_, logger, is_inner_function, may_abort,
       use_counts_);
   return result;
 }
 
 Expression* Parser::InstallHomeObject(Expression* function_literal,
                                       Expression* home_object) {
-  Block* do_block = factory()->NewBlock(nullptr, 1, false, kNoSourcePosition);
+  Block* do_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
   Variable* result_var =
       scope()->NewTemporary(ast_value_factory()->empty_string());
   DoExpression* do_expr =
       factory()->NewDoExpression(do_block, result_var, kNoSourcePosition);
   Assignment* init = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(result_var), function_literal,
       kNoSourcePosition);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(init, kNoSourcePosition), zone());
+  do_block->statements()->push_back(
+      factory()->NewExpressionStatement(init, kNoSourcePosition));
   Property* home_object_property = factory()->NewProperty(
       factory()->NewVariableProxy(result_var),
       factory()->NewSymbolLiteral("home_object_symbol", kNoSourcePosition),
       kNoSourcePosition);
   Assignment* assignment = factory()->NewAssignment(
       Token::ASSIGN, home_object_property, home_object, kNoSourcePosition);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(assignment, kNoSourcePosition), zone());
+  do_block->statements()->push_back(
+      factory()->NewExpressionStatement(assignment, kNoSourcePosition));
   return do_expr;
 }
 
 const AstRawString* ClassFieldVariableName(bool is_name,
                                            AstValueFactory* ast_value_factory,
                                            int index) {
   std::string name =
       ".class-field-" + std::to_string(index) + (is_name ? "-name" : "-func");
   return ast_value_factory->GetOneByteString(name.c_str());
 }
@@ skipping 18 matching lines @@
   //   DONT_ENUM, false)
 
   RaiseLanguageMode(STRICT);
   FunctionKind kind = FunctionKind::kConciseMethod;
   DeclarationScope* initializer_scope = NewFunctionScope(kind);
   SetLanguageMode(initializer_scope, language_mode());
   initializer_scope->set_start_position(scanner()->location().end_pos);
   initializer_scope->set_end_position(scanner()->location().end_pos);
   FunctionState initializer_state(&function_state_, &scope_state_,
                                   initializer_scope);
-  ZoneList<Statement*>* body = new (zone()) ZoneList<Statement*>(count, zone());
+  ZoneChunkList<Statement*>* body =
+      new (zone()) ZoneChunkList<Statement*>(zone());
   for (int i = 0; i < count; ++i) {
     const AstRawString* name =
         ClassFieldVariableName(true, ast_value_factory(), i);
     VariableProxy* name_proxy = scope()->NewUnresolved(factory(), name);
     const AstRawString* function_name =
         ClassFieldVariableName(false, ast_value_factory(), i);
     VariableProxy* function_proxy =
         scope()->NewUnresolved(factory(), function_name);
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
     args->Add(function_proxy, zone());
     args->Add(ThisExpression(kNoSourcePosition), zone());
     Expression* call = factory()->NewCallRuntime(Runtime::kInlineCall, args,
                                                  kNoSourcePosition);
     ZoneList<Expression*>* define_property_args =
         new (zone()) ZoneList<Expression*>(5, zone());
     define_property_args->Add(ThisExpression(kNoSourcePosition), zone());
     define_property_args->Add(name_proxy, zone());
     define_property_args->Add(call, zone());
     define_property_args->Add(
         factory()->NewNumberLiteral(DONT_ENUM, kNoSourcePosition), zone());
     define_property_args->Add(
         factory()->NewNumberLiteral(
             false,  // TODO(bakkot) function name inference a la class { x =
                     // function(){}; static y = function(){}; }
             kNoSourcePosition),
         zone());
-    body->Add(factory()->NewExpressionStatement(
-                  factory()->NewCallRuntime(
-                      Runtime::kDefineDataProperty,
-                      define_property_args,  // TODO(bakkot) verify that this is
-                      // the same as object_define_property
-                      kNoSourcePosition),
-                  kNoSourcePosition),
-              zone());
+    body->push_back(factory()->NewExpressionStatement(
+        factory()->NewCallRuntime(
+            Runtime::kDefineDataProperty,
+            define_property_args,  // TODO(bakkot) verify that this is
+            // the same as object_define_property
+            kNoSourcePosition),
+        kNoSourcePosition));
   }
-  body->Add(factory()->NewReturnStatement(ThisExpression(kNoSourcePosition),
-                                          kNoSourcePosition),
-            zone());
+  body->push_back(factory()->NewReturnStatement(
+      ThisExpression(kNoSourcePosition), kNoSourcePosition));
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       ast_value_factory()->empty_string(), initializer_scope, body,
       initializer_state.materialized_literal_count(),
       initializer_state.expected_property_count(), 0, count,
       FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::kAnonymousExpression,
       FunctionLiteral::kShouldLazyCompile, initializer_scope->start_position());
   function_literal->set_is_class_field_initializer(true);
   return function_literal;
 }
 
 FunctionLiteral* Parser::InsertClassFieldInitializer(
     FunctionLiteral* constructor) {
   Statement* call_initializer = factory()->NewExpressionStatement(
       CallClassFieldInitializer(
           constructor->scope(),
           constructor->scope()->NewUnresolved(
               factory(), ast_value_factory()->this_string(), kNoSourcePosition,
               THIS_VARIABLE)),
       kNoSourcePosition);
-  constructor->body()->InsertAt(0, call_initializer, zone());
+  constructor->body()->push_front(call_initializer);
   return constructor;
 }
 
 // If a class name is specified, this method declares the class variable
 // and sets class_info->proxy to point to that name.
 void Parser::DeclareClassVariable(const AstRawString* name, Scope* block_scope,
                                   ClassInfo* class_info, int class_token_pos,
                                   bool* ok) {
 #ifdef DEBUG
   scope()->SetScopeName(name);
@@ skipping 78 matching lines @@
 //   - constructor (if missing, it updates it with a default constructor)
 //   - proxy
 //   - extends
 //   - static_initializer_var
 //   - instance_field_initializers
 //   - properties
 Expression* Parser::RewriteClassLiteral(const AstRawString* name,
                                         ClassInfo* class_info, int pos,
                                         bool* ok) {
   int end_pos = scanner()->location().end_pos;
-  Block* do_block = factory()->NewBlock(nullptr, 1, false, pos);
+  Block* do_block = factory()->NewBlock(nullptr, false, pos);
   Variable* result_var = NewTemporary(ast_value_factory()->empty_string());
   DoExpression* do_expr = factory()->NewDoExpression(do_block, result_var, pos);
 
   bool has_extends = class_info->extends != nullptr;
   bool has_instance_fields =
       class_info->instance_field_initializers->length() > 0;
   DCHECK(!has_instance_fields || allow_harmony_class_fields());
   bool has_default_constructor = class_info->constructor == nullptr;
   if (has_default_constructor) {
     class_info->constructor =
@@ skipping 16 matching lines @@
 
   ClassLiteral* class_literal = factory()->NewClassLiteral(
       class_info->proxy, class_info->extends, class_info->constructor,
       class_info->properties, pos, end_pos);
 
   if (class_info->static_initializer_var != nullptr) {
     class_literal->set_static_initializer_proxy(
         factory()->NewVariableProxy(class_info->static_initializer_var));
   }
 
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(
-          factory()->NewAssignment(Token::ASSIGN,
-                                   factory()->NewVariableProxy(result_var),
-                                   class_literal, kNoSourcePosition),
-          pos),
-      zone());
+  do_block->statements()->push_back(factory()->NewExpressionStatement(
+      factory()->NewAssignment(Token::ASSIGN,
+                               factory()->NewVariableProxy(result_var),
+                               class_literal, kNoSourcePosition),
+      pos));
   if (allow_harmony_class_fields() &&
       (has_instance_fields || (has_extends && !has_default_constructor))) {
     // Default constructors for derived classes without fields will not try to
     // read this variable, so there's no need to create it.
     const AstRawString* init_fn_name =
         ast_value_factory()->dot_class_field_init_string();
     Variable* init_fn_var = scope()->DeclareLocal(
         init_fn_name, CONST, kCreatedInitialized, NORMAL_VARIABLE);
     Expression* initializer =
         has_instance_fields
             ? static_cast<Expression*>(SynthesizeClassFieldInitializer(
                   class_info->instance_field_initializers->length()))
             : factory()->NewBooleanLiteral(false, kNoSourcePosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::INIT, factory()->NewVariableProxy(init_fn_var), initializer,
         kNoSourcePosition);
-    do_block->statements()->Add(
-        factory()->NewExpressionStatement(assignment, kNoSourcePosition),
-        zone());
+    do_block->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, kNoSourcePosition));
   }
   for (int i = 0; i < class_info->instance_field_initializers->length(); ++i) {
     const AstRawString* function_name =
         ClassFieldVariableName(false, ast_value_factory(), i);
     VariableProxy* function_proxy =
         factory()->NewVariableProxy(function_name, NORMAL_VARIABLE);
     Declaration* function_declaration = factory()->NewVariableDeclaration(
         function_proxy, scope(), kNoSourcePosition);
     Variable* function_var =
         Declare(function_declaration, DeclarationDescriptor::NORMAL, CONST,
                 kNeedsInitialization, ok, scope());
     if (!*ok) return nullptr;
     Property* prototype_property = factory()->NewProperty(
         factory()->NewVariableProxy(result_var),
         factory()->NewStringLiteral(ast_value_factory()->prototype_string(),
                                     kNoSourcePosition),
         kNoSourcePosition);
     Expression* function_value = InstallHomeObject(
         class_info->instance_field_initializers->at(i),
         prototype_property);  // TODO(bakkot) ideally this would be conditional,
                               // especially in trivial cases
     Assignment* function_assignment = factory()->NewAssignment(
         Token::INIT, factory()->NewVariableProxy(function_var), function_value,
         kNoSourcePosition);
-    do_block->statements()->Add(factory()->NewExpressionStatement(
-                                    function_assignment, kNoSourcePosition),
-                                zone());
+    do_block->statements()->push_back(factory()->NewExpressionStatement(
+        function_assignment, kNoSourcePosition));
   }
   do_block->set_scope(scope()->FinalizeBlockScope());
   do_expr->set_represented_function(class_info->constructor);
 
   return do_expr;
 }
 
 Literal* Parser::GetLiteralUndefined(int position) {
   return factory()->NewUndefinedLiteral(position);
 }
@@ skipping 31 matching lines @@
     }
     const AstRawString* name = decl->proxy()->raw_name();
     Variable* parameter = function_scope->LookupLocal(name);
     if (parameter == nullptr) continue;
     VariableProxy* to = NewUnresolved(name);
     VariableProxy* from = factory()->NewVariableProxy(parameter);
     Expression* assignment =
         factory()->NewAssignment(Token::ASSIGN, to, from, kNoSourcePosition);
     Statement* statement =
         factory()->NewExpressionStatement(assignment, kNoSourcePosition);
-    inner_block->statements()->InsertAt(0, statement, zone());
+    inner_block->statements()->push_front(statement);
   }
 }
 
 void Parser::InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope) {
   // For the outermost eval scope, we cannot hoist during parsing: let
   // declarations in the surrounding scope may prevent hoisting, but the
   // information is unaccessible during parsing. In this case, we hoist later in
   // DeclarationScope::Analyze.
   if (scope->is_eval_scope() && scope->outer_scope() == original_scope_) {
     return;
@@ skipping 430 matching lines @@
   Expression* expr = args->at(0);
   for (int i = 1; i < args->length(); ++i) {
     expr = factory()->NewBinaryOperation(Token::COMMA, expr, args->at(i),
                                          expr->position());
   }
   return expr;
 }
 
 // This method intoduces the line initializing the generator object
 // when desugaring the body of async_function.
-void Parser::PrepareAsyncFunctionBody(ZoneList<Statement*>* body,
+void Parser::PrepareAsyncFunctionBody(ZoneChunkList<Statement*>* body,
                                       FunctionKind kind, int pos) {
   // function async_function() {
   //   .generator_object = %CreateGeneratorObject();
   //   BuildRejectPromiseOnException({
   //     ... block ...
   //     return %ResolvePromise(.promise, expr), .promise;
   //   })
   // }
 
   Variable* temp =
       NewTemporary(ast_value_factory()->dot_generator_object_string());
   function_state_->set_generator_object_variable(temp);
 
   Expression* init_generator_variable = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(temp),
       BuildCreateJSGeneratorObject(pos, kind), kNoSourcePosition);
-  body->Add(factory()->NewExpressionStatement(init_generator_variable,
-                                              kNoSourcePosition),
-            zone());
+  body->push_back(factory()->NewExpressionStatement(init_generator_variable,
+                                                    kNoSourcePosition));
 }
 
 // This method completes the desugaring of the body of async_function.
-void Parser::RewriteAsyncFunctionBody(ZoneList<Statement*>* body, Block* block,
-                                      Expression* return_value, bool* ok) {
+void Parser::RewriteAsyncFunctionBody(ZoneChunkList<Statement*>* body,
+                                      Block* block, Expression* return_value,
+                                      bool* ok) {
   // function async_function() {
   //   .generator_object = %CreateGeneratorObject();
   //   BuildRejectPromiseOnException({
   //     ... block ...
   //     return %ResolvePromise(.promise, expr), .promise;
   //   })
   // }
 
   return_value = BuildResolvePromise(return_value, return_value->position());
-  block->statements()->Add(
-      factory()->NewReturnStatement(return_value, return_value->position()),
-      zone());
+  block->statements()->push_back(
+      factory()->NewReturnStatement(return_value, return_value->position()));
   block = BuildRejectPromiseOnException(block, CHECK_OK_VOID);
-  body->Add(block, zone());
+  body->push_back(block);
 }
 
 Expression* Parser::RewriteAwaitExpression(Expression* value, int await_pos) {
   // yield do {
   //   tmp = <operand>;
   //   %AsyncFunctionAwait(.generator_object, tmp, .promise);
   //   .promise
   // }
   // The value of the expression is returned to the caller of the async
   // function for the first yield statement; for this, .promise is the
@@ skipping 11 matching lines @@
   // TODO(littledan): investigate why this ordering is needed in more detail.
   Variable* generator_object_variable =
       function_state_->generator_object_variable();
 
   // If generator_object_variable is null,
   // TODO(littledan): Is this necessary?
   if (!generator_object_variable) return value;
 
   const int nopos = kNoSourcePosition;
 
-  Block* do_block = factory()->NewBlock(nullptr, 2, false, nopos);
+  Block* do_block = factory()->NewBlock(nullptr, false, nopos);
 
   Variable* promise = PromiseVariable();
 
   // Wrap value evaluation to provide a break location.
   Variable* temp_var = NewTemporary(ast_value_factory()->empty_string());
   Expression* value_assignment = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(temp_var), value, nopos);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(value_assignment, value->position()),
-      zone());
+  do_block->statements()->push_back(
+      factory()->NewExpressionStatement(value_assignment, value->position()));
 
   ZoneList<Expression*>* async_function_await_args =
       new (zone()) ZoneList<Expression*>(3, zone());
   Expression* generator_object =
       factory()->NewVariableProxy(generator_object_variable);
   async_function_await_args->Add(generator_object, zone());
   async_function_await_args->Add(factory()->NewVariableProxy(temp_var), zone());
   async_function_await_args->Add(factory()->NewVariableProxy(promise), zone());
 
   // The parser emits calls to AsyncFunctionAwaitCaught, but the
   // AstNumberingVisitor will rewrite this to AsyncFunctionAwaitUncaught
   // if there is no local enclosing try/catch block.
   Expression* async_function_await =
       factory()->NewCallRuntime(Context::ASYNC_FUNCTION_AWAIT_CAUGHT_INDEX,
                                 async_function_await_args, nopos);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(async_function_await, await_pos),
-      zone());
+  do_block->statements()->push_back(
+      factory()->NewExpressionStatement(async_function_await, await_pos));
 
   // Wrap await to provide a break location between value evaluation and yield.
   Expression* do_expr = factory()->NewDoExpression(do_block, promise, nopos);
 
   generator_object = factory()->NewVariableProxy(generator_object_variable);
   return factory()->NewYield(generator_object, do_expr, nopos,
                              Yield::kOnExceptionRethrow);
 }
 
 class NonPatternRewriter : public AstExpressionRewriter {
@@ skipping 133 matching lines @@
   //    }
   // where $R, $i and $j are fresh temporary variables.
   ZoneList<Expression*>::iterator s = lit->FirstSpread();
   if (s == lit->EndValue()) return nullptr;  // no spread, no rewriting...
   Variable* result = NewTemporary(ast_value_factory()->dot_result_string());
   // NOTE: The value assigned to R is the whole original array literal,
   // spreads included. This will be fixed before the rewritten AST is returned.
   // $R = lit
   Expression* init_result = factory()->NewAssignment(
       Token::INIT, factory()->NewVariableProxy(result), lit, kNoSourcePosition);
-  Block* do_block = factory()->NewBlock(nullptr, 16, false, kNoSourcePosition);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(init_result, kNoSourcePosition),
-      zone());
+  Block* do_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
+  do_block->statements()->push_back(
+      factory()->NewExpressionStatement(init_result, kNoSourcePosition));
   // Traverse the array literal starting from the first spread.
   while (s != lit->EndValue()) {
     Expression* value = *s++;
     Spread* spread = value->AsSpread();
     if (spread == nullptr) {
       // If the element is not a spread, we're adding a single:
       // %AppendElement($R, value)
       // or, in case of a hole,
       // ++($R.length)
       if (!value->IsLiteral() ||
           !value->AsLiteral()->raw_value()->IsTheHole()) {
         ZoneList<Expression*>* append_element_args = NewExpressionList(2);
         append_element_args->Add(factory()->NewVariableProxy(result), zone());
         append_element_args->Add(value, zone());
-        do_block->statements()->Add(
-            factory()->NewExpressionStatement(
-                factory()->NewCallRuntime(Runtime::kAppendElement,
-                                          append_element_args,
-                                          kNoSourcePosition),
-                kNoSourcePosition),
-            zone());
+        do_block->statements()->push_back(factory()->NewExpressionStatement(
+            factory()->NewCallRuntime(Runtime::kAppendElement,
+                                      append_element_args, kNoSourcePosition),
+            kNoSourcePosition));
       } else {
         Property* length_property = factory()->NewProperty(
             factory()->NewVariableProxy(result),
             factory()->NewStringLiteral(ast_value_factory()->length_string(),
                                         kNoSourcePosition),
             kNoSourcePosition);
         CountOperation* count_op = factory()->NewCountOperation(
             Token::INC, true /* prefix */, length_property, kNoSourcePosition);
-        do_block->statements()->Add(
-            factory()->NewExpressionStatement(count_op, kNoSourcePosition),
-            zone());
+        do_block->statements()->push_back(
+            factory()->NewExpressionStatement(count_op, kNoSourcePosition));
       }
     } else {
       // If it's a spread, we're adding a for/of loop iterating through it.
       Variable* each = NewTemporary(ast_value_factory()->dot_for_string());
       Expression* subject = spread->expression();
       // %AppendElement($R, each)
       Statement* append_body;
       {
         ZoneList<Expression*>* append_element_args = NewExpressionList(2);
         append_element_args->Add(factory()->NewVariableProxy(result), zone());
         append_element_args->Add(factory()->NewVariableProxy(each), zone());
         append_body = factory()->NewExpressionStatement(
             factory()->NewCallRuntime(Runtime::kAppendElement,
                                       append_element_args, kNoSourcePosition),
             kNoSourcePosition);
       }
       // for (each of spread) %AppendElement($R, each)
       ForEachStatement* loop = factory()->NewForEachStatement(
           ForEachStatement::ITERATE, nullptr, kNoSourcePosition);
       const bool finalize = false;
       InitializeForOfStatement(loop->AsForOfStatement(),
                                factory()->NewVariableProxy(each), subject,
                                append_body, finalize);
-      do_block->statements()->Add(loop, zone());
+      do_block->statements()->push_back(loop);
     }
   }
   // Now, rewind the original array literal to truncate everything from the
   // first spread (included) until the end. This fixes $R's initialization.
   lit->RewindSpreads();
   return factory()->NewDoExpression(do_block, result, lit->position());
 }
 
 void Parser::QueueDestructuringAssignmentForRewriting(Expression* expr) {
   DCHECK(expr->IsRewritableExpression());
@@ skipping 274 matching lines @@
   Statement* check_throw;
   {
     Expression* condition = factory()->NewCompareOperation(
         Token::EQ, factory()->NewVariableProxy(var_throw),
         factory()->NewNullLiteral(nopos), nopos);
     Expression* call =
         NewThrowTypeError(MessageTemplate::kThrowMethodMissing,
                           ast_value_factory()->empty_string(), nopos);
     Statement* throw_call = factory()->NewExpressionStatement(call, nopos);
 
-    Block* then = factory()->NewBlock(nullptr, 4 + 1, false, nopos);
+    Block* then = factory()->NewBlock(nullptr, false, nopos);
     BuildIteratorCloseForCompletion(
         then->statements(), var_iterator,
         factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos));
-    then->statements()->Add(throw_call, zone());
+    then->statements()->push_back(throw_call);
     check_throw = factory()->NewIfStatement(
         condition, then, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // output = %_Call(iteratorThrow, iterator, input);
   Statement* call_throw;
   {
     auto args = new (zone()) ZoneList<Expression*>(3, zone());
     args->Add(factory()->NewVariableProxy(var_throw), zone());
     args->Add(factory()->NewVariableProxy(var_iterator), zone());
@@ skipping 125 matching lines @@
         factory()->NewStringLiteral(ast_value_factory()->value_string(), nopos);
     Expression* property = factory()->NewProperty(output_proxy, literal, nopos);
     get_value = factory()->NewExpressionStatement(property, nopos);
   }
 
   // Now put things together.
 
   // try { ... } catch(e) { ... }
   Statement* try_catch;
   {
-    Block* try_block = factory()->NewBlock(nullptr, 2, false, nopos);
-    try_block->statements()->Add(yield_output, zone());
-    try_block->statements()->Add(set_mode_next, zone());
+    Block* try_block = factory()->NewBlock(nullptr, false, nopos);
+    try_block->statements()->push_back(yield_output);
+    try_block->statements()->push_back(set_mode_next);
 
-    Block* catch_block = factory()->NewBlock(nullptr, 1, false, nopos);
-    catch_block->statements()->Add(set_mode_throw, zone());
+    Block* catch_block = factory()->NewBlock(nullptr, false, nopos);
+    catch_block->statements()->push_back(set_mode_throw);
 
     Scope* catch_scope = NewScope(CATCH_SCOPE);
     catch_scope->set_is_hidden();
     const AstRawString* name = ast_value_factory()->dot_catch_string();
     Variable* catch_variable = catch_scope->DeclareLocal(
         name, VAR, kCreatedInitialized, NORMAL_VARIABLE);
 
     try_catch = factory()->NewTryCatchStatementForDesugaring(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // try { ... } finally { ... }
   Statement* try_finally;
   {
-    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(try_catch, zone());
+    Block* try_block = factory()->NewBlock(nullptr, false, nopos);
+    try_block->statements()->push_back(try_catch);
 
-    Block* finally = factory()->NewBlock(nullptr, 2, false, nopos);
-    finally->statements()->Add(get_input, zone());
-    finally->statements()->Add(factory()->NewContinueStatement(loop, nopos),
-                               zone());
+    Block* finally = factory()->NewBlock(nullptr, false, nopos);
+    finally->statements()->push_back(get_input);
+    finally->statements()->push_back(
+        factory()->NewContinueStatement(loop, nopos));
 
     try_finally = factory()->NewTryFinallyStatement(try_block, finally, nopos);
   }
 
   // switch (mode) { ... }
   SwitchStatement* switch_mode = factory()->NewSwitchStatement(nullptr, nopos);
   {
-    auto case_next = new (zone()) ZoneList<Statement*>(3, zone());
-    case_next->Add(call_next, zone());
-    case_next->Add(validate_next_output, zone());
-    case_next->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+    auto case_next = new (zone()) ZoneChunkList<Statement*>(zone());
+    case_next->push_back(call_next);
+    case_next->push_back(validate_next_output);
+    case_next->push_back(factory()->NewBreakStatement(switch_mode, nopos));
 
-    auto case_return = new (zone()) ZoneList<Statement*>(5, zone());
+    auto case_return = new (zone()) ZoneChunkList<Statement*>(zone());
     BuildIteratorClose(case_return, var_iterator, var_input, var_output);
-    case_return->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+    case_return->push_back(factory()->NewBreakStatement(switch_mode, nopos));
 
-    auto case_throw = new (zone()) ZoneList<Statement*>(5, zone());
-    case_throw->Add(get_throw, zone());
-    case_throw->Add(check_throw, zone());
-    case_throw->Add(call_throw, zone());
-    case_throw->Add(validate_throw_output, zone());
-    case_throw->Add(factory()->NewBreakStatement(switch_mode, nopos), zone());
+    auto case_throw = new (zone()) ZoneChunkList<Statement*>(zone());
+    case_throw->push_back(get_throw);
+    case_throw->push_back(check_throw);
+    case_throw->push_back(call_throw);
+    case_throw->push_back(validate_throw_output);
+    case_throw->push_back(factory()->NewBreakStatement(switch_mode, nopos));
 
     auto cases = new (zone()) ZoneList<CaseClause*>(3, zone());
     Expression* knext =
         factory()->NewSmiLiteral(JSGeneratorObject::kNext, nopos);
     Expression* kreturn =
         factory()->NewSmiLiteral(JSGeneratorObject::kReturn, nopos);
     Expression* kthrow =
         factory()->NewSmiLiteral(JSGeneratorObject::kThrow, nopos);
     cases->Add(factory()->NewCaseClause(knext, case_next, nopos), zone());
     cases->Add(factory()->NewCaseClause(kreturn, case_return, nopos), zone());
     cases->Add(factory()->NewCaseClause(kthrow, case_throw, nopos), zone());
 
     switch_mode->Initialize(factory()->NewVariableProxy(var_mode), cases);
   }
 
   // while (true) { ... }
   // Already defined earlier: WhileStatement* loop = ...
   {
-    Block* loop_body = factory()->NewBlock(nullptr, 4, false, nopos);
-    loop_body->statements()->Add(switch_mode, zone());
-    loop_body->statements()->Add(if_done, zone());
-    loop_body->statements()->Add(set_mode_return, zone());
-    loop_body->statements()->Add(try_finally, zone());
+    Block* loop_body = factory()->NewBlock(nullptr, false, nopos);
+    loop_body->statements()->push_back(switch_mode);
+    loop_body->statements()->push_back(if_done);
+    loop_body->statements()->push_back(set_mode_return);
+    loop_body->statements()->push_back(try_finally);
 
     loop->Initialize(factory()->NewBooleanLiteral(true, nopos), loop_body);
   }
 
   // do { ... }
   DoExpression* yield_star;
   {
     // The rewriter needs to process the get_value statement only, hence we
     // put the preceding statements into an init block.
 
-    Block* do_block_ = factory()->NewBlock(nullptr, 7, true, nopos);
-    do_block_->statements()->Add(initialize_input, zone());
-    do_block_->statements()->Add(initialize_mode, zone());
-    do_block_->statements()->Add(initialize_output, zone());
-    do_block_->statements()->Add(get_iterator, zone());
-    do_block_->statements()->Add(validate_iterator, zone());
-    do_block_->statements()->Add(loop, zone());
-    do_block_->statements()->Add(maybe_return_value, zone());
+    Block* do_block_ = factory()->NewBlock(nullptr, true, nopos);
+    do_block_->statements()->push_back(initialize_input);
+    do_block_->statements()->push_back(initialize_mode);
+    do_block_->statements()->push_back(initialize_output);
+    do_block_->statements()->push_back(get_iterator);
+    do_block_->statements()->push_back(validate_iterator);
+    do_block_->statements()->push_back(loop);
+    do_block_->statements()->push_back(maybe_return_value);
 
-    Block* do_block = factory()->NewBlock(nullptr, 2, false, nopos);
-    do_block->statements()->Add(do_block_, zone());
-    do_block->statements()->Add(get_value, zone());
+    Block* do_block = factory()->NewBlock(nullptr, false, nopos);
+    do_block->statements()->push_back(do_block_);
+    do_block->statements()->push_back(get_value);
 
     Variable* dot_result =
         NewTemporary(ast_value_factory()->dot_result_string());
     yield_star = factory()->NewDoExpression(do_block, dot_result, nopos);
     Rewriter::Rewrite(this, GetClosureScope(), yield_star, ast_value_factory());
   }
 
   return yield_star;
 }
 
 Statement* Parser::CheckCallable(Variable* var, Expression* error, int pos) {
   const int nopos = kNoSourcePosition;
   Statement* validate_var;
   {
     Expression* type_of = factory()->NewUnaryOperation(
         Token::TYPEOF, factory()->NewVariableProxy(var), nopos);
     Expression* function_literal = factory()->NewStringLiteral(
         ast_value_factory()->function_string(), nopos);
     Expression* condition = factory()->NewCompareOperation(
         Token::EQ_STRICT, type_of, function_literal, nopos);
 
     Statement* throw_call = factory()->NewExpressionStatement(error, pos);
 
     validate_var = factory()->NewIfStatement(
         condition, factory()->NewEmptyStatement(nopos), throw_call, nopos);
   }
   return validate_var;
 }
 
-void Parser::BuildIteratorClose(ZoneList<Statement*>* statements,
+void Parser::BuildIteratorClose(ZoneChunkList<Statement*>* statements,
                                 Variable* iterator, Variable* input,
                                 Variable* var_output) {
   //
   // This function adds four statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (IS_NULL_OR_UNDEFINED(iteratorReturn) {
   //     return {value: input, done: true};
   //   }
@@ skipping 70 matching lines @@
       Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory()->NewExpressionStatement(call, nopos);
     }
 
     validate_output = factory()->NewIfStatement(
         is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
         nopos);
   }
 
-  statements->Add(get_return, zone());
-  statements->Add(check_return, zone());
-  statements->Add(call_return, zone());
-  statements->Add(validate_output, zone());
+  statements->push_back(get_return);
+  statements->push_back(check_return);
+  statements->push_back(call_return);
+  statements->push_back(validate_output);
 }
 
 void Parser::FinalizeIteratorUse(Variable* completion, Expression* condition,
                                  Variable* iter, Block* iterator_use,
                                  Block* target) {
   //
   // This function adds two statements to [target], corresponding to the
   // following code:
   //
   //   completion = kNormalCompletion;
@@ skipping 38 matching lines @@
     Statement* statement = factory()->NewExpressionStatement(assignment, nopos);
     set_completion_throw = factory()->NewIfStatement(
         condition, statement, factory()->NewEmptyStatement(nopos), nopos);
   }
 
   // if (condition) {
   //   #BuildIteratorCloseForCompletion(iter, completion)
   // }
   Block* maybe_close;
   {
-    Block* block = factory()->NewBlock(nullptr, 2, true, nopos);
+    Block* block = factory()->NewBlock(nullptr, true, nopos);
     Expression* proxy = factory()->NewVariableProxy(completion);
     BuildIteratorCloseForCompletion(block->statements(), iter, proxy);
-    DCHECK(block->statements()->length() == 2);
+    DCHECK(block->statements()->size() == 2);
 
-    maybe_close = factory()->NewBlock(nullptr, 1, true, nopos);
-    maybe_close->statements()->Add(
-        factory()->NewIfStatement(condition, block,
-                                  factory()->NewEmptyStatement(nopos), nopos),
-        zone());
+    maybe_close = factory()->NewBlock(nullptr, true, nopos);
+    maybe_close->statements()->push_back(factory()->NewIfStatement(
+        condition, block, factory()->NewEmptyStatement(nopos), nopos));
   }
 
   // try { #try_block }
   // catch(e) {
   //   #set_completion_throw;
   //   %ReThrow(e);
   // }
   Statement* try_catch;
   {
     Scope* catch_scope = NewScopeWithParent(scope(), CATCH_SCOPE);
     Variable* catch_variable =
         catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                   kCreatedInitialized, NORMAL_VARIABLE);
     catch_scope->set_is_hidden();
 
     Statement* rethrow;
     // We use %ReThrow rather than the ordinary throw because we want to
     // preserve the original exception message.  This is also why we create a
     // TryCatchStatementForReThrow below (which does not clear the pending
     // message), rather than a TryCatchStatement.
     {
       auto args = new (zone()) ZoneList<Expression*>(1, zone());
       args->Add(factory()->NewVariableProxy(catch_variable), zone());
       rethrow = factory()->NewExpressionStatement(
           factory()->NewCallRuntime(Runtime::kReThrow, args, nopos), nopos);
     }
 
-    Block* catch_block = factory()->NewBlock(nullptr, 2, false, nopos);
-    catch_block->statements()->Add(set_completion_throw, zone());
-    catch_block->statements()->Add(rethrow, zone());
+    Block* catch_block = factory()->NewBlock(nullptr, false, nopos);
+    catch_block->statements()->push_back(set_completion_throw);
+    catch_block->statements()->push_back(rethrow);
 
     try_catch = factory()->NewTryCatchStatementForReThrow(
         iterator_use, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // try { #try_catch } finally { #maybe_close }
   Statement* try_finally;
   {
-    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(try_catch, zone());
+    Block* try_block = factory()->NewBlock(nullptr, false, nopos);
+    try_block->statements()->push_back(try_catch);
 
     try_finally =
         factory()->NewTryFinallyStatement(try_block, maybe_close, nopos);
   }
 
-  target->statements()->Add(initialize_completion, zone());
-  target->statements()->Add(try_finally, zone());
+  target->statements()->push_back(initialize_completion);
+  target->statements()->push_back(try_finally);
 }
 
-void Parser::BuildIteratorCloseForCompletion(ZoneList<Statement*>* statements,
-                                             Variable* iterator,
-                                             Expression* completion) {
+void Parser::BuildIteratorCloseForCompletion(
+    ZoneChunkList<Statement*>* statements, Variable* iterator,
+    Expression* completion) {
   //
   // This function adds two statements to [statements], corresponding to the
   // following code:
   //
   //   let iteratorReturn = iterator.return;
   //   if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) {
   //     if (completion === kThrowCompletion) {
   //       if (!IS_CALLABLE(iteratorReturn)) {
   //         throw MakeTypeError(kReturnMethodNotCallable);
   //       }
@@ skipping 37 matching lines @@
   // try { %_Call(iteratorReturn, iterator) } catch (_) { }
   Statement* try_call_return;
   {
     auto args = new (zone()) ZoneList<Expression*>(2, zone());
     args->Add(factory()->NewVariableProxy(var_return), zone());
     args->Add(factory()->NewVariableProxy(iterator), zone());
 
     Expression* call =
         factory()->NewCallRuntime(Runtime::kInlineCall, args, nopos);
 
-    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(factory()->NewExpressionStatement(call, nopos),
-                                 zone());
+    Block* try_block = factory()->NewBlock(nullptr, false, nopos);
+    try_block->statements()->push_back(
+        factory()->NewExpressionStatement(call, nopos));
 
-    Block* catch_block = factory()->NewBlock(nullptr, 0, false, nopos);
+    Block* catch_block = factory()->NewBlock(nullptr, false, nopos);
 
     Scope* catch_scope = NewScope(CATCH_SCOPE);
     Variable* catch_variable =
         catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                   kCreatedInitialized, NORMAL_VARIABLE);
     catch_scope->set_is_hidden();
 
     try_call_return = factory()->NewTryCatchStatement(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
@@ skipping 33 matching lines @@
       args->Add(factory()->NewVariableProxy(var_output), zone());
       Expression* call = factory()->NewCallRuntime(
           Runtime::kThrowIteratorResultNotAnObject, args, nopos);
       throw_call = factory()->NewExpressionStatement(call, nopos);
     }
 
     Statement* check_return = factory()->NewIfStatement(
         is_receiver_call, factory()->NewEmptyStatement(nopos), throw_call,
         nopos);
 
-    validate_return = factory()->NewBlock(nullptr, 2, false, nopos);
-    validate_return->statements()->Add(call_return, zone());
-    validate_return->statements()->Add(check_return, zone());
+    validate_return = factory()->NewBlock(nullptr, false, nopos);
+    validate_return->statements()->push_back(call_return);
+    validate_return->statements()->push_back(check_return);
   }
 
   // if (completion === kThrowCompletion) {
   //   #check_return_callable;
   //   #try_call_return;
   // } else {
   //   #validate_return;
   // }
   Statement* call_return_carefully;
   {
     Expression* condition = factory()->NewCompareOperation(
         Token::EQ_STRICT, completion,
         factory()->NewSmiLiteral(Parser::kThrowCompletion, nopos), nopos);
 
-    Block* then_block = factory()->NewBlock(nullptr, 2, false, nopos);
-    then_block->statements()->Add(check_return_callable, zone());
-    then_block->statements()->Add(try_call_return, zone());
+    Block* then_block = factory()->NewBlock(nullptr, false, nopos);
+    then_block->statements()->push_back(check_return_callable);
+    then_block->statements()->push_back(try_call_return);
 
     call_return_carefully = factory()->NewIfStatement(condition, then_block,
                                                       validate_return, nopos);
   }
 
   // if (!IS_NULL_OR_UNDEFINED(iteratorReturn)) { ... }
   Statement* maybe_call_return;
   {
     Expression* condition = factory()->NewCompareOperation(
         Token::EQ, factory()->NewVariableProxy(var_return),
         factory()->NewNullLiteral(nopos), nopos);
 
     maybe_call_return = factory()->NewIfStatement(
         condition, factory()->NewEmptyStatement(nopos), call_return_carefully,
         nopos);
   }
 
-  statements->Add(get_return, zone());
-  statements->Add(maybe_call_return, zone());
+  statements->push_back(get_return);
+  statements->push_back(maybe_call_return);
 }
 
 Statement* Parser::FinalizeForOfStatement(ForOfStatement* loop,
                                           Variable* var_completion, int pos) {
   //
   // This function replaces the loop with the following wrapping:
   //
   //   completion = kNormalCompletion;
   //   try {
   //     try {
@@ skipping 21 matching lines @@
         Token::EQ_STRICT, factory()->NewVariableProxy(var_completion),
         factory()->NewSmiLiteral(Parser::kNormalCompletion, nopos), nopos);
     Expression* rhs = factory()->NewCompareOperation(
         Token::EQ_STRICT, factory()->NewVariableProxy(loop->iterator()),
         factory()->NewUndefinedLiteral(nopos), nopos);
     closing_condition = factory()->NewUnaryOperation(
         Token::NOT, factory()->NewBinaryOperation(Token::OR, lhs, rhs, nopos),
         nopos);
   }
 
-  Block* final_loop = factory()->NewBlock(nullptr, 2, false, nopos);
+  Block* final_loop = factory()->NewBlock(nullptr, false, nopos);
   {
-    Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
-    try_block->statements()->Add(loop, zone());
+    Block* try_block = factory()->NewBlock(nullptr, false, nopos);
+    try_block->statements()->push_back(loop);
 
     FinalizeIteratorUse(var_completion, closing_condition, loop->iterator(),
                         try_block, final_loop);
   }
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8