Changed statement ZoneList to a ZoneChunkList

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-types.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
 #include "src/bailout-reason.h"
 #include "src/base/flags.h"
 #include "src/factory.h"
 #include "src/globals.h"
 #include "src/isolate.h"
 #include "src/list.h"
 #include "src/parsing/token.h"
 #include "src/runtime/runtime.h"
 #include "src/small-pointer-list.h"
 #include "src/utils.h"
+#include "src/zone/zone-chunk-list.h"
 
 namespace v8 {
 namespace internal {
 
 // The abstract syntax tree is an intermediate, light-weight
 // representation of the parsed JavaScript code suitable for
 // compilation to native code.
 
 // Nodes are allocated in a separate zone, which allows faster
 // allocation and constant-time deallocation of the entire syntax
@@ skipping 138 matching lines @@
   FeedbackVectorSpec* get_spec() { return &spec_; }
 
  private:
   Flags flags_;
   int node_count_;
   FeedbackVectorSpec spec_;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
 
-
-class AstNode: public ZoneObject {
+class AstNode : public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum NodeType : uint8_t { AST_NODE_LIST(DECLARE_TYPE_ENUM) };
 #undef DECLARE_TYPE_ENUM
 
   void* operator new(size_t size, Zone* zone) { return zone->New(size); }
 
   NodeType node_type() const { return NodeTypeField::decode(bit_field_); }
   int position() const { return position_; }
 
@@ skipping 233 matching lines @@
     DCHECK(!BailoutId(base_id_).IsNone());
     return base_id_;
   }
 
   static const uint8_t kNextBitFieldIndex = BreakableTypeField::kNext;
 };
 
 
 class Block final : public BreakableStatement {
  public:
-  ZoneList<Statement*>* statements() { return &statements_; }
+  ZoneChunkList<Statement*>* statements() { return &statements_; }
   bool ignore_completion_value() const {
     return IgnoreCompletionField::decode(bit_field_);
   }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 
   bool IsJump() const {
-    return !statements_.is_empty() && statements_.last()->IsJump()
-        && labels() == NULL;  // Good enough as an approximation...
+    return statements_.size() > 0 && statements_.back()->IsJump() &&
+           labels() == NULL;  // Good enough as an approximation...
   }
 
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
  private:
   friend class AstNodeFactory;
 
-  Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
+  Block(Zone* zone, ZoneList<const AstRawString*>* labels,
         bool ignore_completion_value, int pos)
       : BreakableStatement(labels, TARGET_FOR_NAMED_ONLY, pos, kBlock),
-        statements_(capacity, zone),
+        statements_(zone),
         scope_(NULL) {
     bit_field_ |= IgnoreCompletionField::encode(ignore_completion_value);
   }
   static int parent_num_ids() { return BreakableStatement::num_ids(); }
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
-  ZoneList<Statement*> statements_;
+  ZoneChunkList<Statement*> statements_;
   Scope* scope_;
 
   class IgnoreCompletionField
       : public BitField<bool, BreakableStatement::kNextBitFieldIndex, 1> {};
 
  protected:
   static const uint8_t kNextBitFieldIndex = IgnoreCompletionField::kNext;
 };
 
 
@@ skipping 483 matching lines @@
 
 class CaseClause final : public Expression {
  public:
   bool is_default() const { return label_ == NULL; }
   Expression* label() const {
     CHECK(!is_default());
     return label_;
   }
   void set_label(Expression* e) { label_ = e; }
   Label* body_target() { return &body_target_; }
-  ZoneList<Statement*>* statements() const { return statements_; }
+  ZoneChunkList<Statement*>* statements() const { return statements_; }
 
   static int num_ids() { return parent_num_ids() + 2; }
   BailoutId EntryId() const { return BailoutId(local_id(0)); }
   TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
 
   AstType* compare_type() { return compare_type_; }
   void set_compare_type(AstType* type) { compare_type_ = type; }
 
   // CaseClause will have both a slot in the feedback vector and the
   // TypeFeedbackId to record the type information. TypeFeedbackId is used by
   // full codegen and the feedback vector slot is used by interpreter.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache);
 
   FeedbackVectorSlot CompareOperationFeedbackSlot() {
     return type_feedback_slot_;
   }
 
  private:
   friend class AstNodeFactory;
 
   static int parent_num_ids() { return Expression::num_ids(); }
-  CaseClause(Expression* label, ZoneList<Statement*>* statements, int pos);
+  CaseClause(Expression* label, ZoneChunkList<Statement*>* statements, int pos);
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* label_;
   Label body_target_;
-  ZoneList<Statement*>* statements_;
+  ZoneChunkList<Statement*>* statements_;
   AstType* compare_type_;
   FeedbackVectorSlot type_feedback_slot_;
 };
 
 
 class SwitchStatement final : public BreakableStatement {
  public:
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
@@ skipping 437 matching lines @@
     return flags;
   }
 
   enum Flags {
     kNoFlags = 0,
     kFastElements = 1,
     kShallowProperties = 1 << 1,
     kDisableMementos = 1 << 2
   };
 
-  struct Accessors: public ZoneObject {
+  struct Accessors : public ZoneObject {
     Accessors() : getter(NULL), setter(NULL), bailout_id(BailoutId::None()) {}
     ObjectLiteralProperty* getter;
     ObjectLiteralProperty* setter;
     BailoutId bailout_id;
   };
 
   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
 
   // Return an AST id for a property that is used in simulate instructions.
   BailoutId GetIdForPropertyName(int i) {
@@ skipping 1104 matching lines @@
   };
 
   enum ParameterFlag { kNoDuplicateParameters, kHasDuplicateParameters };
 
   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstString* raw_name() const { return raw_name_; }
   void set_raw_name(const AstString* name) { raw_name_ = name; }
   DeclarationScope* scope() const { return scope_; }
-  ZoneList<Statement*>* body() const { return body_; }
+  ZoneChunkList<Statement*>* body() const { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const;
   int end_position() const;
   int SourceSize() const { return end_position() - start_position(); }
   bool is_declaration() const { return function_type() == kDeclaration; }
   bool is_named_expression() const {
     return function_type() == kNamedExpression;
   }
   bool is_anonymous_expression() const {
@@ skipping 111 matching lines @@
   void set_is_class_field_initializer(bool is_class_field_initializer) {
     bit_field_ =
         IsClassFieldInitializer::update(bit_field_, is_class_field_initializer);
   }
 
  private:
   friend class AstNodeFactory;
 
   FunctionLiteral(Zone* zone, const AstString* name,
                   AstValueFactory* ast_value_factory, DeclarationScope* scope,
-                  ZoneList<Statement*>* body, int materialized_literal_count,
-                  int expected_property_count, int parameter_count,
-                  int function_length, FunctionType function_type,
+                  ZoneChunkList<Statement*>* body,
+                  int materialized_literal_count, int expected_property_count,
+                  int parameter_count, int function_length,
+                  FunctionType function_type,
                   ParameterFlag has_duplicate_parameters,
                   EagerCompileHint eager_compile_hint, int position,
                   bool is_function)
       : Expression(position, kFunctionLiteral),
         materialized_literal_count_(materialized_literal_count),
         expected_property_count_(expected_property_count),
         parameter_count_(parameter_count),
         function_length_(function_length),
         function_token_position_(kNoSourcePosition),
         yield_count_(0),
@@ skipping 30 matching lines @@
 
   int materialized_literal_count_;
   int expected_property_count_;
   int parameter_count_;
   int function_length_;
   int function_token_position_;
   int yield_count_;
 
   const AstString* raw_name_;
   DeclarationScope* scope_;
-  ZoneList<Statement*>* body_;
+  ZoneChunkList<Statement*>* body_;
   const AstString* raw_inferred_name_;
   Handle<String> inferred_name_;
   AstProperties ast_properties_;
 };
 
 // Property is used for passing information
 // about a class literal's properties from the parser to the code generator.
 class ClassLiteralProperty final : public LiteralProperty {
  public:
   enum Kind : uint8_t { METHOD, GETTER, SETTER, FIELD };
@@ skipping 182 matching lines @@
 class AstVisitor BASE_EMBEDDED {
  public:
   void Visit(AstNode* node) { impl()->Visit(node); }
 
   void VisitDeclarations(ZoneList<Declaration*>* declarations) {
     for (int i = 0; i < declarations->length(); i++) {
       Visit(declarations->at(i));
     }
   }
 
-  void VisitStatements(ZoneList<Statement*>* statements) {
-    for (int i = 0; i < statements->length(); i++) {
-      Statement* stmt = statements->at(i);
-      Visit(stmt);
-      if (stmt->IsJump()) break;
+  void VisitStatements(ZoneChunkList<Statement*>* statements) {
+    for (Statement* statement : *statements) {
+      Visit(statement);
+      if (statement->IsJump()) break;
     }
   }
 
   void VisitExpressions(ZoneList<Expression*>* expressions) {
     for (int i = 0; i < expressions->length(); i++) {
       // The variable statement visiting code may pass NULL expressions
       // to this code. Maybe this should be handled by introducing an
       // undefined expression or literal?  Revisit this code if this
       // changes
       Expression* expression = expressions->at(i);
@@ skipping 143 matching lines @@
                                               Scope* scope, int pos) {
     return new (zone_) VariableDeclaration(proxy, scope, pos);
   }
 
   FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
                                               FunctionLiteral* fun,
                                               Scope* scope, int pos) {
     return new (zone_) FunctionDeclaration(proxy, fun, scope, pos);
   }
 
-  Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
+  Block* NewBlock(ZoneList<const AstRawString*>* labels,
                   bool ignore_completion_value, int pos) {
-    return new (zone_)
-        Block(zone_, labels, capacity, ignore_completion_value, pos);
+    return new (zone_) Block(zone_, labels, ignore_completion_value, pos);
   }
 
 #define STATEMENT_WITH_LABELS(NodeType)                                     \
   NodeType* New##NodeType(ZoneList<const AstRawString*>* labels, int pos) { \
     return new (zone_) NodeType(labels, pos);                               \
   }
   STATEMENT_WITH_LABELS(DoWhileStatement)
   STATEMENT_WITH_LABELS(WhileStatement)
   STATEMENT_WITH_LABELS(ForStatement)
   STATEMENT_WITH_LABELS(SwitchStatement)
@@ skipping 100 matching lines @@
 
   EmptyStatement* NewEmptyStatement(int pos) {
     return new (zone_) EmptyStatement(pos);
   }
 
   SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(Scope* scope) {
     return new (zone_) SloppyBlockFunctionStatement(
         NewEmptyStatement(kNoSourcePosition), scope);
   }
 
-  CaseClause* NewCaseClause(
-      Expression* label, ZoneList<Statement*>* statements, int pos) {
+  CaseClause* NewCaseClause(Expression* label,
+                            ZoneChunkList<Statement*>* statements, int pos) {
     return new (zone_) CaseClause(label, statements, pos);
   }
 
   Literal* NewStringLiteral(const AstRawString* string, int pos) {
     return new (zone_) Literal(ast_value_factory_->NewString(string), pos);
   }
 
   // A JavaScript symbol (ECMA-262 edition 6).
   Literal* NewSymbolLiteral(const char* name, int pos) {
     return new (zone_) Literal(ast_value_factory_->NewSymbol(name), pos);
@@ skipping 173 matching lines @@
     if (!expression) expression = NewUndefinedLiteral(pos);
     return new (zone_) Yield(generator_object, expression, pos, on_exception);
   }
 
   Throw* NewThrow(Expression* exception, int pos) {
     return new (zone_) Throw(exception, pos);
   }
 
   FunctionLiteral* NewFunctionLiteral(
       const AstRawString* name, DeclarationScope* scope,
-      ZoneList<Statement*>* body, int materialized_literal_count,
+      ZoneChunkList<Statement*>* body, int materialized_literal_count,
       int expected_property_count, int parameter_count, int function_length,
       FunctionLiteral::ParameterFlag has_duplicate_parameters,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::EagerCompileHint eager_compile_hint, int position) {
     return new (zone_) FunctionLiteral(
         zone_, name, ast_value_factory_, scope, body,
         materialized_literal_count, expected_property_count, parameter_count,
         function_length, function_type, has_duplicate_parameters,
         eager_compile_hint, position, true);
   }
 
   // Creates a FunctionLiteral representing a top-level script, the
   // result of an eval (top-level or otherwise), or the result of calling
   // the Function constructor.
   FunctionLiteral* NewScriptOrEvalFunctionLiteral(
-      DeclarationScope* scope, ZoneList<Statement*>* body,
+      DeclarationScope* scope, ZoneChunkList<Statement*>* body,
       int materialized_literal_count, int expected_property_count,
       int parameter_count) {
     return new (zone_) FunctionLiteral(
         zone_, ast_value_factory_->empty_string(), ast_value_factory_, scope,
         body, materialized_literal_count, expected_property_count,
         parameter_count, parameter_count, FunctionLiteral::kAnonymousExpression,
         FunctionLiteral::kNoDuplicateParameters,
         FunctionLiteral::kShouldLazyCompile, 0, false);
   }
 
@@ skipping 113 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_