Changed statement ZoneList to a ZoneChunkList

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 2278 matching lines @@
   ExpressionT value;
   if (has_initializer) {
     value = this->ParseAssignmentExpression(
         true, CHECK_OK_CUSTOM(EmptyFunctionLiteral));
     impl()->RewriteNonPattern(CHECK_OK_CUSTOM(EmptyFunctionLiteral));
   } else {
     value = factory()->NewUndefinedLiteral(kNoSourcePosition);
   }
   initializer_scope->set_end_position(scanner()->location().end_pos);
   typename Types::StatementList body = impl()->NewStatementList(1);
-  body->Add(factory()->NewReturnStatement(value, kNoSourcePosition), zone());
+  body->push_back(factory()->NewReturnStatement(value, kNoSourcePosition));
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
       impl()->EmptyIdentifierString(), initializer_scope, body,
       initializer_state.materialized_literal_count(),
       initializer_state.expected_property_count(), 0, 0,
       FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::kAnonymousExpression, default_eager_compile_hint_,
       initializer_scope->start_position());
   function_literal->set_is_class_field_initializer(true);
   return function_literal;
 }
@@ skipping 1234 matching lines @@
   // declaration syntax.
 
   DCHECK_NOT_NULL(parsing_result);
   parsing_result->descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
   parsing_result->descriptor.declaration_pos = peek_position();
   parsing_result->descriptor.initialization_pos = peek_position();
 
   BlockT init_block = impl()->NullBlock();
   if (var_context != kForStatement) {
     init_block = factory()->NewBlock(
-        nullptr, 1, true, parsing_result->descriptor.declaration_pos);
+        nullptr, true, parsing_result->descriptor.declaration_pos);
   }
 
   switch (peek()) {
     case Token::VAR:
       parsing_result->descriptor.mode = VAR;
       Consume(Token::VAR);
       break;
     case Token::CONST:
       Consume(Token::CONST);
       DCHECK(var_context != kStatement);
@@ skipping 436 matching lines @@
           formal_parameters, body, kind == kAsyncArrowFunction, CHECK_OK);
       ExpressionClassifier classifier(this);
       if (kind == kAsyncArrowFunction) {
         ParseAsyncFunctionBody(scope(), body, kAsyncArrowFunction,
                                FunctionBodyType::kSingleExpression, accept_IN,
                                pos, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
       } else {
         ExpressionT expression = ParseAssignmentExpression(accept_IN, CHECK_OK);
         impl()->RewriteNonPattern(CHECK_OK);
-        body->Add(factory()->NewReturnStatement(expression, pos), zone());
+        body->push_back(factory()->NewReturnStatement(expression, pos));
         if (allow_tailcalls() && !is_sloppy(language_mode())) {
           // ES6 14.6.1 Static Semantics: IsInTailPosition
           impl()->MarkTailPosition(expression);
         }
       }
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       impl()->MarkCollectedTailCallExpressions();
     }
 
@@ skipping 99 matching lines @@
 template <typename Impl>
 void ParserBase<Impl>::ParseAsyncFunctionBody(Scope* scope, StatementListT body,
                                               FunctionKind kind,
                                               FunctionBodyType body_type,
                                               bool accept_IN, int pos,
                                               bool* ok) {
   scope->ForceContextAllocation();
 
   impl()->PrepareAsyncFunctionBody(body, kind, pos);
 
-  BlockT block = factory()->NewBlock(nullptr, 8, true, kNoSourcePosition);
+  BlockT block = factory()->NewBlock(nullptr, true, kNoSourcePosition);
 
   ExpressionT return_value = impl()->EmptyExpression();
   if (body_type == FunctionBodyType::kNormal) {
     ParseStatementList(block->statements(), Token::RBRACE,
                        CHECK_OK_CUSTOM(Void));
     return_value = factory()->NewUndefinedLiteral(kNoSourcePosition);
   } else {
     return_value = ParseAssignmentExpression(accept_IN, CHECK_OK_CUSTOM(Void));
     impl()->RewriteNonPattern(CHECK_OK_CUSTOM(Void));
   }
@@ skipping 290 matching lines @@
     // - over kLazyParseTrialLimit statements
     // - all starting with an identifier (i.e., no if, for, while, etc.)
     if (may_abort) {
       if (!starts_with_identifier) {
         may_abort = false;
       } else if (++count_statements > kLazyParseTrialLimit) {
         return kLazyParsingAborted;
       }
     }
 
-    body->Add(stat, zone());
+    body->push_back(stat);
   }
   return kLazyParsingComplete;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseStatementListItem(
     bool* ok) {
   // ECMA 262 6th Edition
   // StatementListItem[Yield, Return] :
   //   Statement[?Yield, ?Return]
@@ skipping 84 matching lines @@
     case Token::RETURN:
     case Token::THROW:
     case Token::TRY: {
       // These statements must have their labels preserved in an enclosing
       // block, as the corresponding AST nodes do not currently store their
       // labels.
       // TODO(nikolaos, marja): Consider adding the labels to the AST nodes.
       if (labels == nullptr) {
         return ParseStatementAsUnlabelled(labels, ok);
       } else {
-        BlockT result =
-            factory()->NewBlock(labels, 1, false, kNoSourcePosition);
+        BlockT result = factory()->NewBlock(labels, false, kNoSourcePosition);
         typename Types::Target target(this, result);
         StatementT statement = ParseStatementAsUnlabelled(labels, CHECK_OK);
-        result->statements()->Add(statement, zone());
+        result->statements()->push_back(statement);
         return result;
       }
     }
     case Token::WITH:
       return ParseWithStatement(labels, ok);
     case Token::SWITCH:
       return ParseSwitchStatement(labels, ok);
     case Token::FUNCTION:
       // FunctionDeclaration only allowed as a StatementListItem, not in
       // an arbitrary Statement position. Exceptions such as
@@ skipping 39 matching lines @@
   }
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::BlockT ParserBase<Impl>::ParseBlock(
     ZoneList<const AstRawString*>* labels, bool* ok) {
   // Block ::
   //   '{' StatementList '}'
 
   // Construct block expecting 16 statements.
-  BlockT body = factory()->NewBlock(labels, 16, false, kNoSourcePosition);
+  BlockT body = factory()->NewBlock(labels, false, kNoSourcePosition);
 
   // Parse the statements and collect escaping labels.
   Expect(Token::LBRACE, CHECK_OK_CUSTOM(NullBlock));
   {
     BlockState block_state(zone(), &scope_state_);
     block_state.set_start_position(scanner()->location().beg_pos);
     typename Types::Target target(this, body);
 
     while (peek() != Token::RBRACE) {
       StatementT stat = ParseStatementListItem(CHECK_OK_CUSTOM(NullBlock));
       if (!impl()->IsNullStatement(stat) && !impl()->IsEmptyStatement(stat)) {
-        body->statements()->Add(stat, zone());
+        body->statements()->push_back(stat);
       }
     }
 
     Expect(Token::RBRACE, CHECK_OK_CUSTOM(NullBlock));
     block_state.set_end_position(scanner()->location().end_pos);
     body->set_scope(block_state.FinalizedBlockScope());
   }
   return body;
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseScopedStatement(
     ZoneList<const AstRawString*>* labels, bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
     return ParseStatement(labels, kDisallowLabelledFunctionStatement, ok);
   } else {
     if (legacy) {
       impl()->CountUsage(v8::Isolate::kLegacyFunctionDeclaration);
     }
     // Make a block around the statement for a lexical binding
     // is introduced by a FunctionDeclaration.
     BlockState block_state(zone(), &scope_state_);
     block_state.set_start_position(scanner()->location().beg_pos);
-    BlockT block = factory()->NewBlock(NULL, 1, false, kNoSourcePosition);
+    BlockT block = factory()->NewBlock(NULL, false, kNoSourcePosition);
     StatementT body = ParseFunctionDeclaration(CHECK_OK);
-    block->statements()->Add(body, zone());
+    block->statements()->push_back(body);
     block_state.set_end_position(scanner()->location().end_pos);
     block->set_scope(block_state.FinalizedBlockScope());
     return block;
   }
 }
 
 template <typename Impl>
 typename ParserBase<Impl>::StatementT ParserBase<Impl>::ParseVariableStatement(
     VariableDeclarationContext var_context,
     ZoneList<const AstRawString*>* names, bool* ok) {
@@ skipping 374 matching lines @@
           return impl()->NullStatement();
         }
         default_seen = true;
       }
       Expect(Token::COLON, CHECK_OK);
       int clause_pos = position();
       StatementListT statements = impl()->NewStatementList(5);
       while (peek() != Token::CASE && peek() != Token::DEFAULT &&
              peek() != Token::RBRACE) {
         StatementT stat = ParseStatementListItem(CHECK_OK);
-        statements->Add(stat, zone());
+        statements->push_back(stat);
       }
       auto clause = factory()->NewCaseClause(label, statements, clause_pos);
       cases->Add(clause, zone());
     }
     Expect(Token::RBRACE, CHECK_OK);
 
     cases_block_state.set_end_position(scanner()->location().end_pos);
     return impl()->RewriteSwitchStatement(
         tag, switch_statement, cases, cases_block_state.FinalizedBlockScope());
   }
@@ skipping 37 matching lines @@
     Expect(Token::LPAREN, CHECK_OK);
     catch_info.scope = NewScope(CATCH_SCOPE);
     catch_info.scope->set_start_position(scanner()->location().beg_pos);
 
     {
       CollectExpressionsInTailPositionToListScope
           collect_tail_call_expressions_scope(
               function_state_, &catch_info.tail_call_expressions);
       BlockState catch_block_state(&scope_state_, catch_info.scope);
 
-      catch_block = factory()->NewBlock(nullptr, 16, false, kNoSourcePosition);
+      catch_block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
 
       // Create a block scope to hold any lexical declarations created
       // as part of destructuring the catch parameter.
       {
         BlockState catch_variable_block_state(zone(), &scope_state_);
         catch_variable_block_state.set_start_position(
             scanner()->location().beg_pos);
         typename Types::Target target(this, catch_block);
 
         // This does not simply call ParsePrimaryExpression to avoid
         // ExpressionFromIdentifier from being called in the first
         // branch, which would introduce an unresolved symbol and mess
         // with arrow function names.
         if (peek_any_identifier()) {
           catch_info.name =
               ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
         } else {
           ExpressionClassifier pattern_classifier(this);
           catch_info.pattern = ParsePrimaryExpression(CHECK_OK);
           ValidateBindingPattern(CHECK_OK);
         }
 
         Expect(Token::RPAREN, CHECK_OK);
         impl()->RewriteCatchPattern(&catch_info, CHECK_OK);
         if (!impl()->IsNullStatement(catch_info.init_block)) {
-          catch_block->statements()->Add(catch_info.init_block, zone());
+          catch_block->statements()->push_back(catch_info.init_block);
         }
 
         catch_info.inner_block = ParseBlock(nullptr, CHECK_OK);
-        catch_block->statements()->Add(catch_info.inner_block, zone());
+        catch_block->statements()->push_back(catch_info.inner_block);
         impl()->ValidateCatchBlock(catch_info, CHECK_OK);
         catch_variable_block_state.set_end_position(
             scanner()->location().end_pos);
         catch_block->set_scope(
             catch_variable_block_state.FinalizedBlockScope());
       }
     }
 
     catch_info.scope->set_end_position(scanner()->location().end_pos);
   }
@@ skipping 83 matching lines @@
                                         ReturnExprContext::kInsideForInOfBody);
           BlockState block_state(zone(), &scope_state_);
           block_state.set_start_position(scanner()->location().beg_pos);
 
           StatementT body = ParseScopedStatement(nullptr, true, CHECK_OK);
 
           BlockT body_block = impl()->NullBlock();
           ExpressionT each_variable = impl()->EmptyExpression();
           impl()->DesugarBindingInForEachStatement(&for_info, &body_block,
                                                    &each_variable, CHECK_OK);
-          body_block->statements()->Add(body, zone());
+          body_block->statements()->push_back(body);
           final_loop = impl()->InitializeForEachStatement(
               loop, each_variable, enumerable, body_block, each_keyword_pos);
 
           block_state.set_end_position(scanner()->location().end_pos);
           body_block->set_scope(block_state.FinalizedBlockScope());
         }
 
         init_block =
             impl()->CreateForEachStatementTDZ(init_block, for_info, ok);
 
         for_state.set_end_position(scanner()->location().end_pos);
         Scope* for_scope = for_state.FinalizedBlockScope();
         // Parsed for-in loop w/ variable declarations.
         if (!impl()->IsNullStatement(init_block)) {
-          init_block->statements()->Add(final_loop, zone());
+          init_block->statements()->push_back(final_loop);
           init_block->set_scope(for_scope);
           return init_block;
         } else {
           DCHECK_NULL(for_scope);
           return final_loop;
         }
       } else {
         // One or more declaration not followed by in/of.
         init = impl()->BuildInitializationBlock(
             &for_info.parsing_result,
@@ skipping 125 matching lines @@
       //   }
       //
       // or, desugar
       //   for (; c; n) b
       // into
       //   {
       //     for (; c; n) b
       //   }
       // just in case b introduces a lexical binding some other way, e.g., if b
       // is a FunctionDeclaration.
-      BlockT block = factory()->NewBlock(nullptr, 2, false, kNoSourcePosition);
+      BlockT block = factory()->NewBlock(nullptr, false, kNoSourcePosition);
       if (!impl()->IsNullStatement(init)) {
-        block->statements()->Add(init, zone());
+        block->statements()->push_back(init);
       }
-      block->statements()->Add(loop, zone());
+      block->statements()->push_back(loop);
       block->set_scope(for_scope);
       loop->Initialize(init, cond, next, body);
       return block;
     } else {
       loop->Initialize(init, cond, next, body);
       return loop;
     }
   }
 }
 
@@ skipping 48 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H