Changed statement ZoneList to a ZoneChunkList

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
 
@@ skipping 392 matching lines @@
 // The pre-parser doesn't need to build lists of expressions, identifiers, or
 // the like. If the PreParser is used in identifier tracking mode, it needs to
 // build lists of identifiers though.
 template <typename T>
 class PreParserList {
  public:
   // These functions make list->Add(some_expression) work (and do nothing).
   PreParserList() : length_(0), identifiers_(nullptr) {}
   PreParserList* operator->() { return this; }
   void Add(T, Zone* zone);
+  void push_back(T);
   int length() const { return length_; }
+  int size() const { return length_; }
   static PreParserList Null() { return PreParserList(-1); }
   bool IsNull() const { return length_ == -1; }
 
  private:
   explicit PreParserList(int n) : length_(n), identifiers_(nullptr) {}
   int length_;
   ZoneList<const AstRawString*>* identifiers_;
 
   friend class PreParser;
   friend class PreParserFactory;
 };
 
 template <>
 inline void PreParserList<PreParserExpression>::Add(
     PreParserExpression expression, Zone* zone) {
   if (expression.identifiers_ != nullptr) {
     DCHECK(FLAG_lazy_inner_functions);
     DCHECK(zone != nullptr);
     if (identifiers_ == nullptr) {
       identifiers_ = new (zone) ZoneList<const AstRawString*>(1, zone);
     }
     for (auto identifier : (*expression.identifiers_)) {
       identifiers_->Add(identifier, zone);
     }
   }
   ++length_;
 }
 
+template <>
+inline void PreParserList<PreParserExpression>::push_back(
+    PreParserExpression expression) {
+  UNREACHABLE();
+}
+
+template <typename T>
+void PreParserList<T>::Add(T, Zone*) {
+  ++length_;
+}
+
 template <typename T>
-void PreParserList<T>::Add(T, Zone* zone) {
+void PreParserList<T>::push_back(T) {
   ++length_;
 }
 
 typedef PreParserList<PreParserExpression> PreParserExpressionList;
 
 class PreParserStatement;
 typedef PreParserList<PreParserStatement> PreParserStatementList;
 
 class PreParserStatement {
  public:
@@ skipping 218 matching lines @@
 
   PreParserExpression NewEmptyParentheses(int pos) {
     return PreParserExpression::Default();
   }
 
   PreParserStatement NewEmptyStatement(int pos) {
     return PreParserStatement::Default();
   }
 
   PreParserStatement NewBlock(ZoneList<const AstRawString*>* labels,
-                              int capacity, bool ignore_completion_value,
-                              int pos) {
+                              bool ignore_completion_value, int pos) {
     return PreParserStatement::Default();
   }
 
   PreParserStatement NewDebuggerStatement(int pos) {
     return PreParserStatement::Default();
   }
 
   PreParserStatement NewExpressionStatement(PreParserExpression expr, int pos) {
     return PreParserStatement::ExpressionStatement(expr);
   }
@@ skipping 846 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H