Changed statement ZoneList to a ZoneChunkList

src/parsing/pattern-rewriter.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ast/ast.h"
 #include "src/messages.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
@@ skipping 96 matching lines @@
 }
 
 
 void Parser::PatternRewriter::VisitVariableProxy(VariableProxy* pattern) {
   Expression* value = current_value_;
 
   if (IsAssignmentContext()) {
     // In an assignment context, simply perform the assignment
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, pattern, value, pattern->position());
-    block_->statements()->Add(
-        factory()->NewExpressionStatement(assignment, pattern->position()),
-        zone());
+    block_->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, pattern->position()));
     return;
   }
 
   descriptor_->scope->RemoveUnresolved(pattern);
 
   // Declare variable.
   // Note that we *always* must treat the initial value via a separate init
   // assignment for variables and constants because the value must be assigned
   // when the variable is encountered in the source. But the variable/constant
   // is declared (and set to 'undefined') upon entering the function within
@@ skipping 72 matching lines @@
     arguments->Add(
         factory()->NewStringLiteral(name, descriptor_->declaration_pos),
         zone());
     arguments->Add(factory()->NewNumberLiteral(var_init_scope->language_mode(),
                                                kNoSourcePosition),
                    zone());
     arguments->Add(value, zone());
 
     CallRuntime* initialize = factory()->NewCallRuntime(
         Runtime::kInitializeVarGlobal, arguments, value->position());
-    block_->statements()->Add(
-        factory()->NewExpressionStatement(initialize, initialize->position()),
-        zone());
+    block_->statements()->push_back(
+        factory()->NewExpressionStatement(initialize, initialize->position()));
   } else {
     // For 'let' and 'const' declared variables the initialization always
     // assigns to the declared variable.
     // But for var declarations we need to do a new lookup.
     if (descriptor_->mode == VAR) {
       proxy = var_init_scope->NewUnresolved(factory(), name);
     } else {
       DCHECK_NOT_NULL(proxy);
       DCHECK_NOT_NULL(proxy->var());
     }
     // Add break location for destructured sub-pattern.
     int pos = IsSubPattern() ? pattern->position() : value->position();
     Assignment* assignment =
         factory()->NewAssignment(Token::INIT, proxy, value, pos);
-    block_->statements()->Add(
-        factory()->NewExpressionStatement(assignment, pos), zone());
+    block_->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, pos));
   }
 }
 
 
 Variable* Parser::PatternRewriter::CreateTempVar(Expression* value) {
   auto temp = scope()->NewTemporary(ast_value_factory()->empty_string());
   if (value != nullptr) {
     auto assignment = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(temp), value,
         kNoSourcePosition);
 
-    block_->statements()->Add(
-        factory()->NewExpressionStatement(assignment, kNoSourcePosition),
-        zone());
+    block_->statements()->push_back(
+        factory()->NewExpressionStatement(assignment, kNoSourcePosition));
   }
   return temp;
 }
 
 
 void Parser::PatternRewriter::VisitRewritableExpression(
     RewritableExpression* node) {
   // If this is not a destructuring assignment...
   if (!IsAssignmentContext()) {
     // Mark the node as rewritten to prevent redundant rewriting, and
@@ skipping 24 matching lines @@
         Token::EQ_STRICT, factory()->NewVariableProxy(temp_var),
         factory()->NewUndefinedLiteral(kNoSourcePosition), kNoSourcePosition);
     value = factory()->NewConditional(is_undefined, initializer,
                                       factory()->NewVariableProxy(temp_var),
                                       kNoSourcePosition);
   }
 
   PatternContext old_context = SetAssignmentContextIfNeeded(initializer);
   int pos = assign->position();
   Block* old_block = block_;
-  block_ = factory()->NewBlock(nullptr, 8, true, pos);
+  block_ = factory()->NewBlock(nullptr, true, pos);
   Variable* temp = nullptr;
   Expression* pattern = assign->target();
   Expression* old_value = current_value_;
   current_value_ = value;
   if (pattern->IsObjectLiteral()) {
     VisitObjectLiteral(pattern->AsObjectLiteral(), &temp);
   } else {
     DCHECK(pattern->IsArrayLiteral());
     VisitArrayLiteral(pattern->AsArrayLiteral(), &temp);
   }
   DCHECK_NOT_NULL(temp);
   current_value_ = old_value;
   Expression* expr = factory()->NewDoExpression(block_, temp, pos);
   node->Rewrite(expr);
   block_ = old_block;
   if (block_) {
-    block_->statements()->Add(factory()->NewExpressionStatement(expr, pos),
-                              zone());
+    block_->statements()->push_back(
+        factory()->NewExpressionStatement(expr, pos));
   }
   return set_context(old_context);
 }
 
 // When an extra declaration scope needs to be inserted to account for
 // a sloppy eval in a default parameter or function body, the expressions
 // needs to be in that new inner scope which was added after initial
 // parsing.
 void Parser::PatternRewriter::RewriteParameterScopes(Expression* expr) {
   if (!IsBindingContext()) return;
   if (descriptor_->declaration_kind != DeclarationDescriptor::PARAMETER) return;
   if (!scope()->is_block_scope()) return;
 
   DCHECK(scope()->is_declaration_scope());
   DCHECK(scope()->outer_scope()->is_function_scope());
   DCHECK(scope()->calls_sloppy_eval());
 
   ReparentParameterExpressionScope(parser_->stack_limit(), expr, scope());
 }
 
 void Parser::PatternRewriter::VisitObjectLiteral(ObjectLiteral* pattern,
                                                  Variable** temp_var) {
   auto temp = *temp_var = CreateTempVar(current_value_);
 
-  block_->statements()->Add(parser_->BuildAssertIsCoercible(temp), zone());
+  block_->statements()->push_back(parser_->BuildAssertIsCoercible(temp));
 
   for (ObjectLiteralProperty* property : *pattern->properties()) {
     PatternContext context = SetInitializerContextIfNeeded(property->value());
 
     // Computed property names contain expressions which might require
     // scope rewriting.
     if (!property->key()->IsLiteral()) RewriteParameterScopes(property->key());
 
     RecurseIntoSubpattern(
         property->value(),
@@ skipping 23 matching lines @@
   auto v = CreateTempVar();
   auto completion = CreateTempVar();
   auto nopos = kNoSourcePosition;
 
   // For the purpose of iterator finalization, we temporarily set block_ to a
   // new block.  In the main body of this function, we write to block_ (both
   // explicitly and implicitly via recursion).  At the end of the function, we
   // wrap this new block in a try-finally statement, restore block_ to its
   // original value, and add the try-finally statement to block_.
   auto target = block_;
-  block_ = factory()->NewBlock(nullptr, 8, true, nopos);
+  block_ = factory()->NewBlock(nullptr, true, nopos);
 
   Spread* spread = nullptr;
   for (Expression* value : *node->values()) {
     if (value->IsSpread()) {
       spread = value->AsSpread();
       break;
     }
 
     PatternContext context = SetInitializerContextIfNeeded(value);
 
@@ skipping 26 matching lines @@
               factory()->NewStringLiteral(ast_value_factory()->value_string(),
                                           kNoSourcePosition),
               kNoSourcePosition),
           kNoSourcePosition);
 
       auto unset_done = factory()->NewAssignment(
           Token::ASSIGN, factory()->NewVariableProxy(done),
           factory()->NewBooleanLiteral(false, kNoSourcePosition),
           kNoSourcePosition);
 
-      auto inner_else =
-          factory()->NewBlock(nullptr, 2, true, kNoSourcePosition);
-      inner_else->statements()->Add(
-          factory()->NewExpressionStatement(assign_value, nopos), zone());
-      inner_else->statements()->Add(
-          factory()->NewExpressionStatement(unset_done, nopos), zone());
+      auto inner_else = factory()->NewBlock(nullptr, true, kNoSourcePosition);
+      inner_else->statements()->push_back(
+          factory()->NewExpressionStatement(assign_value, nopos));
+      inner_else->statements()->push_back(
+          factory()->NewExpressionStatement(unset_done, nopos));
 
       auto inner_if = factory()->NewIfStatement(
           result_done,
           factory()->NewExpressionStatement(assign_undefined, nopos),
           inner_else, nopos);
 
-      auto next_block =
-          factory()->NewBlock(nullptr, 3, true, kNoSourcePosition);
-      next_block->statements()->Add(
-          factory()->NewExpressionStatement(
-              factory()->NewAssignment(
-                  Token::ASSIGN, factory()->NewVariableProxy(done),
-                  factory()->NewBooleanLiteral(true, nopos), nopos),
-              nopos),
-          zone());
-      next_block->statements()->Add(
-          factory()->NewExpressionStatement(
-              parser_->BuildIteratorNextResult(
-                  factory()->NewVariableProxy(iterator), result,
-                  kNoSourcePosition),
-              kNoSourcePosition),
-          zone());
-      next_block->statements()->Add(inner_if, zone());
+      auto next_block = factory()->NewBlock(nullptr, true, kNoSourcePosition);
+      next_block->statements()->push_back(factory()->NewExpressionStatement(
+          factory()->NewAssignment(
+              Token::ASSIGN, factory()->NewVariableProxy(done),
+              factory()->NewBooleanLiteral(true, nopos), nopos),
+          nopos));
+      next_block->statements()->push_back(factory()->NewExpressionStatement(
+          parser_->BuildIteratorNextResult(
+              factory()->NewVariableProxy(iterator), result, kNoSourcePosition),
+          kNoSourcePosition));
+      next_block->statements()->push_back(inner_if);
 
       if_not_done = factory()->NewIfStatement(
           factory()->NewUnaryOperation(
               Token::NOT, factory()->NewVariableProxy(done), kNoSourcePosition),
           next_block, factory()->NewEmptyStatement(kNoSourcePosition),
           kNoSourcePosition);
     }
-    block_->statements()->Add(if_not_done, zone());
+    block_->statements()->push_back(if_not_done);
 
     if (!(value->IsLiteral() && value->AsLiteral()->raw_value()->IsTheHole())) {
       {
         // completion = kAbruptCompletion;
         Expression* proxy = factory()->NewVariableProxy(completion);
         Expression* assignment = factory()->NewAssignment(
             Token::ASSIGN, proxy,
             factory()->NewSmiLiteral(kAbruptCompletion, nopos), nopos);
-        block_->statements()->Add(
-            factory()->NewExpressionStatement(assignment, nopos), zone());
+        block_->statements()->push_back(
+            factory()->NewExpressionStatement(assignment, nopos));
       }
 
       RecurseIntoSubpattern(value, factory()->NewVariableProxy(v));
 
       {
         // completion = kNormalCompletion;
         Expression* proxy = factory()->NewVariableProxy(completion);
         Expression* assignment = factory()->NewAssignment(
             Token::ASSIGN, proxy,
             factory()->NewSmiLiteral(kNormalCompletion, nopos), nopos);
-        block_->statements()->Add(
-            factory()->NewExpressionStatement(assignment, nopos), zone());
+        block_->statements()->push_back(
+            factory()->NewExpressionStatement(assignment, nopos));
       }
     }
     set_context(context);
   }
 
   if (spread != nullptr) {
     // A spread can only occur as the last component.  It is not handled by
     // RecurseIntoSubpattern above.
 
     // let array = [];
@@ skipping 55 matching lines @@
 
     // if (!result.done) { #append_element; #unset_done }
     Statement* maybe_append_and_unset_done;
     {
       Expression* result_done =
           factory()->NewProperty(factory()->NewVariableProxy(result),
                                  factory()->NewStringLiteral(
                                      ast_value_factory()->done_string(), nopos),
                                  nopos);
 
-      Block* then = factory()->NewBlock(nullptr, 2, true, nopos);
-      then->statements()->Add(append_element, zone());
-      then->statements()->Add(unset_done, zone());
+      Block* then = factory()->NewBlock(nullptr, true, nopos);
+      then->statements()->push_back(append_element);
+      then->statements()->push_back(unset_done);
 
       maybe_append_and_unset_done = factory()->NewIfStatement(
           factory()->NewUnaryOperation(Token::NOT, result_done, nopos), then,
           factory()->NewEmptyStatement(nopos), nopos);
     }
 
     // while (!done) {
     //   #set_done;
     //   #get_next;
     //   #maybe_append_and_unset_done;
     // }
     WhileStatement* loop = factory()->NewWhileStatement(nullptr, nopos);
     {
       Expression* condition = factory()->NewUnaryOperation(
           Token::NOT, factory()->NewVariableProxy(done), nopos);
-      Block* body = factory()->NewBlock(nullptr, 3, true, nopos);
-      body->statements()->Add(set_done, zone());
-      body->statements()->Add(get_next, zone());
-      body->statements()->Add(maybe_append_and_unset_done, zone());
+      Block* body = factory()->NewBlock(nullptr, true, nopos);
+      body->statements()->push_back(set_done);
+      body->statements()->push_back(get_next);
+      body->statements()->push_back(maybe_append_and_unset_done);
       loop->Initialize(condition, body);
     }
 
-    block_->statements()->Add(loop, zone());
+    block_->statements()->push_back(loop);
     RecurseIntoSubpattern(spread->expression(),
                           factory()->NewVariableProxy(array));
   }
 
   Expression* closing_condition = factory()->NewUnaryOperation(
       Token::NOT, factory()->NewVariableProxy(done), nopos);
   parser_->FinalizeIteratorUse(completion, closing_condition, iterator, block_,
                                target);
   block_ = target;
 }
@@ skipping 36 matching lines @@
 
 // =============== AssignmentPattern only ==================
 
 void Parser::PatternRewriter::VisitProperty(v8::internal::Property* node) {
   DCHECK(IsAssignmentContext());
   auto value = current_value_;
 
   Assignment* assignment =
       factory()->NewAssignment(Token::ASSIGN, node, value, node->position());
 
-  block_->statements()->Add(
-      factory()->NewExpressionStatement(assignment, kNoSourcePosition), zone());
+  block_->statements()->push_back(
+      factory()->NewExpressionStatement(assignment, kNoSourcePosition));
 }
 
 
 // =============== UNREACHABLE =============================
 
 #define NOT_A_PATTERN(Node)                                        \
   void Parser::PatternRewriter::Visit##Node(v8::internal::Node*) { \
     UNREACHABLE();                                                 \
   }
 
@@ skipping 36 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8