Create ast/ and parsing/ subdirectories and move appropriate files

src/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_H_
-#define V8_AST_H_
-
-#include "src/assembler.h"
-#include "src/ast-value-factory.h"
-#include "src/bailout-reason.h"
-#include "src/base/flags.h"
-#include "src/base/smart-pointers.h"
-#include "src/factory.h"
-#include "src/isolate.h"
-#include "src/list.h"
-#include "src/modules.h"
-#include "src/regexp/jsregexp.h"
-#include "src/runtime/runtime.h"
-#include "src/small-pointer-list.h"
-#include "src/token.h"
-#include "src/types.h"
-#include "src/utils.h"
-#include "src/variables.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
-// tree.
-
-
-// ----------------------------------------------------------------------------
-// Nodes of the abstract syntax tree. Only concrete classes are
-// enumerated here.
-
-#define DECLARATION_NODE_LIST(V) \
-  V(VariableDeclaration)         \
-  V(FunctionDeclaration)         \
-  V(ImportDeclaration)           \
-  V(ExportDeclaration)
-
-#define STATEMENT_NODE_LIST(V)    \
-  V(Block)                        \
-  V(ExpressionStatement)          \
-  V(EmptyStatement)               \
-  V(SloppyBlockFunctionStatement) \
-  V(IfStatement)                  \
-  V(ContinueStatement)            \
-  V(BreakStatement)               \
-  V(ReturnStatement)              \
-  V(WithStatement)                \
-  V(SwitchStatement)              \
-  V(DoWhileStatement)             \
-  V(WhileStatement)               \
-  V(ForStatement)                 \
-  V(ForInStatement)               \
-  V(ForOfStatement)               \
-  V(TryCatchStatement)            \
-  V(TryFinallyStatement)          \
-  V(DebuggerStatement)
-
-#define EXPRESSION_NODE_LIST(V) \
-  V(FunctionLiteral)            \
-  V(ClassLiteral)               \
-  V(NativeFunctionLiteral)      \
-  V(Conditional)                \
-  V(VariableProxy)              \
-  V(Literal)                    \
-  V(RegExpLiteral)              \
-  V(ObjectLiteral)              \
-  V(ArrayLiteral)               \
-  V(Assignment)                 \
-  V(Yield)                      \
-  V(Throw)                      \
-  V(Property)                   \
-  V(Call)                       \
-  V(CallNew)                    \
-  V(CallRuntime)                \
-  V(UnaryOperation)             \
-  V(CountOperation)             \
-  V(BinaryOperation)            \
-  V(CompareOperation)           \
-  V(Spread)                     \
-  V(ThisFunction)               \
-  V(SuperPropertyReference)     \
-  V(SuperCallReference)         \
-  V(CaseClause)                 \
-  V(EmptyParentheses)           \
-  V(DoExpression)
-
-#define AST_NODE_LIST(V)                        \
-  DECLARATION_NODE_LIST(V)                      \
-  STATEMENT_NODE_LIST(V)                        \
-  EXPRESSION_NODE_LIST(V)
-
-// Forward declarations
-class AstNodeFactory;
-class AstVisitor;
-class Declaration;
-class Module;
-class BreakableStatement;
-class Expression;
-class IterationStatement;
-class MaterializedLiteral;
-class Statement;
-class TypeFeedbackOracle;
-
-class RegExpAlternative;
-class RegExpAssertion;
-class RegExpAtom;
-class RegExpBackReference;
-class RegExpCapture;
-class RegExpCharacterClass;
-class RegExpCompiler;
-class RegExpDisjunction;
-class RegExpEmpty;
-class RegExpLookaround;
-class RegExpQuantifier;
-class RegExpText;
-
-#define DEF_FORWARD_DECLARATION(type) class type;
-AST_NODE_LIST(DEF_FORWARD_DECLARATION)
-#undef DEF_FORWARD_DECLARATION
-
-
-// Typedef only introduced to avoid unreadable code.
-typedef ZoneList<Handle<String>> ZoneStringList;
-typedef ZoneList<Handle<Object>> ZoneObjectList;
-
-
-#define DECLARE_NODE_TYPE(type)                                          \
-  void Accept(AstVisitor* v) override;                                   \
-  AstNode::NodeType node_type() const final { return AstNode::k##type; } \
-  friend class AstNodeFactory;
-
-
-class FeedbackVectorSlotCache {
- public:
-  explicit FeedbackVectorSlotCache(Zone* zone)
-      : zone_(zone),
-        hash_map_(HashMap::PointersMatch, ZoneHashMap::kDefaultHashMapCapacity,
-                  ZoneAllocationPolicy(zone)) {}
-
-  void Put(Variable* variable, FeedbackVectorSlot slot) {
-    ZoneHashMap::Entry* entry = hash_map_.LookupOrInsert(
-        variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone_));
-    entry->value = reinterpret_cast<void*>(slot.ToInt());
-  }
-
-  ZoneHashMap::Entry* Get(Variable* variable) const {
-    return hash_map_.Lookup(variable, ComputePointerHash(variable));
-  }
-
- private:
-  Zone* zone_;
-  ZoneHashMap hash_map_;
-};
-
-
-class AstProperties final BASE_EMBEDDED {
- public:
-  enum Flag {
-    kNoFlags = 0,
-    kDontSelfOptimize = 1 << 0,
-    kDontCrankshaft = 1 << 1
-  };
-
-  typedef base::Flags<Flag> Flags;
-
-  explicit AstProperties(Zone* zone) : node_count_(0), spec_(zone) {}
-
-  Flags& flags() { return flags_; }
-  Flags flags() const { return flags_; }
-  int node_count() { return node_count_; }
-  void add_node_count(int count) { node_count_ += count; }
-
-  const FeedbackVectorSpec* get_spec() const { return &spec_; }
-  FeedbackVectorSpec* get_spec() { return &spec_; }
-
- private:
-  Flags flags_;
-  int node_count_;
-  FeedbackVectorSpec spec_;
-};
-
-DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
-
-
-class AstNode: public ZoneObject {
- public:
-#define DECLARE_TYPE_ENUM(type) k##type,
-  enum NodeType {
-    AST_NODE_LIST(DECLARE_TYPE_ENUM)
-    kInvalid = -1
-  };
-#undef DECLARE_TYPE_ENUM
-
-  void* operator new(size_t size, Zone* zone) { return zone->New(size); }
-
-  explicit AstNode(int position): position_(position) {}
-  virtual ~AstNode() {}
-
-  virtual void Accept(AstVisitor* v) = 0;
-  virtual NodeType node_type() const = 0;
-  int position() const { return position_; }
-
-  // Type testing & conversion functions overridden by concrete subclasses.
-#define DECLARE_NODE_FUNCTIONS(type) \
-  bool Is##type() const { return node_type() == AstNode::k##type; } \
-  type* As##type() { \
-    return Is##type() ? reinterpret_cast<type*>(this) : NULL; \
-  } \
-  const type* As##type() const { \
-    return Is##type() ? reinterpret_cast<const type*>(this) : NULL; \
-  }
-  AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
-#undef DECLARE_NODE_FUNCTIONS
-
-  virtual BreakableStatement* AsBreakableStatement() { return NULL; }
-  virtual IterationStatement* AsIterationStatement() { return NULL; }
-  virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
-
-  // The interface for feedback slots, with default no-op implementations for
-  // node types which don't actually have this. Note that this is conceptually
-  // not really nice, but multiple inheritance would introduce yet another
-  // vtable entry per node, something we don't want for space reasons.
-  virtual void AssignFeedbackVectorSlots(Isolate* isolate,
-                                         FeedbackVectorSpec* spec,
-                                         FeedbackVectorSlotCache* cache) {}
-
- private:
-  // Hidden to prevent accidental usage. It would have to load the
-  // current zone from the TLS.
-  void* operator new(size_t size);
-
-  friend class CaseClause;  // Generates AST IDs.
-
-  int position_;
-};
-
-
-class Statement : public AstNode {
- public:
-  explicit Statement(Zone* zone, int position) : AstNode(position) {}
-
-  bool IsEmpty() { return AsEmptyStatement() != NULL; }
-  virtual bool IsJump() const { return false; }
-};
-
-
-class SmallMapList final {
- public:
-  SmallMapList() {}
-  SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
-
-  void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
-  void Clear() { list_.Clear(); }
-  void Sort() { list_.Sort(); }
-
-  bool is_empty() const { return list_.is_empty(); }
-  int length() const { return list_.length(); }
-
-  void AddMapIfMissing(Handle<Map> map, Zone* zone) {
-    if (!Map::TryUpdate(map).ToHandle(&map)) return;
-    for (int i = 0; i < length(); ++i) {
-      if (at(i).is_identical_to(map)) return;
-    }
-    Add(map, zone);
-  }
-
-  void FilterForPossibleTransitions(Map* root_map) {
-    for (int i = list_.length() - 1; i >= 0; i--) {
-      if (at(i)->FindRootMap() != root_map) {
-        list_.RemoveElement(list_.at(i));
-      }
-    }
-  }
-
-  void Add(Handle<Map> handle, Zone* zone) {
-    list_.Add(handle.location(), zone);
-  }
-
-  Handle<Map> at(int i) const {
-    return Handle<Map>(list_.at(i));
-  }
-
-  Handle<Map> first() const { return at(0); }
-  Handle<Map> last() const { return at(length() - 1); }
-
- private:
-  // The list stores pointers to Map*, that is Map**, so it's GC safe.
-  SmallPointerList<Map*> list_;
-
-  DISALLOW_COPY_AND_ASSIGN(SmallMapList);
-};
-
-
-class Expression : public AstNode {
- public:
-  enum Context {
-    // Not assigned a context yet, or else will not be visited during
-    // code generation.
-    kUninitialized,
-    // Evaluated for its side effects.
-    kEffect,
-    // Evaluated for its value (and side effects).
-    kValue,
-    // Evaluated for control flow (and side effects).
-    kTest
-  };
-
-  // True iff the expression is a valid reference expression.
-  virtual bool IsValidReferenceExpression() const { return false; }
-
-  // Helpers for ToBoolean conversion.
-  virtual bool ToBooleanIsTrue() const { return false; }
-  virtual bool ToBooleanIsFalse() const { return false; }
-
-  // Symbols that cannot be parsed as array indices are considered property
-  // names.  We do not treat symbols that can be array indexes as property
-  // names because [] for string objects is handled only by keyed ICs.
-  virtual bool IsPropertyName() const { return false; }
-
-  // True iff the expression is a literal represented as a smi.
-  bool IsSmiLiteral() const;
-
-  // True iff the expression is a string literal.
-  bool IsStringLiteral() const;
-
-  // True iff the expression is the null literal.
-  bool IsNullLiteral() const;
-
-  // True if we can prove that the expression is the undefined literal.
-  bool IsUndefinedLiteral(Isolate* isolate) const;
-
-  // True iff the expression is a valid target for an assignment.
-  bool IsValidReferenceExpressionOrThis() const;
-
-  // Expression type bounds
-  Bounds bounds() const { return bounds_; }
-  void set_bounds(Bounds bounds) { bounds_ = bounds; }
-
-  // Type feedback information for assignments and properties.
-  virtual bool IsMonomorphic() {
-    UNREACHABLE();
-    return false;
-  }
-  virtual SmallMapList* GetReceiverTypes() {
-    UNREACHABLE();
-    return NULL;
-  }
-  virtual KeyedAccessStoreMode GetStoreMode() const {
-    UNREACHABLE();
-    return STANDARD_STORE;
-  }
-  virtual IcCheckType GetKeyType() const {
-    UNREACHABLE();
-    return ELEMENT;
-  }
-
-  // TODO(rossberg): this should move to its own AST node eventually.
-  virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
-  uint16_t to_boolean_types() const {
-    return ToBooleanTypesField::decode(bit_field_);
-  }
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId id() const { return BailoutId(local_id(0)); }
-  TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
-
- protected:
-  Expression(Zone* zone, int pos)
-      : AstNode(pos),
-        base_id_(BailoutId::None().ToInt()),
-        bounds_(Bounds::Unbounded()),
-        bit_field_(0) {}
-  static int parent_num_ids() { return 0; }
-  void set_to_boolean_types(uint16_t types) {
-    bit_field_ = ToBooleanTypesField::update(bit_field_, types);
-  }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  int base_id_;
-  Bounds bounds_;
-  class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
-  uint16_t bit_field_;
-  // Ends with 16-bit field; deriving classes in turn begin with
-  // 16-bit fields for optimum packing efficiency.
-};
-
-
-class BreakableStatement : public Statement {
- public:
-  enum BreakableType {
-    TARGET_FOR_ANONYMOUS,
-    TARGET_FOR_NAMED_ONLY
-  };
-
-  // The labels associated with this statement. May be NULL;
-  // if it is != NULL, guaranteed to contain at least one entry.
-  ZoneList<const AstRawString*>* labels() const { return labels_; }
-
-  // Type testing & conversion.
-  BreakableStatement* AsBreakableStatement() final { return this; }
-
-  // Code generation
-  Label* break_target() { return &break_target_; }
-
-  // Testers.
-  bool is_target_for_anonymous() const {
-    return breakable_type_ == TARGET_FOR_ANONYMOUS;
-  }
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId EntryId() const { return BailoutId(local_id(0)); }
-  BailoutId ExitId() const { return BailoutId(local_id(1)); }
-
- protected:
-  BreakableStatement(Zone* zone, ZoneList<const AstRawString*>* labels,
-                     BreakableType breakable_type, int position)
-      : Statement(zone, position),
-        labels_(labels),
-        breakable_type_(breakable_type),
-        base_id_(BailoutId::None().ToInt()) {
-    DCHECK(labels == NULL || labels->length() > 0);
-  }
-  static int parent_num_ids() { return 0; }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  ZoneList<const AstRawString*>* labels_;
-  BreakableType breakable_type_;
-  Label break_target_;
-  int base_id_;
-};
-
-
-class Block final : public BreakableStatement {
- public:
-  DECLARE_NODE_TYPE(Block)
-
-  ZoneList<Statement*>* statements() { return &statements_; }
-  bool ignore_completion_value() const { return ignore_completion_value_; }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId DeclsId() const { return BailoutId(local_id(0)); }
-
-  bool IsJump() const override {
-    return !statements_.is_empty() && statements_.last()->IsJump()
-        && labels() == NULL;  // Good enough as an approximation...
-  }
-
-  Scope* scope() const { return scope_; }
-  void set_scope(Scope* scope) { scope_ = scope; }
-
- protected:
-  Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
-        bool ignore_completion_value, int pos)
-      : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
-        statements_(capacity, zone),
-        ignore_completion_value_(ignore_completion_value),
-        scope_(NULL) {}
-  static int parent_num_ids() { return BreakableStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  ZoneList<Statement*> statements_;
-  bool ignore_completion_value_;
-  Scope* scope_;
-};
-
-
-class DoExpression final : public Expression {
- public:
-  DECLARE_NODE_TYPE(DoExpression)
-
-  Block* block() { return block_; }
-  VariableProxy* result() { return result_; }
-
- protected:
-  DoExpression(Zone* zone, Block* block, VariableProxy* result, int pos)
-      : Expression(zone, pos), block_(block), result_(result) {
-    DCHECK_NOT_NULL(block_);
-    DCHECK_NOT_NULL(result_);
-  }
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Block* block_;
-  VariableProxy* result_;
-};
-
-
-class Declaration : public AstNode {
- public:
-  VariableProxy* proxy() const { return proxy_; }
-  VariableMode mode() const { return mode_; }
-  Scope* scope() const { return scope_; }
-  virtual InitializationFlag initialization() const = 0;
-  virtual bool IsInlineable() const;
-
- protected:
-  Declaration(Zone* zone, VariableProxy* proxy, VariableMode mode, Scope* scope,
-              int pos)
-      : AstNode(pos), mode_(mode), proxy_(proxy), scope_(scope) {
-    DCHECK(IsDeclaredVariableMode(mode));
-  }
-
- private:
-  VariableMode mode_;
-  VariableProxy* proxy_;
-
-  // Nested scope from which the declaration originated.
-  Scope* scope_;
-};
-
-
-class VariableDeclaration final : public Declaration {
- public:
-  DECLARE_NODE_TYPE(VariableDeclaration)
-
-  InitializationFlag initialization() const override {
-    return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
-  }
-
-  bool is_class_declaration() const { return is_class_declaration_; }
-
-  // VariableDeclarations can be grouped into consecutive declaration
-  // groups. Each VariableDeclaration is associated with the start position of
-  // the group it belongs to. The positions are used for strong mode scope
-  // checks for classes and functions.
-  int declaration_group_start() const { return declaration_group_start_; }
-
- protected:
-  VariableDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
-                      Scope* scope, int pos, bool is_class_declaration = false,
-                      int declaration_group_start = -1)
-      : Declaration(zone, proxy, mode, scope, pos),
-        is_class_declaration_(is_class_declaration),
-        declaration_group_start_(declaration_group_start) {}
-
-  bool is_class_declaration_;
-  int declaration_group_start_;
-};
-
-
-class FunctionDeclaration final : public Declaration {
- public:
-  DECLARE_NODE_TYPE(FunctionDeclaration)
-
-  FunctionLiteral* fun() const { return fun_; }
-  InitializationFlag initialization() const override {
-    return kCreatedInitialized;
-  }
-  bool IsInlineable() const override;
-
- protected:
-  FunctionDeclaration(Zone* zone,
-                      VariableProxy* proxy,
-                      VariableMode mode,
-                      FunctionLiteral* fun,
-                      Scope* scope,
-                      int pos)
-      : Declaration(zone, proxy, mode, scope, pos),
-        fun_(fun) {
-    DCHECK(mode == VAR || mode == LET || mode == CONST);
-    DCHECK(fun != NULL);
-  }
-
- private:
-  FunctionLiteral* fun_;
-};
-
-
-class ImportDeclaration final : public Declaration {
- public:
-  DECLARE_NODE_TYPE(ImportDeclaration)
-
-  const AstRawString* import_name() const { return import_name_; }
-  const AstRawString* module_specifier() const { return module_specifier_; }
-  void set_module_specifier(const AstRawString* module_specifier) {
-    DCHECK(module_specifier_ == NULL);
-    module_specifier_ = module_specifier;
-  }
-  InitializationFlag initialization() const override {
-    return kNeedsInitialization;
-  }
-
- protected:
-  ImportDeclaration(Zone* zone, VariableProxy* proxy,
-                    const AstRawString* import_name,
-                    const AstRawString* module_specifier, Scope* scope, int pos)
-      : Declaration(zone, proxy, IMPORT, scope, pos),
-        import_name_(import_name),
-        module_specifier_(module_specifier) {}
-
- private:
-  const AstRawString* import_name_;
-  const AstRawString* module_specifier_;
-};
-
-
-class ExportDeclaration final : public Declaration {
- public:
-  DECLARE_NODE_TYPE(ExportDeclaration)
-
-  InitializationFlag initialization() const override {
-    return kCreatedInitialized;
-  }
-
- protected:
-  ExportDeclaration(Zone* zone, VariableProxy* proxy, Scope* scope, int pos)
-      : Declaration(zone, proxy, LET, scope, pos) {}
-};
-
-
-class Module : public AstNode {
- public:
-  ModuleDescriptor* descriptor() const { return descriptor_; }
-  Block* body() const { return body_; }
-
- protected:
-  Module(Zone* zone, int pos)
-      : AstNode(pos), descriptor_(ModuleDescriptor::New(zone)), body_(NULL) {}
-  Module(Zone* zone, ModuleDescriptor* descriptor, int pos, Block* body = NULL)
-      : AstNode(pos), descriptor_(descriptor), body_(body) {}
-
- private:
-  ModuleDescriptor* descriptor_;
-  Block* body_;
-};
-
-
-class IterationStatement : public BreakableStatement {
- public:
-  // Type testing & conversion.
-  IterationStatement* AsIterationStatement() final { return this; }
-
-  Statement* body() const { return body_; }
-  void set_body(Statement* s) { body_ = s; }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
-  virtual BailoutId ContinueId() const = 0;
-  virtual BailoutId StackCheckId() const = 0;
-
-  // Code generation
-  Label* continue_target()  { return &continue_target_; }
-
- protected:
-  IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
-        body_(NULL) {}
-  static int parent_num_ids() { return BreakableStatement::num_ids(); }
-  void Initialize(Statement* body) { body_ = body; }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Statement* body_;
-  Label continue_target_;
-};
-
-
-class DoWhileStatement final : public IterationStatement {
- public:
-  DECLARE_NODE_TYPE(DoWhileStatement)
-
-  void Initialize(Expression* cond, Statement* body) {
-    IterationStatement::Initialize(body);
-    cond_ = cond;
-  }
-
-  Expression* cond() const { return cond_; }
-
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
-  BailoutId StackCheckId() const override { return BackEdgeId(); }
-  BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
-
- protected:
-  DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : IterationStatement(zone, labels, pos), cond_(NULL) {}
-  static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* cond_;
-};
-
-
-class WhileStatement final : public IterationStatement {
- public:
-  DECLARE_NODE_TYPE(WhileStatement)
-
-  void Initialize(Expression* cond, Statement* body) {
-    IterationStatement::Initialize(body);
-    cond_ = cond;
-  }
-
-  Expression* cond() const { return cond_; }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId ContinueId() const override { return EntryId(); }
-  BailoutId StackCheckId() const override { return BodyId(); }
-  BailoutId BodyId() const { return BailoutId(local_id(0)); }
-
- protected:
-  WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : IterationStatement(zone, labels, pos), cond_(NULL) {}
-  static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* cond_;
-};
-
-
-class ForStatement final : public IterationStatement {
- public:
-  DECLARE_NODE_TYPE(ForStatement)
-
-  void Initialize(Statement* init,
-                  Expression* cond,
-                  Statement* next,
-                  Statement* body) {
-    IterationStatement::Initialize(body);
-    init_ = init;
-    cond_ = cond;
-    next_ = next;
-  }
-
-  Statement* init() const { return init_; }
-  Expression* cond() const { return cond_; }
-  Statement* next() const { return next_; }
-
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
-  BailoutId StackCheckId() const override { return BodyId(); }
-  BailoutId BodyId() const { return BailoutId(local_id(1)); }
-
- protected:
-  ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : IterationStatement(zone, labels, pos),
-        init_(NULL),
-        cond_(NULL),
-        next_(NULL) {}
-  static int parent_num_ids() { return IterationStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Statement* init_;
-  Expression* cond_;
-  Statement* next_;
-};
-
-
-class ForEachStatement : public IterationStatement {
- public:
-  enum VisitMode {
-    ENUMERATE,   // for (each in subject) body;
-    ITERATE      // for (each of subject) body;
-  };
-
-  void Initialize(Expression* each, Expression* subject, Statement* body) {
-    IterationStatement::Initialize(body);
-    each_ = each;
-    subject_ = subject;
-  }
-
-  Expression* each() const { return each_; }
-  Expression* subject() const { return subject_; }
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-  FeedbackVectorSlot EachFeedbackSlot() const { return each_slot_; }
-
- protected:
-  ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : IterationStatement(zone, labels, pos), each_(NULL), subject_(NULL) {}
-
- private:
-  Expression* each_;
-  Expression* subject_;
-  FeedbackVectorSlot each_slot_;
-};
-
-
-class ForInStatement final : public ForEachStatement {
- public:
-  DECLARE_NODE_TYPE(ForInStatement)
-
-  Expression* enumerable() const {
-    return subject();
-  }
-
-  // Type feedback information.
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override {
-    ForEachStatement::AssignFeedbackVectorSlots(isolate, spec, cache);
-    for_in_feedback_slot_ = spec->AddGeneralSlot();
-  }
-
-  FeedbackVectorSlot ForInFeedbackSlot() {
-    DCHECK(!for_in_feedback_slot_.IsInvalid());
-    return for_in_feedback_slot_;
-  }
-
-  enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
-  ForInType for_in_type() const { return for_in_type_; }
-  void set_for_in_type(ForInType type) { for_in_type_ = type; }
-
-  static int num_ids() { return parent_num_ids() + 6; }
-  BailoutId BodyId() const { return BailoutId(local_id(0)); }
-  BailoutId PrepareId() const { return BailoutId(local_id(1)); }
-  BailoutId EnumId() const { return BailoutId(local_id(2)); }
-  BailoutId ToObjectId() const { return BailoutId(local_id(3)); }
-  BailoutId FilterId() const { return BailoutId(local_id(4)); }
-  BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
-  BailoutId ContinueId() const override { return EntryId(); }
-  BailoutId StackCheckId() const override { return BodyId(); }
-
- protected:
-  ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : ForEachStatement(zone, labels, pos), for_in_type_(SLOW_FOR_IN) {}
-  static int parent_num_ids() { return ForEachStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  ForInType for_in_type_;
-  FeedbackVectorSlot for_in_feedback_slot_;
-};
-
-
-class ForOfStatement final : public ForEachStatement {
- public:
-  DECLARE_NODE_TYPE(ForOfStatement)
-
-  void Initialize(Expression* each,
-                  Expression* subject,
-                  Statement* body,
-                  Expression* assign_iterator,
-                  Expression* next_result,
-                  Expression* result_done,
-                  Expression* assign_each) {
-    ForEachStatement::Initialize(each, subject, body);
-    assign_iterator_ = assign_iterator;
-    next_result_ = next_result;
-    result_done_ = result_done;
-    assign_each_ = assign_each;
-  }
-
-  Expression* iterable() const {
-    return subject();
-  }
-
-  // iterator = subject[Symbol.iterator]()
-  Expression* assign_iterator() const {
-    return assign_iterator_;
-  }
-
-  // result = iterator.next()  // with type check
-  Expression* next_result() const {
-    return next_result_;
-  }
-
-  // result.done
-  Expression* result_done() const {
-    return result_done_;
-  }
-
-  // each = result.value
-  Expression* assign_each() const {
-    return assign_each_;
-  }
-
-  BailoutId ContinueId() const override { return EntryId(); }
-  BailoutId StackCheckId() const override { return BackEdgeId(); }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
-
- protected:
-  ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : ForEachStatement(zone, labels, pos),
-        assign_iterator_(NULL),
-        next_result_(NULL),
-        result_done_(NULL),
-        assign_each_(NULL) {}
-  static int parent_num_ids() { return ForEachStatement::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* assign_iterator_;
-  Expression* next_result_;
-  Expression* result_done_;
-  Expression* assign_each_;
-};
-
-
-class ExpressionStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(ExpressionStatement)
-
-  void set_expression(Expression* e) { expression_ = e; }
-  Expression* expression() const { return expression_; }
-  bool IsJump() const override { return expression_->IsThrow(); }
-
- protected:
-  ExpressionStatement(Zone* zone, Expression* expression, int pos)
-      : Statement(zone, pos), expression_(expression) { }
-
- private:
-  Expression* expression_;
-};
-
-
-class JumpStatement : public Statement {
- public:
-  bool IsJump() const final { return true; }
-
- protected:
-  explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
-};
-
-
-class ContinueStatement final : public JumpStatement {
- public:
-  DECLARE_NODE_TYPE(ContinueStatement)
-
-  IterationStatement* target() const { return target_; }
-
- protected:
-  explicit ContinueStatement(Zone* zone, IterationStatement* target, int pos)
-      : JumpStatement(zone, pos), target_(target) { }
-
- private:
-  IterationStatement* target_;
-};
-
-
-class BreakStatement final : public JumpStatement {
- public:
-  DECLARE_NODE_TYPE(BreakStatement)
-
-  BreakableStatement* target() const { return target_; }
-
- protected:
-  explicit BreakStatement(Zone* zone, BreakableStatement* target, int pos)
-      : JumpStatement(zone, pos), target_(target) { }
-
- private:
-  BreakableStatement* target_;
-};
-
-
-class ReturnStatement final : public JumpStatement {
- public:
-  DECLARE_NODE_TYPE(ReturnStatement)
-
-  Expression* expression() const { return expression_; }
-
- protected:
-  explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
-      : JumpStatement(zone, pos), expression_(expression) { }
-
- private:
-  Expression* expression_;
-};
-
-
-class WithStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(WithStatement)
-
-  Scope* scope() { return scope_; }
-  Expression* expression() const { return expression_; }
-  Statement* statement() const { return statement_; }
-  void set_statement(Statement* s) { statement_ = s; }
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId EntryId() const { return BailoutId(local_id(0)); }
-
- protected:
-  WithStatement(Zone* zone, Scope* scope, Expression* expression,
-                Statement* statement, int pos)
-      : Statement(zone, pos),
-        scope_(scope),
-        expression_(expression),
-        statement_(statement),
-        base_id_(BailoutId::None().ToInt()) {}
-  static int parent_num_ids() { return 0; }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Scope* scope_;
-  Expression* expression_;
-  Statement* statement_;
-  int base_id_;
-};
-
-
-class CaseClause final : public Expression {
- public:
-  DECLARE_NODE_TYPE(CaseClause)
-
-  bool is_default() const { return label_ == NULL; }
-  Expression* label() const {
-    CHECK(!is_default());
-    return label_;
-  }
-  Label* body_target() { return &body_target_; }
-  ZoneList<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)); }
-
-  Type* compare_type() { return compare_type_; }
-  void set_compare_type(Type* type) { compare_type_ = type; }
-
- protected:
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  CaseClause(Zone* zone, Expression* label, ZoneList<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_;
-  Type* compare_type_;
-};
-
-
-class SwitchStatement final : public BreakableStatement {
- public:
-  DECLARE_NODE_TYPE(SwitchStatement)
-
-  void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
-    tag_ = tag;
-    cases_ = cases;
-  }
-
-  Expression* tag() const { return tag_; }
-  ZoneList<CaseClause*>* cases() const { return cases_; }
-
- protected:
-  SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
-      : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
-        tag_(NULL),
-        cases_(NULL) {}
-
- private:
-  Expression* tag_;
-  ZoneList<CaseClause*>* cases_;
-};
-
-
-// If-statements always have non-null references to their then- and
-// else-parts. When parsing if-statements with no explicit else-part,
-// the parser implicitly creates an empty statement. Use the
-// HasThenStatement() and HasElseStatement() functions to check if a
-// given if-statement has a then- or an else-part containing code.
-class IfStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(IfStatement)
-
-  bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
-  bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
-
-  Expression* condition() const { return condition_; }
-  Statement* then_statement() const { return then_statement_; }
-  Statement* else_statement() const { return else_statement_; }
-
-  void set_then_statement(Statement* s) { then_statement_ = s; }
-  void set_else_statement(Statement* s) { else_statement_ = s; }
-
-  bool IsJump() const override {
-    return HasThenStatement() && then_statement()->IsJump()
-        && HasElseStatement() && else_statement()->IsJump();
-  }
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 3; }
-  BailoutId IfId() const { return BailoutId(local_id(0)); }
-  BailoutId ThenId() const { return BailoutId(local_id(1)); }
-  BailoutId ElseId() const { return BailoutId(local_id(2)); }
-
- protected:
-  IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
-              Statement* else_statement, int pos)
-      : Statement(zone, pos),
-        condition_(condition),
-        then_statement_(then_statement),
-        else_statement_(else_statement),
-        base_id_(BailoutId::None().ToInt()) {}
-  static int parent_num_ids() { return 0; }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* condition_;
-  Statement* then_statement_;
-  Statement* else_statement_;
-  int base_id_;
-};
-
-
-class TryStatement : public Statement {
- public:
-  Block* try_block() const { return try_block_; }
-  void set_try_block(Block* b) { try_block_ = b; }
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId HandlerId() const { return BailoutId(local_id(0)); }
-
- protected:
-  TryStatement(Zone* zone, Block* try_block, int pos)
-      : Statement(zone, pos),
-        try_block_(try_block),
-        base_id_(BailoutId::None().ToInt()) {}
-  static int parent_num_ids() { return 0; }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Block* try_block_;
-  int base_id_;
-};
-
-
-class TryCatchStatement final : public TryStatement {
- public:
-  DECLARE_NODE_TYPE(TryCatchStatement)
-
-  Scope* scope() { return scope_; }
-  Variable* variable() { return variable_; }
-  Block* catch_block() const { return catch_block_; }
-  void set_catch_block(Block* b) { catch_block_ = b; }
-
- protected:
-  TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
-                    Variable* variable, Block* catch_block, int pos)
-      : TryStatement(zone, try_block, pos),
-        scope_(scope),
-        variable_(variable),
-        catch_block_(catch_block) {}
-
- private:
-  Scope* scope_;
-  Variable* variable_;
-  Block* catch_block_;
-};
-
-
-class TryFinallyStatement final : public TryStatement {
- public:
-  DECLARE_NODE_TYPE(TryFinallyStatement)
-
-  Block* finally_block() const { return finally_block_; }
-  void set_finally_block(Block* b) { finally_block_ = b; }
-
- protected:
-  TryFinallyStatement(Zone* zone, Block* try_block, Block* finally_block,
-                      int pos)
-      : TryStatement(zone, try_block, pos), finally_block_(finally_block) {}
-
- private:
-  Block* finally_block_;
-};
-
-
-class DebuggerStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(DebuggerStatement)
-
-  void set_base_id(int id) { base_id_ = id; }
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId DebugBreakId() const { return BailoutId(local_id(0)); }
-
- protected:
-  explicit DebuggerStatement(Zone* zone, int pos)
-      : Statement(zone, pos), base_id_(BailoutId::None().ToInt()) {}
-  static int parent_num_ids() { return 0; }
-
-  int base_id() const {
-    DCHECK(!BailoutId(base_id_).IsNone());
-    return base_id_;
-  }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  int base_id_;
-};
-
-
-class EmptyStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(EmptyStatement)
-
- protected:
-  explicit EmptyStatement(Zone* zone, int pos): Statement(zone, pos) {}
-};
-
-
-// Delegates to another statement, which may be overwritten.
-// This was introduced to implement ES2015 Annex B3.3 for conditionally making
-// sloppy-mode block-scoped functions have a var binding, which is changed
-// from one statement to another during parsing.
-class SloppyBlockFunctionStatement final : public Statement {
- public:
-  DECLARE_NODE_TYPE(SloppyBlockFunctionStatement)
-
-  Statement* statement() const { return statement_; }
-  void set_statement(Statement* statement) { statement_ = statement; }
-  Scope* scope() const { return scope_; }
-
- private:
-  SloppyBlockFunctionStatement(Zone* zone, Statement* statement, Scope* scope)
-      : Statement(zone, RelocInfo::kNoPosition),
-        statement_(statement),
-        scope_(scope) {}
-
-  Statement* statement_;
-  Scope* const scope_;
-};
-
-
-class Literal final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Literal)
-
-  bool IsPropertyName() const override { return value_->IsPropertyName(); }
-
-  Handle<String> AsPropertyName() {
-    DCHECK(IsPropertyName());
-    return Handle<String>::cast(value());
-  }
-
-  const AstRawString* AsRawPropertyName() {
-    DCHECK(IsPropertyName());
-    return value_->AsString();
-  }
-
-  bool ToBooleanIsTrue() const override { return value()->BooleanValue(); }
-  bool ToBooleanIsFalse() const override { return !value()->BooleanValue(); }
-
-  Handle<Object> value() const { return value_->value(); }
-  const AstValue* raw_value() const { return value_; }
-
-  // Support for using Literal as a HashMap key. NOTE: Currently, this works
-  // only for string and number literals!
-  uint32_t Hash();
-  static bool Match(void* literal1, void* literal2);
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  TypeFeedbackId LiteralFeedbackId() const {
-    return TypeFeedbackId(local_id(0));
-  }
-
- protected:
-  Literal(Zone* zone, const AstValue* value, int position)
-      : Expression(zone, position), value_(value) {}
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  const AstValue* value_;
-};
-
-
-class AstLiteralReindexer;
-
-// Base class for literals that needs space in the corresponding JSFunction.
-class MaterializedLiteral : public Expression {
- public:
-  MaterializedLiteral* AsMaterializedLiteral() final { return this; }
-
-  int literal_index() { return literal_index_; }
-
-  int depth() const {
-    // only callable after initialization.
-    DCHECK(depth_ >= 1);
-    return depth_;
-  }
-
-  bool is_strong() const { return is_strong_; }
-
- protected:
-  MaterializedLiteral(Zone* zone, int literal_index, bool is_strong, int pos)
-      : Expression(zone, pos),
-        literal_index_(literal_index),
-        is_simple_(false),
-        is_strong_(is_strong),
-        depth_(0) {}
-
-  // A materialized literal is simple if the values consist of only
-  // constants and simple object and array literals.
-  bool is_simple() const { return is_simple_; }
-  void set_is_simple(bool is_simple) { is_simple_ = is_simple; }
-  friend class CompileTimeValue;
-
-  void set_depth(int depth) {
-    DCHECK(depth >= 1);
-    depth_ = depth;
-  }
-
-  // Populate the constant properties/elements fixed array.
-  void BuildConstants(Isolate* isolate);
-  friend class ArrayLiteral;
-  friend class ObjectLiteral;
-
-  // If the expression is a literal, return the literal value;
-  // if the expression is a materialized literal and is simple return a
-  // compile time value as encoded by CompileTimeValue::GetValue().
-  // Otherwise, return undefined literal as the placeholder
-  // in the object literal boilerplate.
-  Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
-
- private:
-  int literal_index_;
-  bool is_simple_;
-  bool is_strong_;
-  int depth_;
-
-  friend class AstLiteralReindexer;
-};
-
-
-// Property is used for passing information
-// about an object literal's properties from the parser
-// to the code generator.
-class ObjectLiteralProperty final : public ZoneObject {
- public:
-  enum Kind {
-    CONSTANT,              // Property with constant value (compile time).
-    COMPUTED,              // Property with computed value (execution time).
-    MATERIALIZED_LITERAL,  // Property value is a materialized literal.
-    GETTER, SETTER,        // Property is an accessor function.
-    PROTOTYPE              // Property is __proto__.
-  };
-
-  Expression* key() { return key_; }
-  Expression* value() { return value_; }
-  Kind kind() { return kind_; }
-
-  // Type feedback information.
-  bool IsMonomorphic() { return !receiver_type_.is_null(); }
-  Handle<Map> GetReceiverType() { return receiver_type_; }
-
-  bool IsCompileTimeValue();
-
-  void set_emit_store(bool emit_store);
-  bool emit_store();
-
-  bool is_static() const { return is_static_; }
-  bool is_computed_name() const { return is_computed_name_; }
-
-  FeedbackVectorSlot GetSlot(int offset = 0) const {
-    DCHECK_LT(offset, static_cast<int>(arraysize(slots_)));
-    return slots_[offset];
-  }
-  void SetSlot(FeedbackVectorSlot slot, int offset = 0) {
-    DCHECK_LT(offset, static_cast<int>(arraysize(slots_)));
-    slots_[offset] = slot;
-  }
-
-  void set_receiver_type(Handle<Map> map) { receiver_type_ = map; }
-
- protected:
-  friend class AstNodeFactory;
-
-  ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
-                        bool is_static, bool is_computed_name);
-  ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
-                        Expression* value, bool is_static,
-                        bool is_computed_name);
-
- private:
-  Expression* key_;
-  Expression* value_;
-  FeedbackVectorSlot slots_[2];
-  Kind kind_;
-  bool emit_store_;
-  bool is_static_;
-  bool is_computed_name_;
-  Handle<Map> receiver_type_;
-};
-
-
-// An object literal has a boilerplate object that is used
-// for minimizing the work when constructing it at runtime.
-class ObjectLiteral final : public MaterializedLiteral {
- public:
-  typedef ObjectLiteralProperty Property;
-
-  DECLARE_NODE_TYPE(ObjectLiteral)
-
-  Handle<FixedArray> constant_properties() const {
-    return constant_properties_;
-  }
-  int properties_count() const { return constant_properties_->length() / 2; }
-  ZoneList<Property*>* properties() const { return properties_; }
-  bool fast_elements() const { return fast_elements_; }
-  bool may_store_doubles() const { return may_store_doubles_; }
-  bool has_function() const { return has_function_; }
-  bool has_elements() const { return has_elements_; }
-
-  // Decide if a property should be in the object boilerplate.
-  static bool IsBoilerplateProperty(Property* property);
-
-  // Populate the constant properties fixed array.
-  void BuildConstantProperties(Isolate* isolate);
-
-  // Mark all computed expressions that are bound to a key that
-  // is shadowed by a later occurrence of the same key. For the
-  // marked expressions, no store code is emitted.
-  void CalculateEmitStore(Zone* zone);
-
-  // Assemble bitfield of flags for the CreateObjectLiteral helper.
-  int ComputeFlags(bool disable_mementos = false) const {
-    int flags = fast_elements() ? kFastElements : kNoFlags;
-    flags |= has_function() ? kHasFunction : kNoFlags;
-    if (depth() == 1 && !has_elements() && !may_store_doubles()) {
-      flags |= kShallowProperties;
-    }
-    if (disable_mementos) {
-      flags |= kDisableMementos;
-    }
-    if (is_strong()) {
-      flags |= kIsStrong;
-    }
-    return flags;
-  }
-
-  enum Flags {
-    kNoFlags = 0,
-    kFastElements = 1,
-    kHasFunction = 1 << 1,
-    kShallowProperties = 1 << 2,
-    kDisableMementos = 1 << 3,
-    kIsStrong = 1 << 4
-  };
-
-  struct Accessors: public ZoneObject {
-    Accessors() : getter(NULL), setter(NULL) {}
-    ObjectLiteralProperty* getter;
-    ObjectLiteralProperty* setter;
-  };
-
-  BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
-
-  // Return an AST id for a property that is used in simulate instructions.
-  BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 1)); }
-
-  // Unlike other AST nodes, this number of bailout IDs allocated for an
-  // ObjectLiteral can vary, so num_ids() is not a static method.
-  int num_ids() const { return parent_num_ids() + 1 + properties()->length(); }
-
-  // Object literals need one feedback slot for each non-trivial value, as well
-  // as some slots for home objects.
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-
- protected:
-  ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
-                int boilerplate_properties, bool has_function, bool is_strong,
-                int pos)
-      : MaterializedLiteral(zone, literal_index, is_strong, pos),
-        properties_(properties),
-        boilerplate_properties_(boilerplate_properties),
-        fast_elements_(false),
-        has_elements_(false),
-        may_store_doubles_(false),
-        has_function_(has_function) {}
-  static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-  Handle<FixedArray> constant_properties_;
-  ZoneList<Property*>* properties_;
-  int boilerplate_properties_;
-  bool fast_elements_;
-  bool has_elements_;
-  bool may_store_doubles_;
-  bool has_function_;
-  FeedbackVectorSlot slot_;
-};
-
-
-// A map from property names to getter/setter pairs allocated in the zone.
-class AccessorTable : public TemplateHashMap<Literal, ObjectLiteral::Accessors,
-                                             ZoneAllocationPolicy> {
- public:
-  explicit AccessorTable(Zone* zone)
-      : TemplateHashMap<Literal, ObjectLiteral::Accessors,
-                        ZoneAllocationPolicy>(Literal::Match,
-                                              ZoneAllocationPolicy(zone)),
-        zone_(zone) {}
-
-  Iterator lookup(Literal* literal) {
-    Iterator it = find(literal, true, ZoneAllocationPolicy(zone_));
-    if (it->second == NULL) it->second = new (zone_) ObjectLiteral::Accessors();
-    return it;
-  }
-
- private:
-  Zone* zone_;
-};
-
-
-// Node for capturing a regexp literal.
-class RegExpLiteral final : public MaterializedLiteral {
- public:
-  DECLARE_NODE_TYPE(RegExpLiteral)
-
-  Handle<String> pattern() const { return pattern_->string(); }
-  int flags() const { return flags_; }
-
- protected:
-  RegExpLiteral(Zone* zone, const AstRawString* pattern, int flags,
-                int literal_index, bool is_strong, int pos)
-      : MaterializedLiteral(zone, literal_index, is_strong, pos),
-        pattern_(pattern),
-        flags_(flags) {
-    set_depth(1);
-  }
-
- private:
-  const AstRawString* const pattern_;
-  int const flags_;
-};
-
-
-// An array literal has a literals object that is used
-// for minimizing the work when constructing it at runtime.
-class ArrayLiteral final : public MaterializedLiteral {
- public:
-  DECLARE_NODE_TYPE(ArrayLiteral)
-
-  Handle<FixedArray> constant_elements() const { return constant_elements_; }
-  ElementsKind constant_elements_kind() const {
-    DCHECK_EQ(2, constant_elements_->length());
-    return static_cast<ElementsKind>(
-        Smi::cast(constant_elements_->get(0))->value());
-  }
-
-  ZoneList<Expression*>* values() const { return values_; }
-
-  BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
-
-  // Return an AST id for an element that is used in simulate instructions.
-  BailoutId GetIdForElement(int i) { return BailoutId(local_id(i + 1)); }
-
-  // Unlike other AST nodes, this number of bailout IDs allocated for an
-  // ArrayLiteral can vary, so num_ids() is not a static method.
-  int num_ids() const { return parent_num_ids() + 1 + values()->length(); }
-
-  // Populate the constant elements fixed array.
-  void BuildConstantElements(Isolate* isolate);
-
-  // Assemble bitfield of flags for the CreateArrayLiteral helper.
-  int ComputeFlags(bool disable_mementos = false) const {
-    int flags = depth() == 1 ? kShallowElements : kNoFlags;
-    if (disable_mementos) {
-      flags |= kDisableMementos;
-    }
-    if (is_strong()) {
-      flags |= kIsStrong;
-    }
-    return flags;
-  }
-
-  enum Flags {
-    kNoFlags = 0,
-    kShallowElements = 1,
-    kDisableMementos = 1 << 1,
-    kIsStrong = 1 << 2
-  };
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-  FeedbackVectorSlot LiteralFeedbackSlot() const { return literal_slot_; }
-
- protected:
-  ArrayLiteral(Zone* zone, ZoneList<Expression*>* values,
-               int first_spread_index, int literal_index, bool is_strong,
-               int pos)
-      : MaterializedLiteral(zone, literal_index, is_strong, pos),
-        values_(values),
-        first_spread_index_(first_spread_index) {}
-  static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Handle<FixedArray> constant_elements_;
-  ZoneList<Expression*>* values_;
-  int first_spread_index_;
-  FeedbackVectorSlot literal_slot_;
-};
-
-
-class VariableProxy final : public Expression {
- public:
-  DECLARE_NODE_TYPE(VariableProxy)
-
-  bool IsValidReferenceExpression() const override {
-    return !is_this() && !is_new_target();
-  }
-
-  bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
-
-  Handle<String> name() const { return raw_name()->string(); }
-  const AstRawString* raw_name() const {
-    return is_resolved() ? var_->raw_name() : raw_name_;
-  }
-
-  Variable* var() const {
-    DCHECK(is_resolved());
-    return var_;
-  }
-  void set_var(Variable* v) {
-    DCHECK(!is_resolved());
-    DCHECK_NOT_NULL(v);
-    var_ = v;
-  }
-
-  bool is_this() const { return IsThisField::decode(bit_field_); }
-
-  bool is_assigned() const { return IsAssignedField::decode(bit_field_); }
-  void set_is_assigned() {
-    bit_field_ = IsAssignedField::update(bit_field_, true);
-  }
-
-  bool is_resolved() const { return IsResolvedField::decode(bit_field_); }
-  void set_is_resolved() {
-    bit_field_ = IsResolvedField::update(bit_field_, true);
-  }
-
-  bool is_new_target() const { return IsNewTargetField::decode(bit_field_); }
-  void set_is_new_target() {
-    bit_field_ = IsNewTargetField::update(bit_field_, true);
-  }
-
-  int end_position() const { return end_position_; }
-
-  // Bind this proxy to the variable var.
-  void BindTo(Variable* var);
-
-  bool UsesVariableFeedbackSlot() const {
-    return var()->IsUnallocated() || var()->IsLookupSlot();
-  }
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-
-  FeedbackVectorSlot VariableFeedbackSlot() { return variable_feedback_slot_; }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId BeforeId() const { return BailoutId(local_id(0)); }
-
- protected:
-  VariableProxy(Zone* zone, Variable* var, int start_position,
-                int end_position);
-
-  VariableProxy(Zone* zone, const AstRawString* name,
-                Variable::Kind variable_kind, int start_position,
-                int end_position);
-  static int parent_num_ids() { return Expression::num_ids(); }
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  class IsThisField : public BitField8<bool, 0, 1> {};
-  class IsAssignedField : public BitField8<bool, 1, 1> {};
-  class IsResolvedField : public BitField8<bool, 2, 1> {};
-  class IsNewTargetField : public BitField8<bool, 3, 1> {};
-
-  // Start with 16-bit (or smaller) field, which should get packed together
-  // with Expression's trailing 16-bit field.
-  uint8_t bit_field_;
-  FeedbackVectorSlot variable_feedback_slot_;
-  union {
-    const AstRawString* raw_name_;  // if !is_resolved_
-    Variable* var_;                 // if is_resolved_
-  };
-  // Position is stored in the AstNode superclass, but VariableProxy needs to
-  // know its end position too (for error messages). It cannot be inferred from
-  // the variable name length because it can contain escapes.
-  int end_position_;
-};
-
-
-// Left-hand side can only be a property, a global or a (parameter or local)
-// slot.
-enum LhsKind {
-  VARIABLE,
-  NAMED_PROPERTY,
-  KEYED_PROPERTY,
-  NAMED_SUPER_PROPERTY,
-  KEYED_SUPER_PROPERTY
-};
-
-
-class Property final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Property)
-
-  bool IsValidReferenceExpression() const override { return true; }
-
-  Expression* obj() const { return obj_; }
-  Expression* key() const { return key_; }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId LoadId() const { return BailoutId(local_id(0)); }
-
-  bool IsStringAccess() const {
-    return IsStringAccessField::decode(bit_field_);
-  }
-
-  // Type feedback information.
-  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
-  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
-  KeyedAccessStoreMode GetStoreMode() const override { return STANDARD_STORE; }
-  IcCheckType GetKeyType() const override {
-    return KeyTypeField::decode(bit_field_);
-  }
-  bool IsUninitialized() const {
-    return !is_for_call() && HasNoTypeInformation();
-  }
-  bool HasNoTypeInformation() const {
-    return GetInlineCacheState() == UNINITIALIZED;
-  }
-  InlineCacheState GetInlineCacheState() const {
-    return InlineCacheStateField::decode(bit_field_);
-  }
-  void set_is_string_access(bool b) {
-    bit_field_ = IsStringAccessField::update(bit_field_, b);
-  }
-  void set_key_type(IcCheckType key_type) {
-    bit_field_ = KeyTypeField::update(bit_field_, key_type);
-  }
-  void set_inline_cache_state(InlineCacheState state) {
-    bit_field_ = InlineCacheStateField::update(bit_field_, state);
-  }
-  void mark_for_call() {
-    bit_field_ = IsForCallField::update(bit_field_, true);
-  }
-  bool is_for_call() const { return IsForCallField::decode(bit_field_); }
-
-  bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override {
-    FeedbackVectorSlotKind kind = key()->IsPropertyName()
-                                      ? FeedbackVectorSlotKind::LOAD_IC
-                                      : FeedbackVectorSlotKind::KEYED_LOAD_IC;
-    property_feedback_slot_ = spec->AddSlot(kind);
-  }
-
-  FeedbackVectorSlot PropertyFeedbackSlot() const {
-    return property_feedback_slot_;
-  }
-
-  static LhsKind GetAssignType(Property* property) {
-    if (property == NULL) return VARIABLE;
-    bool super_access = property->IsSuperAccess();
-    return (property->key()->IsPropertyName())
-               ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
-               : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
-  }
-
- protected:
-  Property(Zone* zone, Expression* obj, Expression* key, int pos)
-      : Expression(zone, pos),
-        bit_field_(IsForCallField::encode(false) |
-                   IsStringAccessField::encode(false) |
-                   InlineCacheStateField::encode(UNINITIALIZED)),
-        obj_(obj),
-        key_(key) {}
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  class IsForCallField : public BitField8<bool, 0, 1> {};
-  class IsStringAccessField : public BitField8<bool, 1, 1> {};
-  class KeyTypeField : public BitField8<IcCheckType, 2, 1> {};
-  class InlineCacheStateField : public BitField8<InlineCacheState, 3, 4> {};
-  uint8_t bit_field_;
-  FeedbackVectorSlot property_feedback_slot_;
-  Expression* obj_;
-  Expression* key_;
-  SmallMapList receiver_types_;
-};
-
-
-class Call final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Call)
-
-  Expression* expression() const { return expression_; }
-  ZoneList<Expression*>* arguments() const { return arguments_; }
-
-  // Type feedback information.
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-
-  FeedbackVectorSlot CallFeedbackSlot() const { return stub_slot_; }
-
-  FeedbackVectorSlot CallFeedbackICSlot() const { return ic_slot_; }
-
-  SmallMapList* GetReceiverTypes() override {
-    if (expression()->IsProperty()) {
-      return expression()->AsProperty()->GetReceiverTypes();
-    }
-    return NULL;
-  }
-
-  bool IsMonomorphic() override {
-    if (expression()->IsProperty()) {
-      return expression()->AsProperty()->IsMonomorphic();
-    }
-    return !target_.is_null();
-  }
-
-  bool global_call() const {
-    VariableProxy* proxy = expression_->AsVariableProxy();
-    return proxy != NULL && proxy->var()->IsUnallocatedOrGlobalSlot();
-  }
-
-  bool known_global_function() const {
-    return global_call() && !target_.is_null();
-  }
-
-  Handle<JSFunction> target() { return target_; }
-
-  Handle<AllocationSite> allocation_site() { return allocation_site_; }
-
-  void SetKnownGlobalTarget(Handle<JSFunction> target) {
-    target_ = target;
-    set_is_uninitialized(false);
-  }
-  void set_target(Handle<JSFunction> target) { target_ = target; }
-  void set_allocation_site(Handle<AllocationSite> site) {
-    allocation_site_ = site;
-  }
-
-  static int num_ids() { return parent_num_ids() + 4; }
-  BailoutId ReturnId() const { return BailoutId(local_id(0)); }
-  BailoutId EvalId() const { return BailoutId(local_id(1)); }
-  BailoutId LookupId() const { return BailoutId(local_id(2)); }
-  BailoutId CallId() const { return BailoutId(local_id(3)); }
-
-  bool is_uninitialized() const {
-    return IsUninitializedField::decode(bit_field_);
-  }
-  void set_is_uninitialized(bool b) {
-    bit_field_ = IsUninitializedField::update(bit_field_, b);
-  }
-
-  enum CallType {
-    POSSIBLY_EVAL_CALL,
-    GLOBAL_CALL,
-    LOOKUP_SLOT_CALL,
-    NAMED_PROPERTY_CALL,
-    KEYED_PROPERTY_CALL,
-    NAMED_SUPER_PROPERTY_CALL,
-    KEYED_SUPER_PROPERTY_CALL,
-    SUPER_CALL,
-    OTHER_CALL
-  };
-
-  // Helpers to determine how to handle the call.
-  CallType GetCallType(Isolate* isolate) const;
-  bool IsUsingCallFeedbackSlot(Isolate* isolate) const;
-  bool IsUsingCallFeedbackICSlot(Isolate* isolate) const;
-
-#ifdef DEBUG
-  // Used to assert that the FullCodeGenerator records the return site.
-  bool return_is_recorded_;
-#endif
-
- protected:
-  Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
-       int pos)
-      : Expression(zone, pos),
-        expression_(expression),
-        arguments_(arguments),
-        bit_field_(IsUninitializedField::encode(false)) {
-    if (expression->IsProperty()) {
-      expression->AsProperty()->mark_for_call();
-    }
-  }
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  FeedbackVectorSlot ic_slot_;
-  FeedbackVectorSlot stub_slot_;
-  Expression* expression_;
-  ZoneList<Expression*>* arguments_;
-  Handle<JSFunction> target_;
-  Handle<AllocationSite> allocation_site_;
-  class IsUninitializedField : public BitField8<bool, 0, 1> {};
-  uint8_t bit_field_;
-};
-
-
-class CallNew final : public Expression {
- public:
-  DECLARE_NODE_TYPE(CallNew)
-
-  Expression* expression() const { return expression_; }
-  ZoneList<Expression*>* arguments() const { return arguments_; }
-
-  // Type feedback information.
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override {
-    callnew_feedback_slot_ = spec->AddGeneralSlot();
-  }
-
-  FeedbackVectorSlot CallNewFeedbackSlot() {
-    DCHECK(!callnew_feedback_slot_.IsInvalid());
-    return callnew_feedback_slot_;
-  }
-
-  bool IsMonomorphic() override { return is_monomorphic_; }
-  Handle<JSFunction> target() const { return target_; }
-  Handle<AllocationSite> allocation_site() const {
-    return allocation_site_;
-  }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  static int feedback_slots() { return 1; }
-  BailoutId ReturnId() const { return BailoutId(local_id(0)); }
-
-  void set_allocation_site(Handle<AllocationSite> site) {
-    allocation_site_ = site;
-  }
-  void set_is_monomorphic(bool monomorphic) { is_monomorphic_ = monomorphic; }
-  void set_target(Handle<JSFunction> target) { target_ = target; }
-  void SetKnownGlobalTarget(Handle<JSFunction> target) {
-    target_ = target;
-    is_monomorphic_ = true;
-  }
-
- protected:
-  CallNew(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
-          int pos)
-      : Expression(zone, pos),
-        expression_(expression),
-        arguments_(arguments),
-        is_monomorphic_(false) {}
-
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* expression_;
-  ZoneList<Expression*>* arguments_;
-  bool is_monomorphic_;
-  Handle<JSFunction> target_;
-  Handle<AllocationSite> allocation_site_;
-  FeedbackVectorSlot callnew_feedback_slot_;
-};
-
-
-// The CallRuntime class does not represent any official JavaScript
-// language construct. Instead it is used to call a C or JS function
-// with a set of arguments. This is used from the builtins that are
-// implemented in JavaScript (see "v8natives.js").
-class CallRuntime final : public Expression {
- public:
-  DECLARE_NODE_TYPE(CallRuntime)
-
-  ZoneList<Expression*>* arguments() const { return arguments_; }
-  bool is_jsruntime() const { return function_ == NULL; }
-
-  int context_index() const {
-    DCHECK(is_jsruntime());
-    return context_index_;
-  }
-  const Runtime::Function* function() const {
-    DCHECK(!is_jsruntime());
-    return function_;
-  }
-
-  static int num_ids() { return parent_num_ids() + 1; }
-  BailoutId CallId() { return BailoutId(local_id(0)); }
-
-  const char* debug_name() {
-    return is_jsruntime() ? "(context function)" : function_->name;
-  }
-
- protected:
-  CallRuntime(Zone* zone, const Runtime::Function* function,
-              ZoneList<Expression*>* arguments, int pos)
-      : Expression(zone, pos), function_(function), arguments_(arguments) {}
-
-  CallRuntime(Zone* zone, int context_index, ZoneList<Expression*>* arguments,
-              int pos)
-      : Expression(zone, pos),
-        function_(NULL),
-        context_index_(context_index),
-        arguments_(arguments) {}
-
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  const Runtime::Function* function_;
-  int context_index_;
-  ZoneList<Expression*>* arguments_;
-};
-
-
-class UnaryOperation final : public Expression {
- public:
-  DECLARE_NODE_TYPE(UnaryOperation)
-
-  Token::Value op() const { return op_; }
-  Expression* expression() const { return expression_; }
-
-  // For unary not (Token::NOT), the AST ids where true and false will
-  // actually be materialized, respectively.
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
-  BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
-
-  void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
-
- protected:
-  UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
-      : Expression(zone, pos), op_(op), expression_(expression) {
-    DCHECK(Token::IsUnaryOp(op));
-  }
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Token::Value op_;
-  Expression* expression_;
-};
-
-
-class BinaryOperation final : public Expression {
- public:
-  DECLARE_NODE_TYPE(BinaryOperation)
-
-  Token::Value op() const { return static_cast<Token::Value>(op_); }
-  Expression* left() const { return left_; }
-  Expression* right() const { return right_; }
-  Handle<AllocationSite> allocation_site() const { return allocation_site_; }
-  void set_allocation_site(Handle<AllocationSite> allocation_site) {
-    allocation_site_ = allocation_site;
-  }
-
-  // The short-circuit logical operations need an AST ID for their
-  // right-hand subexpression.
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId RightId() const { return BailoutId(local_id(0)); }
-
-  TypeFeedbackId BinaryOperationFeedbackId() const {
-    return TypeFeedbackId(local_id(1));
-  }
-  Maybe<int> fixed_right_arg() const {
-    return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
-  }
-  void set_fixed_right_arg(Maybe<int> arg) {
-    has_fixed_right_arg_ = arg.IsJust();
-    if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
-  }
-
-  void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
-
- protected:
-  BinaryOperation(Zone* zone, Token::Value op, Expression* left,
-                  Expression* right, int pos)
-      : Expression(zone, pos),
-        op_(static_cast<byte>(op)),
-        has_fixed_right_arg_(false),
-        fixed_right_arg_value_(0),
-        left_(left),
-        right_(right) {
-    DCHECK(Token::IsBinaryOp(op));
-  }
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  const byte op_;  // actually Token::Value
-  // TODO(rossberg): the fixed arg should probably be represented as a Constant
-  // type for the RHS. Currenty it's actually a Maybe<int>
-  bool has_fixed_right_arg_;
-  int fixed_right_arg_value_;
-  Expression* left_;
-  Expression* right_;
-  Handle<AllocationSite> allocation_site_;
-};
-
-
-class CountOperation final : public Expression {
- public:
-  DECLARE_NODE_TYPE(CountOperation)
-
-  bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
-  bool is_postfix() const { return !is_prefix(); }
-
-  Token::Value op() const { return TokenField::decode(bit_field_); }
-  Token::Value binary_op() {
-    return (op() == Token::INC) ? Token::ADD : Token::SUB;
-  }
-
-  Expression* expression() const { return expression_; }
-
-  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
-  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
-  IcCheckType GetKeyType() const override {
-    return KeyTypeField::decode(bit_field_);
-  }
-  KeyedAccessStoreMode GetStoreMode() const override {
-    return StoreModeField::decode(bit_field_);
-  }
-  Type* type() const { return type_; }
-  void set_key_type(IcCheckType type) {
-    bit_field_ = KeyTypeField::update(bit_field_, type);
-  }
-  void set_store_mode(KeyedAccessStoreMode mode) {
-    bit_field_ = StoreModeField::update(bit_field_, mode);
-  }
-  void set_type(Type* type) { type_ = type; }
-
-  static int num_ids() { return parent_num_ids() + 4; }
-  BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
-  BailoutId ToNumberId() const { return BailoutId(local_id(1)); }
-  TypeFeedbackId CountBinOpFeedbackId() const {
-    return TypeFeedbackId(local_id(2));
-  }
-  TypeFeedbackId CountStoreFeedbackId() const {
-    return TypeFeedbackId(local_id(3));
-  }
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-  FeedbackVectorSlot CountSlot() const { return slot_; }
-
- protected:
-  CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
-                 int pos)
-      : Expression(zone, pos),
-        bit_field_(
-            IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
-            StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
-        type_(NULL),
-        expression_(expr) {}
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  class IsPrefixField : public BitField16<bool, 0, 1> {};
-  class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
-  class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
-  class TokenField : public BitField16<Token::Value, 5, 8> {};
-
-  // Starts with 16-bit field, which should get packed together with
-  // Expression's trailing 16-bit field.
-  uint16_t bit_field_;
-  Type* type_;
-  Expression* expression_;
-  SmallMapList receiver_types_;
-  FeedbackVectorSlot slot_;
-};
-
-
-class CompareOperation final : public Expression {
- public:
-  DECLARE_NODE_TYPE(CompareOperation)
-
-  Token::Value op() const { return op_; }
-  Expression* left() const { return left_; }
-  Expression* right() const { return right_; }
-
-  // Type feedback information.
-  static int num_ids() { return parent_num_ids() + 1; }
-  TypeFeedbackId CompareOperationFeedbackId() const {
-    return TypeFeedbackId(local_id(0));
-  }
-  Type* combined_type() const { return combined_type_; }
-  void set_combined_type(Type* type) { combined_type_ = type; }
-
-  // Match special cases.
-  bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
-  bool IsLiteralCompareUndefined(Expression** expr, Isolate* isolate);
-  bool IsLiteralCompareNull(Expression** expr);
-
- protected:
-  CompareOperation(Zone* zone, Token::Value op, Expression* left,
-                   Expression* right, int pos)
-      : Expression(zone, pos),
-        op_(op),
-        left_(left),
-        right_(right),
-        combined_type_(Type::None(zone)) {
-    DCHECK(Token::IsCompareOp(op));
-  }
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Token::Value op_;
-  Expression* left_;
-  Expression* right_;
-
-  Type* combined_type_;
-};
-
-
-class Spread final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Spread)
-
-  Expression* expression() const { return expression_; }
-
-  static int num_ids() { return parent_num_ids(); }
-
- protected:
-  Spread(Zone* zone, Expression* expression, int pos)
-      : Expression(zone, pos), expression_(expression) {}
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* expression_;
-};
-
-
-class Conditional final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Conditional)
-
-  Expression* condition() const { return condition_; }
-  Expression* then_expression() const { return then_expression_; }
-  Expression* else_expression() const { return else_expression_; }
-
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId ThenId() const { return BailoutId(local_id(0)); }
-  BailoutId ElseId() const { return BailoutId(local_id(1)); }
-
- protected:
-  Conditional(Zone* zone, Expression* condition, Expression* then_expression,
-              Expression* else_expression, int position)
-      : Expression(zone, position),
-        condition_(condition),
-        then_expression_(then_expression),
-        else_expression_(else_expression) {}
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  Expression* condition_;
-  Expression* then_expression_;
-  Expression* else_expression_;
-};
-
-
-class Assignment final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Assignment)
-
-  Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
-
-  Token::Value binary_op() const;
-
-  Token::Value op() const { return TokenField::decode(bit_field_); }
-  Expression* target() const { return target_; }
-  Expression* value() const { return value_; }
-  BinaryOperation* binary_operation() const { return binary_operation_; }
-
-  // This check relies on the definition order of token in token.h.
-  bool is_compound() const { return op() > Token::ASSIGN; }
-
-  static int num_ids() { return parent_num_ids() + 2; }
-  BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
-
-  // Type feedback information.
-  TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
-  bool IsMonomorphic() override { return receiver_types_.length() == 1; }
-  bool IsUninitialized() const {
-    return IsUninitializedField::decode(bit_field_);
-  }
-  bool HasNoTypeInformation() {
-    return IsUninitializedField::decode(bit_field_);
-  }
-  SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
-  IcCheckType GetKeyType() const override {
-    return KeyTypeField::decode(bit_field_);
-  }
-  KeyedAccessStoreMode GetStoreMode() const override {
-    return StoreModeField::decode(bit_field_);
-  }
-  void set_is_uninitialized(bool b) {
-    bit_field_ = IsUninitializedField::update(bit_field_, b);
-  }
-  void set_key_type(IcCheckType key_type) {
-    bit_field_ = KeyTypeField::update(bit_field_, key_type);
-  }
-  void set_store_mode(KeyedAccessStoreMode mode) {
-    bit_field_ = StoreModeField::update(bit_field_, mode);
-  }
-
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-  FeedbackVectorSlot AssignmentSlot() const { return slot_; }
-
- protected:
-  Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
-             int pos);
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  class IsUninitializedField : public BitField16<bool, 0, 1> {};
-  class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
-  class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
-  class TokenField : public BitField16<Token::Value, 5, 8> {};
-
-  // Starts with 16-bit field, which should get packed together with
-  // Expression's trailing 16-bit field.
-  uint16_t bit_field_;
-  Expression* target_;
-  Expression* value_;
-  BinaryOperation* binary_operation_;
-  SmallMapList receiver_types_;
-  FeedbackVectorSlot slot_;
-};
-
-
-class Yield final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Yield)
-
-  enum Kind {
-    kInitial,  // The initial yield that returns the unboxed generator object.
-    kSuspend,  // A normal yield: { value: EXPRESSION, done: false }
-    kDelegating,  // A yield*.
-    kFinal        // A return: { value: EXPRESSION, done: true }
-  };
-
-  Expression* generator_object() const { return generator_object_; }
-  Expression* expression() const { return expression_; }
-  Kind yield_kind() const { return yield_kind_; }
-
-  // Type feedback information.
-  bool HasFeedbackSlots() const { return yield_kind() == kDelegating; }
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override {
-    if (HasFeedbackSlots()) {
-      yield_first_feedback_slot_ = spec->AddKeyedLoadICSlot();
-      keyed_load_feedback_slot_ = spec->AddLoadICSlot();
-      done_feedback_slot_ = spec->AddLoadICSlot();
-    }
-  }
-
-  FeedbackVectorSlot KeyedLoadFeedbackSlot() {
-    DCHECK(!HasFeedbackSlots() || !yield_first_feedback_slot_.IsInvalid());
-    return yield_first_feedback_slot_;
-  }
-
-  FeedbackVectorSlot DoneFeedbackSlot() { return keyed_load_feedback_slot_; }
-
-  FeedbackVectorSlot ValueFeedbackSlot() { return done_feedback_slot_; }
-
- protected:
-  Yield(Zone* zone, Expression* generator_object, Expression* expression,
-        Kind yield_kind, int pos)
-      : Expression(zone, pos),
-        generator_object_(generator_object),
-        expression_(expression),
-        yield_kind_(yield_kind) {}
-
- private:
-  Expression* generator_object_;
-  Expression* expression_;
-  Kind yield_kind_;
-  FeedbackVectorSlot yield_first_feedback_slot_;
-  FeedbackVectorSlot keyed_load_feedback_slot_;
-  FeedbackVectorSlot done_feedback_slot_;
-};
-
-
-class Throw final : public Expression {
- public:
-  DECLARE_NODE_TYPE(Throw)
-
-  Expression* exception() const { return exception_; }
-
- protected:
-  Throw(Zone* zone, Expression* exception, int pos)
-      : Expression(zone, pos), exception_(exception) {}
-
- private:
-  Expression* exception_;
-};
-
-
-class FunctionLiteral final : public Expression {
- public:
-  enum FunctionType {
-    ANONYMOUS_EXPRESSION,
-    NAMED_EXPRESSION,
-    DECLARATION
-  };
-
-  enum ParameterFlag {
-    kNoDuplicateParameters = 0,
-    kHasDuplicateParameters = 1
-  };
-
-  enum IsFunctionFlag {
-    kGlobalOrEval,
-    kIsFunction
-  };
-
-  enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
-
-  enum ShouldBeUsedOnceHint { kShouldBeUsedOnce, kDontKnowIfShouldBeUsedOnce };
-
-  enum ArityRestriction {
-    NORMAL_ARITY,
-    GETTER_ARITY,
-    SETTER_ARITY
-  };
-
-  DECLARE_NODE_TYPE(FunctionLiteral)
-
-  Handle<String> name() const { return raw_name_->string(); }
-  const AstRawString* raw_name() const { return raw_name_; }
-  Scope* scope() const { return scope_; }
-  ZoneList<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_expression() const { return IsExpression::decode(bitfield_); }
-  bool is_anonymous() const { return IsAnonymous::decode(bitfield_); }
-  LanguageMode language_mode() const;
-
-  static bool NeedsHomeObject(Expression* expr);
-
-  int materialized_literal_count() { return materialized_literal_count_; }
-  int expected_property_count() { return expected_property_count_; }
-  int parameter_count() { return parameter_count_; }
-
-  bool AllowsLazyCompilation();
-  bool AllowsLazyCompilationWithoutContext();
-
-  Handle<String> debug_name() const {
-    if (raw_name_ != NULL && !raw_name_->IsEmpty()) {
-      return raw_name_->string();
-    }
-    return inferred_name();
-  }
-
-  Handle<String> inferred_name() const {
-    if (!inferred_name_.is_null()) {
-      DCHECK(raw_inferred_name_ == NULL);
-      return inferred_name_;
-    }
-    if (raw_inferred_name_ != NULL) {
-      return raw_inferred_name_->string();
-    }
-    UNREACHABLE();
-    return Handle<String>();
-  }
-
-  // Only one of {set_inferred_name, set_raw_inferred_name} should be called.
-  void set_inferred_name(Handle<String> inferred_name) {
-    DCHECK(!inferred_name.is_null());
-    inferred_name_ = inferred_name;
-    DCHECK(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
-    raw_inferred_name_ = NULL;
-  }
-
-  void set_raw_inferred_name(const AstString* raw_inferred_name) {
-    DCHECK(raw_inferred_name != NULL);
-    raw_inferred_name_ = raw_inferred_name;
-    DCHECK(inferred_name_.is_null());
-    inferred_name_ = Handle<String>();
-  }
-
-  bool pretenure() { return Pretenure::decode(bitfield_); }
-  void set_pretenure() { bitfield_ |= Pretenure::encode(true); }
-
-  bool has_duplicate_parameters() {
-    return HasDuplicateParameters::decode(bitfield_);
-  }
-
-  bool is_function() { return IsFunction::decode(bitfield_) == kIsFunction; }
-
-  // This is used as a heuristic on when to eagerly compile a function
-  // literal. We consider the following constructs as hints that the
-  // function will be called immediately:
-  // - (function() { ... })();
-  // - var x = function() { ... }();
-  bool should_eager_compile() const {
-    return EagerCompileHintBit::decode(bitfield_) == kShouldEagerCompile;
-  }
-  void set_should_eager_compile() {
-    bitfield_ = EagerCompileHintBit::update(bitfield_, kShouldEagerCompile);
-  }
-
-  // A hint that we expect this function to be called (exactly) once,
-  // i.e. we suspect it's an initialization function.
-  bool should_be_used_once_hint() const {
-    return ShouldBeUsedOnceHintBit::decode(bitfield_) == kShouldBeUsedOnce;
-  }
-  void set_should_be_used_once_hint() {
-    bitfield_ = ShouldBeUsedOnceHintBit::update(bitfield_, kShouldBeUsedOnce);
-  }
-
-  FunctionKind kind() const { return FunctionKindBits::decode(bitfield_); }
-
-  int ast_node_count() { return ast_properties_.node_count(); }
-  AstProperties::Flags flags() const { return ast_properties_.flags(); }
-  void set_ast_properties(AstProperties* ast_properties) {
-    ast_properties_ = *ast_properties;
-  }
-  const FeedbackVectorSpec* feedback_vector_spec() const {
-    return ast_properties_.get_spec();
-  }
-  bool dont_optimize() { return dont_optimize_reason_ != kNoReason; }
-  BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
-  void set_dont_optimize_reason(BailoutReason reason) {
-    dont_optimize_reason_ = reason;
-  }
-
- protected:
-  FunctionLiteral(Zone* zone, const AstRawString* name,
-                  AstValueFactory* ast_value_factory, Scope* scope,
-                  ZoneList<Statement*>* body, int materialized_literal_count,
-                  int expected_property_count, int parameter_count,
-                  FunctionType function_type,
-                  ParameterFlag has_duplicate_parameters,
-                  IsFunctionFlag is_function,
-                  EagerCompileHint eager_compile_hint, FunctionKind kind,
-                  int position)
-      : Expression(zone, position),
-        raw_name_(name),
-        scope_(scope),
-        body_(body),
-        raw_inferred_name_(ast_value_factory->empty_string()),
-        ast_properties_(zone),
-        dont_optimize_reason_(kNoReason),
-        materialized_literal_count_(materialized_literal_count),
-        expected_property_count_(expected_property_count),
-        parameter_count_(parameter_count),
-        function_token_position_(RelocInfo::kNoPosition) {
-    bitfield_ = IsExpression::encode(function_type != DECLARATION) |
-                IsAnonymous::encode(function_type == ANONYMOUS_EXPRESSION) |
-                Pretenure::encode(false) |
-                HasDuplicateParameters::encode(has_duplicate_parameters) |
-                IsFunction::encode(is_function) |
-                EagerCompileHintBit::encode(eager_compile_hint) |
-                FunctionKindBits::encode(kind) |
-                ShouldBeUsedOnceHintBit::encode(kDontKnowIfShouldBeUsedOnce);
-    DCHECK(IsValidFunctionKind(kind));
-  }
-
- private:
-  const AstRawString* raw_name_;
-  Handle<String> name_;
-  Scope* scope_;
-  ZoneList<Statement*>* body_;
-  const AstString* raw_inferred_name_;
-  Handle<String> inferred_name_;
-  AstProperties ast_properties_;
-  BailoutReason dont_optimize_reason_;
-
-  int materialized_literal_count_;
-  int expected_property_count_;
-  int parameter_count_;
-  int function_token_position_;
-
-  unsigned bitfield_;
-  class IsExpression : public BitField<bool, 0, 1> {};
-  class IsAnonymous : public BitField<bool, 1, 1> {};
-  class Pretenure : public BitField<bool, 2, 1> {};
-  class HasDuplicateParameters : public BitField<ParameterFlag, 3, 1> {};
-  class IsFunction : public BitField<IsFunctionFlag, 4, 1> {};
-  class EagerCompileHintBit : public BitField<EagerCompileHint, 5, 1> {};
-  class FunctionKindBits : public BitField<FunctionKind, 6, 8> {};
-  class ShouldBeUsedOnceHintBit : public BitField<ShouldBeUsedOnceHint, 15, 1> {
-  };
-};
-
-
-class ClassLiteral final : public Expression {
- public:
-  typedef ObjectLiteralProperty Property;
-
-  DECLARE_NODE_TYPE(ClassLiteral)
-
-  Handle<String> name() const { return raw_name_->string(); }
-  const AstRawString* raw_name() const { return raw_name_; }
-  Scope* scope() const { return scope_; }
-  VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
-  Expression* extends() const { return extends_; }
-  FunctionLiteral* constructor() const { return constructor_; }
-  ZoneList<Property*>* properties() const { return properties_; }
-  int start_position() const { return position(); }
-  int end_position() const { return end_position_; }
-
-  BailoutId EntryId() const { return BailoutId(local_id(0)); }
-  BailoutId DeclsId() const { return BailoutId(local_id(1)); }
-  BailoutId ExitId() { return BailoutId(local_id(2)); }
-  BailoutId CreateLiteralId() const { return BailoutId(local_id(3)); }
-
-  // Return an AST id for a property that is used in simulate instructions.
-  BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 4)); }
-
-  // Unlike other AST nodes, this number of bailout IDs allocated for an
-  // ClassLiteral can vary, so num_ids() is not a static method.
-  int num_ids() const { return parent_num_ids() + 4 + properties()->length(); }
-
-  // Object literals need one feedback slot for each non-trivial value, as well
-  // as some slots for home objects.
-  void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
-                                 FeedbackVectorSlotCache* cache) override;
-
-  bool NeedsProxySlot() const {
-    return class_variable_proxy() != nullptr &&
-           class_variable_proxy()->var()->IsUnallocated();
-  }
-
-  FeedbackVectorSlot ProxySlot() const { return slot_; }
-
- protected:
-  ClassLiteral(Zone* zone, const AstRawString* name, Scope* scope,
-               VariableProxy* class_variable_proxy, Expression* extends,
-               FunctionLiteral* constructor, ZoneList<Property*>* properties,
-               int start_position, int end_position)
-      : Expression(zone, start_position),
-        raw_name_(name),
-        scope_(scope),
-        class_variable_proxy_(class_variable_proxy),
-        extends_(extends),
-        constructor_(constructor),
-        properties_(properties),
-        end_position_(end_position) {}
-
-  static int parent_num_ids() { return Expression::num_ids(); }
-
- private:
-  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
-
-  const AstRawString* raw_name_;
-  Scope* scope_;
-  VariableProxy* class_variable_proxy_;
-  Expression* extends_;
-  FunctionLiteral* constructor_;
-  ZoneList<Property*>* properties_;
-  int end_position_;
-  FeedbackVectorSlot slot_;
-};
-
-
-class NativeFunctionLiteral final : public Expression {
- public:
-  DECLARE_NODE_TYPE(NativeFunctionLiteral)
-
-  Handle<String> name() const { return name_->string(); }
-  v8::Extension* extension() const { return extension_; }
-
- protected:
-  NativeFunctionLiteral(Zone* zone, const AstRawString* name,
-                        v8::Extension* extension, int pos)
-      : Expression(zone, pos), name_(name), extension_(extension) {}
-
- private:
-  const AstRawString* name_;
-  v8::Extension* extension_;
-};
-
-
-class ThisFunction final : public Expression {
- public:
-  DECLARE_NODE_TYPE(ThisFunction)
-
- protected:
-  ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
-};
-
-
-class SuperPropertyReference final : public Expression {
- public:
-  DECLARE_NODE_TYPE(SuperPropertyReference)
-
-  VariableProxy* this_var() const { return this_var_; }
-  Expression* home_object() const { return home_object_; }
-
- protected:
-  SuperPropertyReference(Zone* zone, VariableProxy* this_var,
-                         Expression* home_object, int pos)
-      : Expression(zone, pos), this_var_(this_var), home_object_(home_object) {
-    DCHECK(this_var->is_this());
-    DCHECK(home_object->IsProperty());
-  }
-
- private:
-  VariableProxy* this_var_;
-  Expression* home_object_;
-};
-
-
-class SuperCallReference final : public Expression {
- public:
-  DECLARE_NODE_TYPE(SuperCallReference)
-
-  VariableProxy* this_var() const { return this_var_; }
-  VariableProxy* new_target_var() const { return new_target_var_; }
-  VariableProxy* this_function_var() const { return this_function_var_; }
-
- protected:
-  SuperCallReference(Zone* zone, VariableProxy* this_var,
-                     VariableProxy* new_target_var,
-                     VariableProxy* this_function_var, int pos)
-      : Expression(zone, pos),
-        this_var_(this_var),
-        new_target_var_(new_target_var),
-        this_function_var_(this_function_var) {
-    DCHECK(this_var->is_this());
-    DCHECK(new_target_var->raw_name()->IsOneByteEqualTo(".new.target"));
-    DCHECK(this_function_var->raw_name()->IsOneByteEqualTo(".this_function"));
-  }
-
- private:
-  VariableProxy* this_var_;
-  VariableProxy* new_target_var_;
-  VariableProxy* this_function_var_;
-};
-
-
-// This class is produced when parsing the () in arrow functions without any
-// arguments and is not actually a valid expression.
-class EmptyParentheses final : public Expression {
- public:
-  DECLARE_NODE_TYPE(EmptyParentheses)
-
- private:
-  EmptyParentheses(Zone* zone, int pos) : Expression(zone, pos) {}
-};
-
-
-#undef DECLARE_NODE_TYPE
-
-
-// ----------------------------------------------------------------------------
-// Regular expressions
-
-
-class RegExpVisitor BASE_EMBEDDED {
- public:
-  virtual ~RegExpVisitor() { }
-#define MAKE_CASE(Name)                                              \
-  virtual void* Visit##Name(RegExp##Name*, void* data) = 0;
-  FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
-#undef MAKE_CASE
-};
-
-
-class RegExpTree : public ZoneObject {
- public:
-  static const int kInfinity = kMaxInt;
-  virtual ~RegExpTree() {}
-  virtual void* Accept(RegExpVisitor* visitor, void* data) = 0;
-  virtual RegExpNode* ToNode(RegExpCompiler* compiler,
-                             RegExpNode* on_success) = 0;
-  virtual bool IsTextElement() { return false; }
-  virtual bool IsAnchoredAtStart() { return false; }
-  virtual bool IsAnchoredAtEnd() { return false; }
-  virtual int min_match() = 0;
-  virtual int max_match() = 0;
-  // Returns the interval of registers used for captures within this
-  // expression.
-  virtual Interval CaptureRegisters() { return Interval::Empty(); }
-  virtual void AppendToText(RegExpText* text, Zone* zone);
-  std::ostream& Print(std::ostream& os, Zone* zone);  // NOLINT
-#define MAKE_ASTYPE(Name)                                                  \
-  virtual RegExp##Name* As##Name();                                        \
-  virtual bool Is##Name();
-  FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ASTYPE)
-#undef MAKE_ASTYPE
-};
-
-
-class RegExpDisjunction final : public RegExpTree {
- public:
-  explicit RegExpDisjunction(ZoneList<RegExpTree*>* alternatives);
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpDisjunction* AsDisjunction() override;
-  Interval CaptureRegisters() override;
-  bool IsDisjunction() override;
-  bool IsAnchoredAtStart() override;
-  bool IsAnchoredAtEnd() override;
-  int min_match() override { return min_match_; }
-  int max_match() override { return max_match_; }
-  ZoneList<RegExpTree*>* alternatives() { return alternatives_; }
- private:
-  bool SortConsecutiveAtoms(RegExpCompiler* compiler);
-  void RationalizeConsecutiveAtoms(RegExpCompiler* compiler);
-  void FixSingleCharacterDisjunctions(RegExpCompiler* compiler);
-  ZoneList<RegExpTree*>* alternatives_;
-  int min_match_;
-  int max_match_;
-};
-
-
-class RegExpAlternative final : public RegExpTree {
- public:
-  explicit RegExpAlternative(ZoneList<RegExpTree*>* nodes);
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpAlternative* AsAlternative() override;
-  Interval CaptureRegisters() override;
-  bool IsAlternative() override;
-  bool IsAnchoredAtStart() override;
-  bool IsAnchoredAtEnd() override;
-  int min_match() override { return min_match_; }
-  int max_match() override { return max_match_; }
-  ZoneList<RegExpTree*>* nodes() { return nodes_; }
- private:
-  ZoneList<RegExpTree*>* nodes_;
-  int min_match_;
-  int max_match_;
-};
-
-
-class RegExpAssertion final : public RegExpTree {
- public:
-  enum AssertionType {
-    START_OF_LINE,
-    START_OF_INPUT,
-    END_OF_LINE,
-    END_OF_INPUT,
-    BOUNDARY,
-    NON_BOUNDARY
-  };
-  explicit RegExpAssertion(AssertionType type) : assertion_type_(type) { }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpAssertion* AsAssertion() override;
-  bool IsAssertion() override;
-  bool IsAnchoredAtStart() override;
-  bool IsAnchoredAtEnd() override;
-  int min_match() override { return 0; }
-  int max_match() override { return 0; }
-  AssertionType assertion_type() { return assertion_type_; }
- private:
-  AssertionType assertion_type_;
-};
-
-
-class CharacterSet final BASE_EMBEDDED {
- public:
-  explicit CharacterSet(uc16 standard_set_type)
-      : ranges_(NULL),
-        standard_set_type_(standard_set_type) {}
-  explicit CharacterSet(ZoneList<CharacterRange>* ranges)
-      : ranges_(ranges),
-        standard_set_type_(0) {}
-  ZoneList<CharacterRange>* ranges(Zone* zone);
-  uc16 standard_set_type() { return standard_set_type_; }
-  void set_standard_set_type(uc16 special_set_type) {
-    standard_set_type_ = special_set_type;
-  }
-  bool is_standard() { return standard_set_type_ != 0; }
-  void Canonicalize();
- private:
-  ZoneList<CharacterRange>* ranges_;
-  // If non-zero, the value represents a standard set (e.g., all whitespace
-  // characters) without having to expand the ranges.
-  uc16 standard_set_type_;
-};
-
-
-class RegExpCharacterClass final : public RegExpTree {
- public:
-  RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
-      : set_(ranges),
-        is_negated_(is_negated) { }
-  explicit RegExpCharacterClass(uc16 type)
-      : set_(type),
-        is_negated_(false) { }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpCharacterClass* AsCharacterClass() override;
-  bool IsCharacterClass() override;
-  bool IsTextElement() override { return true; }
-  int min_match() override { return 1; }
-  int max_match() override { return 1; }
-  void AppendToText(RegExpText* text, Zone* zone) override;
-  CharacterSet character_set() { return set_; }
-  // TODO(lrn): Remove need for complex version if is_standard that
-  // recognizes a mangled standard set and just do { return set_.is_special(); }
-  bool is_standard(Zone* zone);
-  // Returns a value representing the standard character set if is_standard()
-  // returns true.
-  // Currently used values are:
-  // s : unicode whitespace
-  // S : unicode non-whitespace
-  // w : ASCII word character (digit, letter, underscore)
-  // W : non-ASCII word character
-  // d : ASCII digit
-  // D : non-ASCII digit
-  // . : non-unicode non-newline
-  // * : All characters
-  uc16 standard_type() { return set_.standard_set_type(); }
-  ZoneList<CharacterRange>* ranges(Zone* zone) { return set_.ranges(zone); }
-  bool is_negated() { return is_negated_; }
-
- private:
-  CharacterSet set_;
-  bool is_negated_;
-};
-
-
-class RegExpAtom final : public RegExpTree {
- public:
-  explicit RegExpAtom(Vector<const uc16> data) : data_(data) { }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpAtom* AsAtom() override;
-  bool IsAtom() override;
-  bool IsTextElement() override { return true; }
-  int min_match() override { return data_.length(); }
-  int max_match() override { return data_.length(); }
-  void AppendToText(RegExpText* text, Zone* zone) override;
-  Vector<const uc16> data() { return data_; }
-  int length() { return data_.length(); }
- private:
-  Vector<const uc16> data_;
-};
-
-
-class RegExpText final : public RegExpTree {
- public:
-  explicit RegExpText(Zone* zone) : elements_(2, zone), length_(0) {}
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpText* AsText() override;
-  bool IsText() override;
-  bool IsTextElement() override { return true; }
-  int min_match() override { return length_; }
-  int max_match() override { return length_; }
-  void AppendToText(RegExpText* text, Zone* zone) override;
-  void AddElement(TextElement elm, Zone* zone)  {
-    elements_.Add(elm, zone);
-    length_ += elm.length();
-  }
-  ZoneList<TextElement>* elements() { return &elements_; }
- private:
-  ZoneList<TextElement> elements_;
-  int length_;
-};
-
-
-class RegExpQuantifier final : public RegExpTree {
- public:
-  enum QuantifierType { GREEDY, NON_GREEDY, POSSESSIVE };
-  RegExpQuantifier(int min, int max, QuantifierType type, RegExpTree* body)
-      : body_(body),
-        min_(min),
-        max_(max),
-        min_match_(min * body->min_match()),
-        quantifier_type_(type) {
-    if (max > 0 && body->max_match() > kInfinity / max) {
-      max_match_ = kInfinity;
-    } else {
-      max_match_ = max * body->max_match();
-    }
-  }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  static RegExpNode* ToNode(int min,
-                            int max,
-                            bool is_greedy,
-                            RegExpTree* body,
-                            RegExpCompiler* compiler,
-                            RegExpNode* on_success,
-                            bool not_at_start = false);
-  RegExpQuantifier* AsQuantifier() override;
-  Interval CaptureRegisters() override;
-  bool IsQuantifier() override;
-  int min_match() override { return min_match_; }
-  int max_match() override { return max_match_; }
-  int min() { return min_; }
-  int max() { return max_; }
-  bool is_possessive() { return quantifier_type_ == POSSESSIVE; }
-  bool is_non_greedy() { return quantifier_type_ == NON_GREEDY; }
-  bool is_greedy() { return quantifier_type_ == GREEDY; }
-  RegExpTree* body() { return body_; }
-
- private:
-  RegExpTree* body_;
-  int min_;
-  int max_;
-  int min_match_;
-  int max_match_;
-  QuantifierType quantifier_type_;
-};
-
-
-class RegExpCapture final : public RegExpTree {
- public:
-  explicit RegExpCapture(int index) : body_(NULL), index_(index) {}
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  static RegExpNode* ToNode(RegExpTree* body,
-                            int index,
-                            RegExpCompiler* compiler,
-                            RegExpNode* on_success);
-  RegExpCapture* AsCapture() override;
-  bool IsAnchoredAtStart() override;
-  bool IsAnchoredAtEnd() override;
-  Interval CaptureRegisters() override;
-  bool IsCapture() override;
-  int min_match() override { return body_->min_match(); }
-  int max_match() override { return body_->max_match(); }
-  RegExpTree* body() { return body_; }
-  void set_body(RegExpTree* body) { body_ = body; }
-  int index() { return index_; }
-  static int StartRegister(int index) { return index * 2; }
-  static int EndRegister(int index) { return index * 2 + 1; }
-
- private:
-  RegExpTree* body_;
-  int index_;
-};
-
-
-class RegExpLookaround final : public RegExpTree {
- public:
-  enum Type { LOOKAHEAD, LOOKBEHIND };
-
-  RegExpLookaround(RegExpTree* body, bool is_positive, int capture_count,
-                   int capture_from, Type type)
-      : body_(body),
-        is_positive_(is_positive),
-        capture_count_(capture_count),
-        capture_from_(capture_from),
-        type_(type) {}
-
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpLookaround* AsLookaround() override;
-  Interval CaptureRegisters() override;
-  bool IsLookaround() override;
-  bool IsAnchoredAtStart() override;
-  int min_match() override { return 0; }
-  int max_match() override { return 0; }
-  RegExpTree* body() { return body_; }
-  bool is_positive() { return is_positive_; }
-  int capture_count() { return capture_count_; }
-  int capture_from() { return capture_from_; }
-  Type type() { return type_; }
-
- private:
-  RegExpTree* body_;
-  bool is_positive_;
-  int capture_count_;
-  int capture_from_;
-  Type type_;
-};
-
-
-class RegExpBackReference final : public RegExpTree {
- public:
-  explicit RegExpBackReference(RegExpCapture* capture)
-      : capture_(capture) { }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpBackReference* AsBackReference() override;
-  bool IsBackReference() override;
-  int min_match() override { return 0; }
-  // The capture may not be completely parsed yet, if the reference occurs
-  // before the capture. In the ordinary case, nothing has been captured yet,
-  // so the back reference must have the length 0. If the back reference is
-  // inside a lookbehind, effectively making it a forward reference, we return
-  // 0 since lookbehinds have a length of 0.
-  int max_match() override {
-    return capture_->body() ? capture_->max_match() : 0;
-  }
-  int index() { return capture_->index(); }
-  RegExpCapture* capture() { return capture_; }
- private:
-  RegExpCapture* capture_;
-};
-
-
-class RegExpEmpty final : public RegExpTree {
- public:
-  RegExpEmpty() { }
-  void* Accept(RegExpVisitor* visitor, void* data) override;
-  RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  RegExpEmpty* AsEmpty() override;
-  bool IsEmpty() override;
-  int min_match() override { return 0; }
-  int max_match() override { return 0; }
-};
-
-
-// ----------------------------------------------------------------------------
-// Basic visitor
-// - leaf node visitors are abstract.
-
-class AstVisitor BASE_EMBEDDED {
- public:
-  AstVisitor() {}
-  virtual ~AstVisitor() {}
-
-  // Stack overflow check and dynamic dispatch.
-  virtual void Visit(AstNode* node) = 0;
-
-  // Iteration left-to-right.
-  virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
-  virtual void VisitStatements(ZoneList<Statement*>* statements);
-  virtual void VisitExpressions(ZoneList<Expression*>* expressions);
-
-  // Individual AST nodes.
-#define DEF_VISIT(type)                         \
-  virtual void Visit##type(type* node) = 0;
-  AST_NODE_LIST(DEF_VISIT)
-#undef DEF_VISIT
-};
-
-
-#define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
- public:                                                    \
-  void Visit(AstNode* node) final {                         \
-    if (!CheckStackOverflow()) node->Accept(this);          \
-  }                                                         \
-                                                            \
-  void SetStackOverflow() { stack_overflow_ = true; }       \
-  void ClearStackOverflow() { stack_overflow_ = false; }    \
-  bool HasStackOverflow() const { return stack_overflow_; } \
-                                                            \
-  bool CheckStackOverflow() {                               \
-    if (stack_overflow_) return true;                       \
-    if (GetCurrentStackPosition() < stack_limit_) {         \
-      stack_overflow_ = true;                               \
-      return true;                                          \
-    }                                                       \
-    return false;                                           \
-  }                                                         \
-                                                            \
- private:                                                   \
-  void InitializeAstVisitor(Isolate* isolate) {             \
-    stack_limit_ = isolate->stack_guard()->real_climit();   \
-    stack_overflow_ = false;                                \
-  }                                                         \
-                                                            \
-  void InitializeAstVisitor(uintptr_t stack_limit) {        \
-    stack_limit_ = stack_limit;                             \
-    stack_overflow_ = false;                                \
-  }                                                         \
-                                                            \
-  uintptr_t stack_limit_;                                   \
-  bool stack_overflow_
-
-
-// ----------------------------------------------------------------------------
-// AstNode factory
-
-class AstNodeFactory final BASE_EMBEDDED {
- public:
-  explicit AstNodeFactory(AstValueFactory* ast_value_factory)
-      : local_zone_(ast_value_factory->zone()),
-        parser_zone_(ast_value_factory->zone()),
-        ast_value_factory_(ast_value_factory) {}
-
-  AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
-
-  VariableDeclaration* NewVariableDeclaration(
-      VariableProxy* proxy, VariableMode mode, Scope* scope, int pos,
-      bool is_class_declaration = false, int declaration_group_start = -1) {
-    return new (parser_zone_)
-        VariableDeclaration(parser_zone_, proxy, mode, scope, pos,
-                            is_class_declaration, declaration_group_start);
-  }
-
-  FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
-                                              VariableMode mode,
-                                              FunctionLiteral* fun,
-                                              Scope* scope,
-                                              int pos) {
-    return new (parser_zone_)
-        FunctionDeclaration(parser_zone_, proxy, mode, fun, scope, pos);
-  }
-
-  ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,
-                                          const AstRawString* import_name,
-                                          const AstRawString* module_specifier,
-                                          Scope* scope, int pos) {
-    return new (parser_zone_) ImportDeclaration(
-        parser_zone_, proxy, import_name, module_specifier, scope, pos);
-  }
-
-  ExportDeclaration* NewExportDeclaration(VariableProxy* proxy,
-                                          Scope* scope,
-                                          int pos) {
-    return new (parser_zone_)
-        ExportDeclaration(parser_zone_, proxy, scope, pos);
-  }
-
-  Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
-                  bool ignore_completion_value, int pos) {
-    return new (local_zone_)
-        Block(local_zone_, labels, capacity, ignore_completion_value, pos);
-  }
-
-#define STATEMENT_WITH_LABELS(NodeType)                                     \
-  NodeType* New##NodeType(ZoneList<const AstRawString*>* labels, int pos) { \
-    return new (local_zone_) NodeType(local_zone_, labels, pos);            \
-  }
-  STATEMENT_WITH_LABELS(DoWhileStatement)
-  STATEMENT_WITH_LABELS(WhileStatement)
-  STATEMENT_WITH_LABELS(ForStatement)
-  STATEMENT_WITH_LABELS(SwitchStatement)
-#undef STATEMENT_WITH_LABELS
-
-  ForEachStatement* NewForEachStatement(ForEachStatement::VisitMode visit_mode,
-                                        ZoneList<const AstRawString*>* labels,
-                                        int pos) {
-    switch (visit_mode) {
-      case ForEachStatement::ENUMERATE: {
-        return new (local_zone_) ForInStatement(local_zone_, labels, pos);
-      }
-      case ForEachStatement::ITERATE: {
-        return new (local_zone_) ForOfStatement(local_zone_, labels, pos);
-      }
-    }
-    UNREACHABLE();
-    return NULL;
-  }
-
-  ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
-    return new (local_zone_) ExpressionStatement(local_zone_, expression, pos);
-  }
-
-  ContinueStatement* NewContinueStatement(IterationStatement* target, int pos) {
-    return new (local_zone_) ContinueStatement(local_zone_, target, pos);
-  }
-
-  BreakStatement* NewBreakStatement(BreakableStatement* target, int pos) {
-    return new (local_zone_) BreakStatement(local_zone_, target, pos);
-  }
-
-  ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
-    return new (local_zone_) ReturnStatement(local_zone_, expression, pos);
-  }
-
-  WithStatement* NewWithStatement(Scope* scope,
-                                  Expression* expression,
-                                  Statement* statement,
-                                  int pos) {
-    return new (local_zone_)
-        WithStatement(local_zone_, scope, expression, statement, pos);
-  }
-
-  IfStatement* NewIfStatement(Expression* condition,
-                              Statement* then_statement,
-                              Statement* else_statement,
-                              int pos) {
-    return new (local_zone_) IfStatement(local_zone_, condition, then_statement,
-                                         else_statement, pos);
-  }
-
-  TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
-                                          Variable* variable,
-                                          Block* catch_block, int pos) {
-    return new (local_zone_) TryCatchStatement(local_zone_, try_block, scope,
-                                               variable, catch_block, pos);
-  }
-
-  TryFinallyStatement* NewTryFinallyStatement(Block* try_block,
-                                              Block* finally_block, int pos) {
-    return new (local_zone_)
-        TryFinallyStatement(local_zone_, try_block, finally_block, pos);
-  }
-
-  DebuggerStatement* NewDebuggerStatement(int pos) {
-    return new (local_zone_) DebuggerStatement(local_zone_, pos);
-  }
-
-  EmptyStatement* NewEmptyStatement(int pos) {
-    return new (local_zone_) EmptyStatement(local_zone_, pos);
-  }
-
-  SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(
-      Statement* statement, Scope* scope) {
-    return new (local_zone_)
-        SloppyBlockFunctionStatement(local_zone_, statement, scope);
-  }
-
-  CaseClause* NewCaseClause(
-      Expression* label, ZoneList<Statement*>* statements, int pos) {
-    return new (local_zone_) CaseClause(local_zone_, label, statements, pos);
-  }
-
-  Literal* NewStringLiteral(const AstRawString* string, int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewString(string), pos);
-  }
-
-  // A JavaScript symbol (ECMA-262 edition 6).
-  Literal* NewSymbolLiteral(const char* name, int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewSymbol(name), pos);
-  }
-
-  Literal* NewNumberLiteral(double number, int pos, bool with_dot = false) {
-    return new (local_zone_) Literal(
-        local_zone_, ast_value_factory_->NewNumber(number, with_dot), pos);
-  }
-
-  Literal* NewSmiLiteral(int number, int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewSmi(number), pos);
-  }
-
-  Literal* NewBooleanLiteral(bool b, int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewBoolean(b), pos);
-  }
-
-  Literal* NewNullLiteral(int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewNull(), pos);
-  }
-
-  Literal* NewUndefinedLiteral(int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewUndefined(), pos);
-  }
-
-  Literal* NewTheHoleLiteral(int pos) {
-    return new (local_zone_)
-        Literal(local_zone_, ast_value_factory_->NewTheHole(), pos);
-  }
-
-  ObjectLiteral* NewObjectLiteral(
-      ZoneList<ObjectLiteral::Property*>* properties,
-      int literal_index,
-      int boilerplate_properties,
-      bool has_function,
-      bool is_strong,
-      int pos) {
-    return new (local_zone_)
-        ObjectLiteral(local_zone_, properties, literal_index,
-                      boilerplate_properties, has_function, is_strong, pos);
-  }
-
-  ObjectLiteral::Property* NewObjectLiteralProperty(
-      Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
-      bool is_static, bool is_computed_name) {
-    return new (local_zone_)
-        ObjectLiteral::Property(key, value, kind, is_static, is_computed_name);
-  }
-
-  ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
-                                                    Expression* value,
-                                                    bool is_static,
-                                                    bool is_computed_name) {
-    return new (local_zone_) ObjectLiteral::Property(
-        ast_value_factory_, key, value, is_static, is_computed_name);
-  }
-
-  RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern, int flags,
-                                  int literal_index, bool is_strong, int pos) {
-    return new (local_zone_) RegExpLiteral(local_zone_, pattern, flags,
-                                           literal_index, is_strong, pos);
-  }
-
-  ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
-                                int literal_index,
-                                bool is_strong,
-                                int pos) {
-    return new (local_zone_)
-        ArrayLiteral(local_zone_, values, -1, literal_index, is_strong, pos);
-  }
-
-  ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
-                                int first_spread_index, int literal_index,
-                                bool is_strong, int pos) {
-    return new (local_zone_) ArrayLiteral(
-        local_zone_, values, first_spread_index, literal_index, is_strong, pos);
-  }
-
-  VariableProxy* NewVariableProxy(Variable* var,
-                                  int start_position = RelocInfo::kNoPosition,
-                                  int end_position = RelocInfo::kNoPosition) {
-    return new (parser_zone_)
-        VariableProxy(parser_zone_, var, start_position, end_position);
-  }
-
-  VariableProxy* NewVariableProxy(const AstRawString* name,
-                                  Variable::Kind variable_kind,
-                                  int start_position = RelocInfo::kNoPosition,
-                                  int end_position = RelocInfo::kNoPosition) {
-    DCHECK_NOT_NULL(name);
-    return new (parser_zone_) VariableProxy(parser_zone_, name, variable_kind,
-                                            start_position, end_position);
-  }
-
-  Property* NewProperty(Expression* obj, Expression* key, int pos) {
-    return new (local_zone_) Property(local_zone_, obj, key, pos);
-  }
-
-  Call* NewCall(Expression* expression,
-                ZoneList<Expression*>* arguments,
-                int pos) {
-    return new (local_zone_) Call(local_zone_, expression, arguments, pos);
-  }
-
-  CallNew* NewCallNew(Expression* expression,
-                      ZoneList<Expression*>* arguments,
-                      int pos) {
-    return new (local_zone_) CallNew(local_zone_, expression, arguments, pos);
-  }
-
-  CallRuntime* NewCallRuntime(Runtime::FunctionId id,
-                              ZoneList<Expression*>* arguments, int pos) {
-    return new (local_zone_)
-        CallRuntime(local_zone_, Runtime::FunctionForId(id), arguments, pos);
-  }
-
-  CallRuntime* NewCallRuntime(const Runtime::Function* function,
-                              ZoneList<Expression*>* arguments, int pos) {
-    return new (local_zone_) CallRuntime(local_zone_, function, arguments, pos);
-  }
-
-  CallRuntime* NewCallRuntime(int context_index,
-                              ZoneList<Expression*>* arguments, int pos) {
-    return new (local_zone_)
-        CallRuntime(local_zone_, context_index, arguments, pos);
-  }
-
-  UnaryOperation* NewUnaryOperation(Token::Value op,
-                                    Expression* expression,
-                                    int pos) {
-    return new (local_zone_) UnaryOperation(local_zone_, op, expression, pos);
-  }
-
-  BinaryOperation* NewBinaryOperation(Token::Value op,
-                                      Expression* left,
-                                      Expression* right,
-                                      int pos) {
-    return new (local_zone_) BinaryOperation(local_zone_, op, left, right, pos);
-  }
-
-  CountOperation* NewCountOperation(Token::Value op,
-                                    bool is_prefix,
-                                    Expression* expr,
-                                    int pos) {
-    return new (local_zone_)
-        CountOperation(local_zone_, op, is_prefix, expr, pos);
-  }
-
-  CompareOperation* NewCompareOperation(Token::Value op,
-                                        Expression* left,
-                                        Expression* right,
-                                        int pos) {
-    return new (local_zone_)
-        CompareOperation(local_zone_, op, left, right, pos);
-  }
-
-  Spread* NewSpread(Expression* expression, int pos) {
-    return new (local_zone_) Spread(local_zone_, expression, pos);
-  }
-
-  Conditional* NewConditional(Expression* condition,
-                              Expression* then_expression,
-                              Expression* else_expression,
-                              int position) {
-    return new (local_zone_) Conditional(
-        local_zone_, condition, then_expression, else_expression, position);
-  }
-
-  Assignment* NewAssignment(Token::Value op,
-                            Expression* target,
-                            Expression* value,
-                            int pos) {
-    DCHECK(Token::IsAssignmentOp(op));
-    Assignment* assign =
-        new (local_zone_) Assignment(local_zone_, op, target, value, pos);
-    if (assign->is_compound()) {
-      DCHECK(Token::IsAssignmentOp(op));
-      assign->binary_operation_ =
-          NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
-    }
-    return assign;
-  }
-
-  Yield* NewYield(Expression *generator_object,
-                  Expression* expression,
-                  Yield::Kind yield_kind,
-                  int pos) {
-    if (!expression) expression = NewUndefinedLiteral(pos);
-    return new (local_zone_)
-        Yield(local_zone_, generator_object, expression, yield_kind, pos);
-  }
-
-  Throw* NewThrow(Expression* exception, int pos) {
-    return new (local_zone_) Throw(local_zone_, exception, pos);
-  }
-
-  FunctionLiteral* NewFunctionLiteral(
-      const AstRawString* name, AstValueFactory* ast_value_factory,
-      Scope* scope, ZoneList<Statement*>* body, int materialized_literal_count,
-      int expected_property_count, int parameter_count,
-      FunctionLiteral::ParameterFlag has_duplicate_parameters,
-      FunctionLiteral::FunctionType function_type,
-      FunctionLiteral::IsFunctionFlag is_function,
-      FunctionLiteral::EagerCompileHint eager_compile_hint, FunctionKind kind,
-      int position) {
-    return new (parser_zone_) FunctionLiteral(
-        parser_zone_, name, ast_value_factory, scope, body,
-        materialized_literal_count, expected_property_count, parameter_count,
-        function_type, has_duplicate_parameters, is_function,
-        eager_compile_hint, kind, position);
-  }
-
-  ClassLiteral* NewClassLiteral(const AstRawString* name, Scope* scope,
-                                VariableProxy* proxy, Expression* extends,
-                                FunctionLiteral* constructor,
-                                ZoneList<ObjectLiteral::Property*>* properties,
-                                int start_position, int end_position) {
-    return new (parser_zone_)
-        ClassLiteral(parser_zone_, name, scope, proxy, extends, constructor,
-                     properties, start_position, end_position);
-  }
-
-  NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
-                                                  v8::Extension* extension,
-                                                  int pos) {
-    return new (parser_zone_)
-        NativeFunctionLiteral(parser_zone_, name, extension, pos);
-  }
-
-  DoExpression* NewDoExpression(Block* block, Variable* result_var, int pos) {
-    VariableProxy* result = NewVariableProxy(result_var, pos);
-    return new (parser_zone_) DoExpression(parser_zone_, block, result, pos);
-  }
-
-  ThisFunction* NewThisFunction(int pos) {
-    return new (local_zone_) ThisFunction(local_zone_, pos);
-  }
-
-  SuperPropertyReference* NewSuperPropertyReference(VariableProxy* this_var,
-                                                    Expression* home_object,
-                                                    int pos) {
-    return new (parser_zone_)
-        SuperPropertyReference(parser_zone_, this_var, home_object, pos);
-  }
-
-  SuperCallReference* NewSuperCallReference(VariableProxy* this_var,
-                                            VariableProxy* new_target_var,
-                                            VariableProxy* this_function_var,
-                                            int pos) {
-    return new (parser_zone_) SuperCallReference(
-        parser_zone_, this_var, new_target_var, this_function_var, pos);
-  }
-
-  EmptyParentheses* NewEmptyParentheses(int pos) {
-    return new (local_zone_) EmptyParentheses(local_zone_, pos);
-  }
-
-  Zone* zone() const { return local_zone_; }
-
-  // Handles use of temporary zones when parsing inner function bodies.
-  class BodyScope {
-   public:
-    BodyScope(AstNodeFactory* factory, Zone* temp_zone, bool use_temp_zone)
-        : factory_(factory), prev_zone_(factory->local_zone_) {
-      if (use_temp_zone) {
-        factory->local_zone_ = temp_zone;
-      }
-    }
-
-    ~BodyScope() { factory_->local_zone_ = prev_zone_; }
-
-   private:
-    AstNodeFactory* factory_;
-    Zone* prev_zone_;
-  };
-
- private:
-  // This zone may be deallocated upon returning from parsing a function body
-  // which we can guarantee is not going to be compiled or have its AST
-  // inspected.
-  // See ParseFunctionLiteral in parser.cc for preconditions.
-  Zone* local_zone_;
-  // ZoneObjects which need to persist until scope analysis must be allocated in
-  // the parser-level zone.
-  Zone* parser_zone_;
-  AstValueFactory* ast_value_factory_;
-};
-
-
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_AST_H_