src/ast.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_AST_H_
   6 #define V8_AST_H_
   7
   8 #include "src/assembler.h"
   9 #include "src/ast-value-factory.h"
  10 #include "src/bailout-reason.h"
  11 #include "src/base/flags.h"
  12 #include "src/base/smart-pointers.h"
  13 #include "src/factory.h"
  14 #include "src/isolate.h"
  15 #include "src/list.h"
  16 #include "src/modules.h"
  17 #include "src/regexp/jsregexp.h"
  18 #include "src/runtime/runtime.h"
  19 #include "src/small-pointer-list.h"
  20 #include "src/token.h"
  21 #include "src/types.h"
  22 #include "src/utils.h"
  23 #include "src/variables.h"
  24
  25 namespace v8 {
  26 namespace internal {
  27
  28 // The abstract syntax tree is an intermediate, light-weight
  29 // representation of the parsed JavaScript code suitable for
  30 // compilation to native code.
  31
  32 // Nodes are allocated in a separate zone, which allows faster
  33 // allocation and constant-time deallocation of the entire syntax
  34 // tree.
  35
  36
  37 // ----------------------------------------------------------------------------
  38 // Nodes of the abstract syntax tree. Only concrete classes are
  39 // enumerated here.
  40
  41 #define DECLARATION_NODE_LIST(V) \
  42   V(VariableDeclaration)         \
  43   V(FunctionDeclaration)         \
  44   V(ImportDeclaration)           \
  45   V(ExportDeclaration)
  46
  47 #define STATEMENT_NODE_LIST(V)    \
  48   V(Block)                        \
  49   V(ExpressionStatement)          \
  50   V(EmptyStatement)               \
  51   V(SloppyBlockFunctionStatement) \
  52   V(IfStatement)                  \
  53   V(ContinueStatement)            \
  54   V(BreakStatement)               \
  55   V(ReturnStatement)              \
  56   V(WithStatement)                \
  57   V(SwitchStatement)              \
  58   V(DoWhileStatement)             \
  59   V(WhileStatement)               \
  60   V(ForStatement)                 \
  61   V(ForInStatement)               \
  62   V(ForOfStatement)               \
  63   V(TryCatchStatement)            \
  64   V(TryFinallyStatement)          \
  65   V(DebuggerStatement)
  66
  67 #define EXPRESSION_NODE_LIST(V) \
  68   V(FunctionLiteral)            \
  69   V(ClassLiteral)               \
  70   V(NativeFunctionLiteral)      \
  71   V(Conditional)                \
  72   V(VariableProxy)              \
  73   V(Literal)                    \
  74   V(RegExpLiteral)              \
  75   V(ObjectLiteral)              \
  76   V(ArrayLiteral)               \
  77   V(Assignment)                 \
  78   V(Yield)                      \
  79   V(Throw)                      \
  80   V(Property)                   \
  81   V(Call)                       \
  82   V(CallNew)                    \
  83   V(CallRuntime)                \
  84   V(UnaryOperation)             \
  85   V(CountOperation)             \
  86   V(BinaryOperation)            \
  87   V(CompareOperation)           \
  88   V(Spread)                     \
  89   V(ThisFunction)               \
  90   V(SuperPropertyReference)     \
  91   V(SuperCallReference)         \
  92   V(CaseClause)                 \
  93   V(EmptyParentheses)
  94
  95 #define AST_NODE_LIST(V)                        \
  96   DECLARATION_NODE_LIST(V)                      \
  97   STATEMENT_NODE_LIST(V)                        \
  98   EXPRESSION_NODE_LIST(V)
  99
 100 // Forward declarations
 101 class AstNodeFactory;
 102 class AstVisitor;
 103 class Declaration;
 104 class Module;
 105 class BreakableStatement;
 106 class Expression;
 107 class IterationStatement;
 108 class MaterializedLiteral;
 109 class Statement;
 110 class TypeFeedbackOracle;
 111
 112 class RegExpAlternative;
 113 class RegExpAssertion;
 114 class RegExpAtom;
 115 class RegExpBackReference;
 116 class RegExpCapture;
 117 class RegExpCharacterClass;
 118 class RegExpCompiler;
 119 class RegExpDisjunction;
 120 class RegExpEmpty;
 121 class RegExpLookahead;
 122 class RegExpQuantifier;
 123 class RegExpText;
 124
 125 #define DEF_FORWARD_DECLARATION(type) class type;
 126 AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 127 #undef DEF_FORWARD_DECLARATION
 128
 129
 130 // Typedef only introduced to avoid unreadable code.
 131 typedef ZoneList<Handle<String>> ZoneStringList;
 132 typedef ZoneList<Handle<Object>> ZoneObjectList;
 133
 134
 135 #define DECLARE_NODE_TYPE(type)                                          \
 136   void Accept(AstVisitor* v) override;                                   \
 137   AstNode::NodeType node_type() const final { return AstNode::k##type; } \
 138   friend class AstNodeFactory;
 139
 140
 141 class ICSlotCache {
 142  public:
 143   explicit ICSlotCache(Zone* zone)
 144       : zone_(zone),
 145         hash_map_(HashMap::PointersMatch, ZoneHashMap::kDefaultHashMapCapacity,
 146                   ZoneAllocationPolicy(zone)) {}
 147
 148   void Put(Variable* variable, FeedbackVectorICSlot slot) {
 149     ZoneHashMap::Entry* entry = hash_map_.LookupOrInsert(
 150         variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone_));
 151     entry->value = reinterpret_cast<void*>(slot.ToInt());
 152   }
 153
 154   ZoneHashMap::Entry* Get(Variable* variable) const {
 155     return hash_map_.Lookup(variable, ComputePointerHash(variable));
 156   }
 157
 158  private:
 159   Zone* zone_;
 160   ZoneHashMap hash_map_;
 161 };
 162
 163
 164 class AstProperties final BASE_EMBEDDED {
 165  public:
 166   enum Flag {
 167     kNoFlags = 0,
 168     kDontSelfOptimize = 1 << 0,
 169     kDontCrankshaft = 1 << 1
 170   };
 171
 172   typedef base::Flags<Flag> Flags;
 173
 174   explicit AstProperties(Zone* zone) : node_count_(0), spec_(zone) {}
 175
 176   Flags& flags() { return flags_; }
 177   Flags flags() const { return flags_; }
 178   int node_count() { return node_count_; }
 179   void add_node_count(int count) { node_count_ += count; }
 180
 181   const FeedbackVectorSpec* get_spec() const { return &spec_; }
 182   FeedbackVectorSpec* get_spec() { return &spec_; }
 183
 184  private:
 185   Flags flags_;
 186   int node_count_;
 187   FeedbackVectorSpec spec_;
 188 };
 189
 190 DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
 191
 192
 193 class AstNode: public ZoneObject {
 194  public:
 195 #define DECLARE_TYPE_ENUM(type) k##type,
 196   enum NodeType {
 197     AST_NODE_LIST(DECLARE_TYPE_ENUM)
 198     kInvalid = -1
 199   };
 200 #undef DECLARE_TYPE_ENUM
 201
 202   void* operator new(size_t size, Zone* zone) { return zone->New(size); }
 203
 204   explicit AstNode(int position): position_(position) {}
 205   virtual ~AstNode() {}
 206
 207   virtual void Accept(AstVisitor* v) = 0;
 208   virtual NodeType node_type() const = 0;
 209   int position() const { return position_; }
 210
 211   // Type testing & conversion functions overridden by concrete subclasses.
 212 #define DECLARE_NODE_FUNCTIONS(type) \
 213   bool Is##type() const { return node_type() == AstNode::k##type; } \
 214   type* As##type() { \
 215     return Is##type() ? reinterpret_cast<type*>(this) : NULL; \
 216   } \
 217   const type* As##type() const { \
 218     return Is##type() ? reinterpret_cast<const type*>(this) : NULL; \
 219   }
 220   AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 221 #undef DECLARE_NODE_FUNCTIONS
 222
 223   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
 224   virtual IterationStatement* AsIterationStatement() { return NULL; }
 225   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
 226
 227   // The interface for feedback slots, with default no-op implementations for
 228   // node types which don't actually have this. Note that this is conceptually
 229   // not really nice, but multiple inheritance would introduce yet another
 230   // vtable entry per node, something we don't want for space reasons.
 231   virtual void AssignFeedbackVectorSlots(Isolate* isolate,
 232                                          FeedbackVectorSpec* spec,
 233                                          ICSlotCache* cache) {}
 234
 235   // Each ICSlot stores a kind of IC which the participating node should know.
 236   virtual FeedbackVectorSlotKind FeedbackICSlotKind(int index) {
 237     UNREACHABLE();
 238     return FeedbackVectorSlotKind::UNUSED;
 239   }
 240
 241  private:
 242   // Hidden to prevent accidental usage. It would have to load the
 243   // current zone from the TLS.
 244   void* operator new(size_t size);
 245
 246   friend class CaseClause;  // Generates AST IDs.
 247
 248   int position_;
 249 };
 250
 251
 252 class Statement : public AstNode {
 253  public:
 254   explicit Statement(Zone* zone, int position) : AstNode(position) {}
 255
 256   bool IsEmpty() { return AsEmptyStatement() != NULL; }
 257   virtual bool IsJump() const { return false; }
 258 };
 259
 260
 261 class SmallMapList final {
 262  public:
 263   SmallMapList() {}
 264   SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
 265
 266   void Reserve(int capacity, Zone* zone) { list_.Reserve(capacity, zone); }
 267   void Clear() { list_.Clear(); }
 268   void Sort() { list_.Sort(); }
 269
 270   bool is_empty() const { return list_.is_empty(); }
 271   int length() const { return list_.length(); }
 272
 273   void AddMapIfMissing(Handle<Map> map, Zone* zone) {
 274     if (!Map::TryUpdate(map).ToHandle(&map)) return;
 275     for (int i = 0; i < length(); ++i) {
 276       if (at(i).is_identical_to(map)) return;
 277     }
 278     Add(map, zone);
 279   }
 280
 281   void FilterForPossibleTransitions(Map* root_map) {
 282     for (int i = list_.length() - 1; i >= 0; i--) {
 283       if (at(i)->FindRootMap() != root_map) {
 284         list_.RemoveElement(list_.at(i));
 285       }
 286     }
 287   }
 288
 289   void Add(Handle<Map> handle, Zone* zone) {
 290     list_.Add(handle.location(), zone);
 291   }
 292
 293   Handle<Map> at(int i) const {
 294     return Handle<Map>(list_.at(i));
 295   }
 296
 297   Handle<Map> first() const { return at(0); }
 298   Handle<Map> last() const { return at(length() - 1); }
 299
 300  private:
 301   // The list stores pointers to Map*, that is Map**, so it's GC safe.
 302   SmallPointerList<Map*> list_;
 303
 304   DISALLOW_COPY_AND_ASSIGN(SmallMapList);
 305 };
 306
 307
 308 class Expression : public AstNode {
 309  public:
 310   enum Context {
 311     // Not assigned a context yet, or else will not be visited during
 312     // code generation.
 313     kUninitialized,
 314     // Evaluated for its side effects.
 315     kEffect,
 316     // Evaluated for its value (and side effects).
 317     kValue,
 318     // Evaluated for control flow (and side effects).
 319     kTest
 320   };
 321
 322   // True iff the expression is a valid reference expression.
 323   virtual bool IsValidReferenceExpression() const { return false; }
 324
 325   // Helpers for ToBoolean conversion.
 326   virtual bool ToBooleanIsTrue() const { return false; }
 327   virtual bool ToBooleanIsFalse() const { return false; }
 328
 329   // Symbols that cannot be parsed as array indices are considered property
 330   // names.  We do not treat symbols that can be array indexes as property
 331   // names because [] for string objects is handled only by keyed ICs.
 332   virtual bool IsPropertyName() const { return false; }
 333
 334   // True iff the expression is a literal represented as a smi.
 335   bool IsSmiLiteral() const;
 336
 337   // True iff the expression is a string literal.
 338   bool IsStringLiteral() const;
 339
 340   // True iff the expression is the null literal.
 341   bool IsNullLiteral() const;
 342
 343   // True if we can prove that the expression is the undefined literal.
 344   bool IsUndefinedLiteral(Isolate* isolate) const;
 345
 346   // True iff the expression is a valid target for an assignment.
 347   bool IsValidReferenceExpressionOrThis() const;
 348
 349   // Expression type bounds
 350   Bounds bounds() const { return bounds_; }
 351   void set_bounds(Bounds bounds) { bounds_ = bounds; }
 352
 353   // Type feedback information for assignments and properties.
 354   virtual bool IsMonomorphic() {
 355     UNREACHABLE();
 356     return false;
 357   }
 358   virtual SmallMapList* GetReceiverTypes() {
 359     UNREACHABLE();
 360     return NULL;
 361   }
 362   virtual KeyedAccessStoreMode GetStoreMode() const {
 363     UNREACHABLE();
 364     return STANDARD_STORE;
 365   }
 366   virtual IcCheckType GetKeyType() const {
 367     UNREACHABLE();
 368     return ELEMENT;
 369   }
 370
 371   // TODO(rossberg): this should move to its own AST node eventually.
 372   virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
 373   uint16_t to_boolean_types() const {
 374     return ToBooleanTypesField::decode(bit_field_);
 375   }
 376
 377   void set_base_id(int id) { base_id_ = id; }
 378   static int num_ids() { return parent_num_ids() + 2; }
 379   BailoutId id() const { return BailoutId(local_id(0)); }
 380   TypeFeedbackId test_id() const { return TypeFeedbackId(local_id(1)); }
 381
 382  protected:
 383   Expression(Zone* zone, int pos)
 384       : AstNode(pos),
 385         base_id_(BailoutId::None().ToInt()),
 386         bounds_(Bounds::Unbounded()),
 387         bit_field_(0) {}
 388   static int parent_num_ids() { return 0; }
 389   void set_to_boolean_types(uint16_t types) {
 390     bit_field_ = ToBooleanTypesField::update(bit_field_, types);
 391   }
 392
 393   int base_id() const {
 394     DCHECK(!BailoutId(base_id_).IsNone());
 395     return base_id_;
 396   }
 397
 398  private:
 399   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 400
 401   int base_id_;
 402   Bounds bounds_;
 403   class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
 404   uint16_t bit_field_;
 405   // Ends with 16-bit field; deriving classes in turn begin with
 406   // 16-bit fields for optimum packing efficiency.
 407 };
 408
 409
 410 class BreakableStatement : public Statement {
 411  public:
 412   enum BreakableType {
 413     TARGET_FOR_ANONYMOUS,
 414     TARGET_FOR_NAMED_ONLY
 415   };
 416
 417   // The labels associated with this statement. May be NULL;
 418   // if it is != NULL, guaranteed to contain at least one entry.
 419   ZoneList<const AstRawString*>* labels() const { return labels_; }
 420
 421   // Type testing & conversion.
 422   BreakableStatement* AsBreakableStatement() final { return this; }
 423
 424   // Code generation
 425   Label* break_target() { return &break_target_; }
 426
 427   // Testers.
 428   bool is_target_for_anonymous() const {
 429     return breakable_type_ == TARGET_FOR_ANONYMOUS;
 430   }
 431
 432   void set_base_id(int id) { base_id_ = id; }
 433   static int num_ids() { return parent_num_ids() + 2; }
 434   BailoutId EntryId() const { return BailoutId(local_id(0)); }
 435   BailoutId ExitId() const { return BailoutId(local_id(1)); }
 436
 437  protected:
 438   BreakableStatement(Zone* zone, ZoneList<const AstRawString*>* labels,
 439                      BreakableType breakable_type, int position)
 440       : Statement(zone, position),
 441         labels_(labels),
 442         breakable_type_(breakable_type),
 443         base_id_(BailoutId::None().ToInt()) {
 444     DCHECK(labels == NULL || labels->length() > 0);
 445   }
 446   static int parent_num_ids() { return 0; }
 447
 448   int base_id() const {
 449     DCHECK(!BailoutId(base_id_).IsNone());
 450     return base_id_;
 451   }
 452
 453  private:
 454   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 455
 456   ZoneList<const AstRawString*>* labels_;
 457   BreakableType breakable_type_;
 458   Label break_target_;
 459   int base_id_;
 460 };
 461
 462
 463 class Block final : public BreakableStatement {
 464  public:
 465   DECLARE_NODE_TYPE(Block)
 466
 467   void AddStatement(Statement* statement, Zone* zone) {
 468     statements_.Add(statement, zone);
 469   }
 470
 471   ZoneList<Statement*>* statements() { return &statements_; }
 472   bool ignore_completion_value() const { return ignore_completion_value_; }
 473
 474   static int num_ids() { return parent_num_ids() + 1; }
 475   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 476
 477   bool IsJump() const override {
 478     return !statements_.is_empty() && statements_.last()->IsJump()
 479         && labels() == NULL;  // Good enough as an approximation...
 480   }
 481
 482   Scope* scope() const { return scope_; }
 483   void set_scope(Scope* scope) { scope_ = scope; }
 484
 485  protected:
 486   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
 487         bool ignore_completion_value, int pos)
 488       : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
 489         statements_(capacity, zone),
 490         ignore_completion_value_(ignore_completion_value),
 491         scope_(NULL) {}
 492   static int parent_num_ids() { return BreakableStatement::num_ids(); }
 493
 494  private:
 495   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 496
 497   ZoneList<Statement*> statements_;
 498   bool ignore_completion_value_;
 499   Scope* scope_;
 500 };
 501
 502
 503 class Declaration : public AstNode {
 504  public:
 505   VariableProxy* proxy() const { return proxy_; }
 506   VariableMode mode() const { return mode_; }
 507   Scope* scope() const { return scope_; }
 508   virtual InitializationFlag initialization() const = 0;
 509   virtual bool IsInlineable() const;
 510
 511  protected:
 512   Declaration(Zone* zone, VariableProxy* proxy, VariableMode mode, Scope* scope,
 513               int pos)
 514       : AstNode(pos), mode_(mode), proxy_(proxy), scope_(scope) {
 515     DCHECK(IsDeclaredVariableMode(mode));
 516   }
 517
 518  private:
 519   VariableMode mode_;
 520   VariableProxy* proxy_;
 521
 522   // Nested scope from which the declaration originated.
 523   Scope* scope_;
 524 };
 525
 526
 527 class VariableDeclaration final : public Declaration {
 528  public:
 529   DECLARE_NODE_TYPE(VariableDeclaration)
 530
 531   InitializationFlag initialization() const override {
 532     return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
 533   }
 534
 535   bool is_class_declaration() const { return is_class_declaration_; }
 536
 537   // VariableDeclarations can be grouped into consecutive declaration
 538   // groups. Each VariableDeclaration is associated with the start position of
 539   // the group it belongs to. The positions are used for strong mode scope
 540   // checks for classes and functions.
 541   int declaration_group_start() const { return declaration_group_start_; }
 542
 543  protected:
 544   VariableDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
 545                       Scope* scope, int pos, bool is_class_declaration = false,
 546                       int declaration_group_start = -1)
 547       : Declaration(zone, proxy, mode, scope, pos),
 548         is_class_declaration_(is_class_declaration),
 549         declaration_group_start_(declaration_group_start) {}
 550
 551   bool is_class_declaration_;
 552   int declaration_group_start_;
 553 };
 554
 555
 556 class FunctionDeclaration final : public Declaration {
 557  public:
 558   DECLARE_NODE_TYPE(FunctionDeclaration)
 559
 560   FunctionLiteral* fun() const { return fun_; }
 561   InitializationFlag initialization() const override {
 562     return kCreatedInitialized;
 563   }
 564   bool IsInlineable() const override;
 565
 566  protected:
 567   FunctionDeclaration(Zone* zone,
 568                       VariableProxy* proxy,
 569                       VariableMode mode,
 570                       FunctionLiteral* fun,
 571                       Scope* scope,
 572                       int pos)
 573       : Declaration(zone, proxy, mode, scope, pos),
 574         fun_(fun) {
 575     DCHECK(mode == VAR || mode == LET || mode == CONST);
 576     DCHECK(fun != NULL);
 577   }
 578
 579  private:
 580   FunctionLiteral* fun_;
 581 };
 582
 583
 584 class ImportDeclaration final : public Declaration {
 585  public:
 586   DECLARE_NODE_TYPE(ImportDeclaration)
 587
 588   const AstRawString* import_name() const { return import_name_; }
 589   const AstRawString* module_specifier() const { return module_specifier_; }
 590   void set_module_specifier(const AstRawString* module_specifier) {
 591     DCHECK(module_specifier_ == NULL);
 592     module_specifier_ = module_specifier;
 593   }
 594   InitializationFlag initialization() const override {
 595     return kNeedsInitialization;
 596   }
 597
 598  protected:
 599   ImportDeclaration(Zone* zone, VariableProxy* proxy,
 600                     const AstRawString* import_name,
 601                     const AstRawString* module_specifier, Scope* scope, int pos)
 602       : Declaration(zone, proxy, IMPORT, scope, pos),
 603         import_name_(import_name),
 604         module_specifier_(module_specifier) {}
 605
 606  private:
 607   const AstRawString* import_name_;
 608   const AstRawString* module_specifier_;
 609 };
 610
 611
 612 class ExportDeclaration final : public Declaration {
 613  public:
 614   DECLARE_NODE_TYPE(ExportDeclaration)
 615
 616   InitializationFlag initialization() const override {
 617     return kCreatedInitialized;
 618   }
 619
 620  protected:
 621   ExportDeclaration(Zone* zone, VariableProxy* proxy, Scope* scope, int pos)
 622       : Declaration(zone, proxy, LET, scope, pos) {}
 623 };
 624
 625
 626 class Module : public AstNode {
 627  public:
 628   ModuleDescriptor* descriptor() const { return descriptor_; }
 629   Block* body() const { return body_; }
 630
 631  protected:
 632   Module(Zone* zone, int pos)
 633       : AstNode(pos), descriptor_(ModuleDescriptor::New(zone)), body_(NULL) {}
 634   Module(Zone* zone, ModuleDescriptor* descriptor, int pos, Block* body = NULL)
 635       : AstNode(pos), descriptor_(descriptor), body_(body) {}
 636
 637  private:
 638   ModuleDescriptor* descriptor_;
 639   Block* body_;
 640 };
 641
 642
 643 class IterationStatement : public BreakableStatement {
 644  public:
 645   // Type testing & conversion.
 646   IterationStatement* AsIterationStatement() final { return this; }
 647
 648   Statement* body() const { return body_; }
 649
 650   static int num_ids() { return parent_num_ids() + 1; }
 651   BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
 652   virtual BailoutId ContinueId() const = 0;
 653   virtual BailoutId StackCheckId() const = 0;
 654
 655   // Code generation
 656   Label* continue_target()  { return &continue_target_; }
 657
 658  protected:
 659   IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 660       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
 661         body_(NULL) {}
 662   static int parent_num_ids() { return BreakableStatement::num_ids(); }
 663   void Initialize(Statement* body) { body_ = body; }
 664
 665  private:
 666   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 667
 668   Statement* body_;
 669   Label continue_target_;
 670 };
 671
 672
 673 class DoWhileStatement final : public IterationStatement {
 674  public:
 675   DECLARE_NODE_TYPE(DoWhileStatement)
 676
 677   void Initialize(Expression* cond, Statement* body) {
 678     IterationStatement::Initialize(body);
 679     cond_ = cond;
 680   }
 681
 682   Expression* cond() const { return cond_; }
 683
 684   static int num_ids() { return parent_num_ids() + 2; }
 685   BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
 686   BailoutId StackCheckId() const override { return BackEdgeId(); }
 687   BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
 688
 689  protected:
 690   DoWhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 691       : IterationStatement(zone, labels, pos), cond_(NULL) {}
 692   static int parent_num_ids() { return IterationStatement::num_ids(); }
 693
 694  private:
 695   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 696
 697   Expression* cond_;
 698 };
 699
 700
 701 class WhileStatement final : public IterationStatement {
 702  public:
 703   DECLARE_NODE_TYPE(WhileStatement)
 704
 705   void Initialize(Expression* cond, Statement* body) {
 706     IterationStatement::Initialize(body);
 707     cond_ = cond;
 708   }
 709
 710   Expression* cond() const { return cond_; }
 711
 712   static int num_ids() { return parent_num_ids() + 1; }
 713   BailoutId ContinueId() const override { return EntryId(); }
 714   BailoutId StackCheckId() const override { return BodyId(); }
 715   BailoutId BodyId() const { return BailoutId(local_id(0)); }
 716
 717  protected:
 718   WhileStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 719       : IterationStatement(zone, labels, pos), cond_(NULL) {}
 720   static int parent_num_ids() { return IterationStatement::num_ids(); }
 721
 722  private:
 723   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 724
 725   Expression* cond_;
 726 };
 727
 728
 729 class ForStatement final : public IterationStatement {
 730  public:
 731   DECLARE_NODE_TYPE(ForStatement)
 732
 733   void Initialize(Statement* init,
 734                   Expression* cond,
 735                   Statement* next,
 736                   Statement* body) {
 737     IterationStatement::Initialize(body);
 738     init_ = init;
 739     cond_ = cond;
 740     next_ = next;
 741   }
 742
 743   Statement* init() const { return init_; }
 744   Expression* cond() const { return cond_; }
 745   Statement* next() const { return next_; }
 746
 747   static int num_ids() { return parent_num_ids() + 2; }
 748   BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
 749   BailoutId StackCheckId() const override { return BodyId(); }
 750   BailoutId BodyId() const { return BailoutId(local_id(1)); }
 751
 752  protected:
 753   ForStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 754       : IterationStatement(zone, labels, pos),
 755         init_(NULL),
 756         cond_(NULL),
 757         next_(NULL) {}
 758   static int parent_num_ids() { return IterationStatement::num_ids(); }
 759
 760  private:
 761   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 762
 763   Statement* init_;
 764   Expression* cond_;
 765   Statement* next_;
 766 };
 767
 768
 769 class ForEachStatement : public IterationStatement {
 770  public:
 771   enum VisitMode {
 772     ENUMERATE,   // for (each in subject) body;
 773     ITERATE      // for (each of subject) body;
 774   };
 775
 776   void Initialize(Expression* each, Expression* subject, Statement* body) {
 777     IterationStatement::Initialize(body);
 778     each_ = each;
 779     subject_ = subject;
 780   }
 781
 782   Expression* each() const { return each_; }
 783   Expression* subject() const { return subject_; }
 784
 785   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
 786                                  ICSlotCache* cache) override;
 787   FeedbackVectorICSlot EachFeedbackSlot() const { return each_slot_; }
 788
 789  protected:
 790   ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 791       : IterationStatement(zone, labels, pos),
 792         each_(NULL),
 793         subject_(NULL),
 794         each_slot_(FeedbackVectorICSlot::Invalid()) {}
 795
 796  private:
 797   Expression* each_;
 798   Expression* subject_;
 799   FeedbackVectorICSlot each_slot_;
 800 };
 801
 802
 803 class ForInStatement final : public ForEachStatement {
 804  public:
 805   DECLARE_NODE_TYPE(ForInStatement)
 806
 807   Expression* enumerable() const {
 808     return subject();
 809   }
 810
 811   // Type feedback information.
 812   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
 813                                  ICSlotCache* cache) override {
 814     ForEachStatement::AssignFeedbackVectorSlots(isolate, spec, cache);
 815     for_in_feedback_slot_ = spec->AddStubSlot();
 816   }
 817
 818   FeedbackVectorSlot ForInFeedbackSlot() {
 819     DCHECK(!for_in_feedback_slot_.IsInvalid());
 820     return for_in_feedback_slot_;
 821   }
 822
 823   enum ForInType { FAST_FOR_IN, SLOW_FOR_IN };
 824   ForInType for_in_type() const { return for_in_type_; }
 825   void set_for_in_type(ForInType type) { for_in_type_ = type; }
 826
 827   static int num_ids() { return parent_num_ids() + 6; }
 828   BailoutId BodyId() const { return BailoutId(local_id(0)); }
 829   BailoutId PrepareId() const { return BailoutId(local_id(1)); }
 830   BailoutId EnumId() const { return BailoutId(local_id(2)); }
 831   BailoutId ToObjectId() const { return BailoutId(local_id(3)); }
 832   BailoutId FilterId() const { return BailoutId(local_id(4)); }
 833   BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
 834   BailoutId ContinueId() const override { return EntryId(); }
 835   BailoutId StackCheckId() const override { return BodyId(); }
 836
 837  protected:
 838   ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 839       : ForEachStatement(zone, labels, pos),
 840         for_in_type_(SLOW_FOR_IN),
 841         for_in_feedback_slot_(FeedbackVectorSlot::Invalid()) {}
 842   static int parent_num_ids() { return ForEachStatement::num_ids(); }
 843
 844  private:
 845   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 846
 847   ForInType for_in_type_;
 848   FeedbackVectorSlot for_in_feedback_slot_;
 849 };
 850
 851
 852 class ForOfStatement final : public ForEachStatement {
 853  public:
 854   DECLARE_NODE_TYPE(ForOfStatement)
 855
 856   void Initialize(Expression* each,
 857                   Expression* subject,
 858                   Statement* body,
 859                   Expression* assign_iterator,
 860                   Expression* next_result,
 861                   Expression* result_done,
 862                   Expression* assign_each) {
 863     ForEachStatement::Initialize(each, subject, body);
 864     assign_iterator_ = assign_iterator;
 865     next_result_ = next_result;
 866     result_done_ = result_done;
 867     assign_each_ = assign_each;
 868   }
 869
 870   Expression* iterable() const {
 871     return subject();
 872   }
 873
 874   // iterator = subject[Symbol.iterator]()
 875   Expression* assign_iterator() const {
 876     return assign_iterator_;
 877   }
 878
 879   // result = iterator.next()  // with type check
 880   Expression* next_result() const {
 881     return next_result_;
 882   }
 883
 884   // result.done
 885   Expression* result_done() const {
 886     return result_done_;
 887   }
 888
 889   // each = result.value
 890   Expression* assign_each() const {
 891     return assign_each_;
 892   }
 893
 894   BailoutId ContinueId() const override { return EntryId(); }
 895   BailoutId StackCheckId() const override { return BackEdgeId(); }
 896
 897   static int num_ids() { return parent_num_ids() + 1; }
 898   BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
 899
 900  protected:
 901   ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
 902       : ForEachStatement(zone, labels, pos),
 903         assign_iterator_(NULL),
 904         next_result_(NULL),
 905         result_done_(NULL),
 906         assign_each_(NULL) {}
 907   static int parent_num_ids() { return ForEachStatement::num_ids(); }
 908
 909  private:
 910   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 911
 912   Expression* assign_iterator_;
 913   Expression* next_result_;
 914   Expression* result_done_;
 915   Expression* assign_each_;
 916 };
 917
 918
 919 class ExpressionStatement final : public Statement {
 920  public:
 921   DECLARE_NODE_TYPE(ExpressionStatement)
 922
 923   void set_expression(Expression* e) { expression_ = e; }
 924   Expression* expression() const { return expression_; }
 925   bool IsJump() const override { return expression_->IsThrow(); }
 926
 927  protected:
 928   ExpressionStatement(Zone* zone, Expression* expression, int pos)
 929       : Statement(zone, pos), expression_(expression) { }
 930
 931  private:
 932   Expression* expression_;
 933 };
 934
 935
 936 class JumpStatement : public Statement {
 937  public:
 938   bool IsJump() const final { return true; }
 939
 940  protected:
 941   explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
 942 };
 943
 944
 945 class ContinueStatement final : public JumpStatement {
 946  public:
 947   DECLARE_NODE_TYPE(ContinueStatement)
 948
 949   IterationStatement* target() const { return target_; }
 950
 951  protected:
 952   explicit ContinueStatement(Zone* zone, IterationStatement* target, int pos)
 953       : JumpStatement(zone, pos), target_(target) { }
 954
 955  private:
 956   IterationStatement* target_;
 957 };
 958
 959
 960 class BreakStatement final : public JumpStatement {
 961  public:
 962   DECLARE_NODE_TYPE(BreakStatement)
 963
 964   BreakableStatement* target() const { return target_; }
 965
 966  protected:
 967   explicit BreakStatement(Zone* zone, BreakableStatement* target, int pos)
 968       : JumpStatement(zone, pos), target_(target) { }
 969
 970  private:
 971   BreakableStatement* target_;
 972 };
 973
 974
 975 class ReturnStatement final : public JumpStatement {
 976  public:
 977   DECLARE_NODE_TYPE(ReturnStatement)
 978
 979   Expression* expression() const { return expression_; }
 980
 981  protected:
 982   explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
 983       : JumpStatement(zone, pos), expression_(expression) { }
 984
 985  private:
 986   Expression* expression_;
 987 };
 988
 989
 990 class WithStatement final : public Statement {
 991  public:
 992   DECLARE_NODE_TYPE(WithStatement)
 993
 994   Scope* scope() { return scope_; }
 995   Expression* expression() const { return expression_; }
 996   Statement* statement() const { return statement_; }
 997
 998   void set_base_id(int id) { base_id_ = id; }
 999   static int num_ids() { return parent_num_ids() + 1; }
1000   BailoutId EntryId() const { return BailoutId(local_id(0)); }
1001
1002  protected:
1003   WithStatement(Zone* zone, Scope* scope, Expression* expression,
1004                 Statement* statement, int pos)
1005       : Statement(zone, pos),
1006         scope_(scope),
1007         expression_(expression),
1008         statement_(statement),
1009         base_id_(BailoutId::None().ToInt()) {}
1010   static int parent_num_ids() { return 0; }
1011
1012   int base_id() const {
1013     DCHECK(!BailoutId(base_id_).IsNone());
1014     return base_id_;
1015   }
1016
1017  private:
1018   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1019
1020   Scope* scope_;
1021   Expression* expression_;
1022   Statement* statement_;
1023   int base_id_;
1024 };
1025
1026
1027 class CaseClause final : public Expression {
1028  public:
1029   DECLARE_NODE_TYPE(CaseClause)
1030
1031   bool is_default() const { return label_ == NULL; }
1032   Expression* label() const {
1033     CHECK(!is_default());
1034     return label_;
1035   }
1036   Label* body_target() { return &body_target_; }
1037   ZoneList<Statement*>* statements() const { return statements_; }
1038
1039   static int num_ids() { return parent_num_ids() + 2; }
1040   BailoutId EntryId() const { return BailoutId(local_id(0)); }
1041   TypeFeedbackId CompareId() { return TypeFeedbackId(local_id(1)); }
1042
1043   Type* compare_type() { return compare_type_; }
1044   void set_compare_type(Type* type) { compare_type_ = type; }
1045
1046  protected:
1047   static int parent_num_ids() { return Expression::num_ids(); }
1048
1049  private:
1050   CaseClause(Zone* zone, Expression* label, ZoneList<Statement*>* statements,
1051              int pos);
1052   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1053
1054   Expression* label_;
1055   Label body_target_;
1056   ZoneList<Statement*>* statements_;
1057   Type* compare_type_;
1058 };
1059
1060
1061 class SwitchStatement final : public BreakableStatement {
1062  public:
1063   DECLARE_NODE_TYPE(SwitchStatement)
1064
1065   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
1066     tag_ = tag;
1067     cases_ = cases;
1068   }
1069
1070   Expression* tag() const { return tag_; }
1071   ZoneList<CaseClause*>* cases() const { return cases_; }
1072
1073  protected:
1074   SwitchStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
1075       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
1076         tag_(NULL),
1077         cases_(NULL) {}
1078
1079  private:
1080   Expression* tag_;
1081   ZoneList<CaseClause*>* cases_;
1082 };
1083
1084
1085 // If-statements always have non-null references to their then- and
1086 // else-parts. When parsing if-statements with no explicit else-part,
1087 // the parser implicitly creates an empty statement. Use the
1088 // HasThenStatement() and HasElseStatement() functions to check if a
1089 // given if-statement has a then- or an else-part containing code.
1090 class IfStatement final : public Statement {
1091  public:
1092   DECLARE_NODE_TYPE(IfStatement)
1093
1094   bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
1095   bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
1096
1097   Expression* condition() const { return condition_; }
1098   Statement* then_statement() const { return then_statement_; }
1099   Statement* else_statement() const { return else_statement_; }
1100
1101   bool IsJump() const override {
1102     return HasThenStatement() && then_statement()->IsJump()
1103         && HasElseStatement() && else_statement()->IsJump();
1104   }
1105
1106   void set_base_id(int id) { base_id_ = id; }
1107   static int num_ids() { return parent_num_ids() + 3; }
1108   BailoutId IfId() const { return BailoutId(local_id(0)); }
1109   BailoutId ThenId() const { return BailoutId(local_id(1)); }
1110   BailoutId ElseId() const { return BailoutId(local_id(2)); }
1111
1112  protected:
1113   IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
1114               Statement* else_statement, int pos)
1115       : Statement(zone, pos),
1116         condition_(condition),
1117         then_statement_(then_statement),
1118         else_statement_(else_statement),
1119         base_id_(BailoutId::None().ToInt()) {}
1120   static int parent_num_ids() { return 0; }
1121
1122   int base_id() const {
1123     DCHECK(!BailoutId(base_id_).IsNone());
1124     return base_id_;
1125   }
1126
1127  private:
1128   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1129
1130   Expression* condition_;
1131   Statement* then_statement_;
1132   Statement* else_statement_;
1133   int base_id_;
1134 };
1135
1136
1137 class TryStatement : public Statement {
1138  public:
1139   Block* try_block() const { return try_block_; }
1140
1141   void set_base_id(int id) { base_id_ = id; }
1142   static int num_ids() { return parent_num_ids() + 1; }
1143   BailoutId HandlerId() const { return BailoutId(local_id(0)); }
1144
1145  protected:
1146   TryStatement(Zone* zone, Block* try_block, int pos)
1147       : Statement(zone, pos),
1148         try_block_(try_block),
1149         base_id_(BailoutId::None().ToInt()) {}
1150   static int parent_num_ids() { return 0; }
1151
1152   int base_id() const {
1153     DCHECK(!BailoutId(base_id_).IsNone());
1154     return base_id_;
1155   }
1156
1157  private:
1158   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1159
1160   Block* try_block_;
1161   int base_id_;
1162 };
1163
1164
1165 class TryCatchStatement final : public TryStatement {
1166  public:
1167   DECLARE_NODE_TYPE(TryCatchStatement)
1168
1169   Scope* scope() { return scope_; }
1170   Variable* variable() { return variable_; }
1171   Block* catch_block() const { return catch_block_; }
1172
1173  protected:
1174   TryCatchStatement(Zone* zone, Block* try_block, Scope* scope,
1175                     Variable* variable, Block* catch_block, int pos)
1176       : TryStatement(zone, try_block, pos),
1177         scope_(scope),
1178         variable_(variable),
1179         catch_block_(catch_block) {}
1180
1181  private:
1182   Scope* scope_;
1183   Variable* variable_;
1184   Block* catch_block_;
1185 };
1186
1187
1188 class TryFinallyStatement final : public TryStatement {
1189  public:
1190   DECLARE_NODE_TYPE(TryFinallyStatement)
1191
1192   Block* finally_block() const { return finally_block_; }
1193
1194  protected:
1195   TryFinallyStatement(Zone* zone, Block* try_block, Block* finally_block,
1196                       int pos)
1197       : TryStatement(zone, try_block, pos), finally_block_(finally_block) {}
1198
1199  private:
1200   Block* finally_block_;
1201 };
1202
1203
1204 class DebuggerStatement final : public Statement {
1205  public:
1206   DECLARE_NODE_TYPE(DebuggerStatement)
1207
1208   void set_base_id(int id) { base_id_ = id; }
1209   static int num_ids() { return parent_num_ids() + 1; }
1210   BailoutId DebugBreakId() const { return BailoutId(local_id(0)); }
1211
1212  protected:
1213   explicit DebuggerStatement(Zone* zone, int pos)
1214       : Statement(zone, pos), base_id_(BailoutId::None().ToInt()) {}
1215   static int parent_num_ids() { return 0; }
1216
1217   int base_id() const {
1218     DCHECK(!BailoutId(base_id_).IsNone());
1219     return base_id_;
1220   }
1221
1222  private:
1223   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1224
1225   int base_id_;
1226 };
1227
1228
1229 class EmptyStatement final : public Statement {
1230  public:
1231   DECLARE_NODE_TYPE(EmptyStatement)
1232
1233  protected:
1234   explicit EmptyStatement(Zone* zone, int pos): Statement(zone, pos) {}
1235 };
1236
1237
1238 // Delegates to another statement, which may be overwritten.
1239 // This was introduced to implement ES2015 Annex B3.3 for conditionally making
1240 // sloppy-mode block-scoped functions have a var binding, which is changed
1241 // from one statement to another during parsing.
1242 class SloppyBlockFunctionStatement final : public Statement {
1243  public:
1244   DECLARE_NODE_TYPE(SloppyBlockFunctionStatement)
1245
1246   Statement* statement() const { return statement_; }
1247   void set_statement(Statement* statement) { statement_ = statement; }
1248   Scope* scope() const { return scope_; }
1249
1250  private:
1251   SloppyBlockFunctionStatement(Zone* zone, Statement* statement, Scope* scope)
1252       : Statement(zone, RelocInfo::kNoPosition),
1253         statement_(statement),
1254         scope_(scope) {}
1255
1256   Statement* statement_;
1257   Scope* const scope_;
1258 };
1259
1260
1261 class Literal final : public Expression {
1262  public:
1263   DECLARE_NODE_TYPE(Literal)
1264
1265   bool IsPropertyName() const override { return value_->IsPropertyName(); }
1266
1267   Handle<String> AsPropertyName() {
1268     DCHECK(IsPropertyName());
1269     return Handle<String>::cast(value());
1270   }
1271
1272   const AstRawString* AsRawPropertyName() {
1273     DCHECK(IsPropertyName());
1274     return value_->AsString();
1275   }
1276
1277   bool ToBooleanIsTrue() const override { return value()->BooleanValue(); }
1278   bool ToBooleanIsFalse() const override { return !value()->BooleanValue(); }
1279
1280   Handle<Object> value() const { return value_->value(); }
1281   const AstValue* raw_value() const { return value_; }
1282
1283   // Support for using Literal as a HashMap key. NOTE: Currently, this works
1284   // only for string and number literals!
1285   uint32_t Hash();
1286   static bool Match(void* literal1, void* literal2);
1287
1288   static int num_ids() { return parent_num_ids() + 1; }
1289   TypeFeedbackId LiteralFeedbackId() const {
1290     return TypeFeedbackId(local_id(0));
1291   }
1292
1293  protected:
1294   Literal(Zone* zone, const AstValue* value, int position)
1295       : Expression(zone, position), value_(value) {}
1296   static int parent_num_ids() { return Expression::num_ids(); }
1297
1298  private:
1299   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1300
1301   const AstValue* value_;
1302 };
1303
1304
1305 class AstLiteralReindexer;
1306
1307 // Base class for literals that needs space in the corresponding JSFunction.
1308 class MaterializedLiteral : public Expression {
1309  public:
1310   virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
1311
1312   int literal_index() { return literal_index_; }
1313
1314   int depth() const {
1315     // only callable after initialization.
1316     DCHECK(depth_ >= 1);
1317     return depth_;
1318   }
1319
1320   bool is_strong() const { return is_strong_; }
1321
1322  protected:
1323   MaterializedLiteral(Zone* zone, int literal_index, bool is_strong, int pos)
1324       : Expression(zone, pos),
1325         literal_index_(literal_index),
1326         is_simple_(false),
1327         is_strong_(is_strong),
1328         depth_(0) {}
1329
1330   // A materialized literal is simple if the values consist of only
1331   // constants and simple object and array literals.
1332   bool is_simple() const { return is_simple_; }
1333   void set_is_simple(bool is_simple) { is_simple_ = is_simple; }
1334   friend class CompileTimeValue;
1335
1336   void set_depth(int depth) {
1337     DCHECK(depth >= 1);
1338     depth_ = depth;
1339   }
1340
1341   // Populate the constant properties/elements fixed array.
1342   void BuildConstants(Isolate* isolate);
1343   friend class ArrayLiteral;
1344   friend class ObjectLiteral;
1345
1346   // If the expression is a literal, return the literal value;
1347   // if the expression is a materialized literal and is simple return a
1348   // compile time value as encoded by CompileTimeValue::GetValue().
1349   // Otherwise, return undefined literal as the placeholder
1350   // in the object literal boilerplate.
1351   Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1352
1353  private:
1354   int literal_index_;
1355   bool is_simple_;
1356   bool is_strong_;
1357   int depth_;
1358
1359   friend class AstLiteralReindexer;
1360 };
1361
1362
1363 // Property is used for passing information
1364 // about an object literal's properties from the parser
1365 // to the code generator.
1366 class ObjectLiteralProperty final : public ZoneObject {
1367  public:
1368   enum Kind {
1369     CONSTANT,              // Property with constant value (compile time).
1370     COMPUTED,              // Property with computed value (execution time).
1371     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
1372     GETTER, SETTER,        // Property is an accessor function.
1373     PROTOTYPE              // Property is __proto__.
1374   };
1375
1376   Expression* key() { return key_; }
1377   Expression* value() { return value_; }
1378   Kind kind() { return kind_; }
1379
1380   // Type feedback information.
1381   bool IsMonomorphic() { return !receiver_type_.is_null(); }
1382   Handle<Map> GetReceiverType() { return receiver_type_; }
1383
1384   bool IsCompileTimeValue();
1385
1386   void set_emit_store(bool emit_store);
1387   bool emit_store();
1388
1389   bool is_static() const { return is_static_; }
1390   bool is_computed_name() const { return is_computed_name_; }
1391
1392   FeedbackVectorICSlot GetSlot(int offset = 0) const {
1393     if (slot_.IsInvalid()) return slot_;
1394     int slot = slot_.ToInt();
1395     return FeedbackVectorICSlot(slot + offset);
1396   }
1397   FeedbackVectorICSlot slot() const { return slot_; }
1398   void set_slot(FeedbackVectorICSlot slot) { slot_ = slot; }
1399
1400   void set_receiver_type(Handle<Map> map) { receiver_type_ = map; }
1401
1402  protected:
1403   friend class AstNodeFactory;
1404
1405   ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
1406                         bool is_static, bool is_computed_name);
1407   ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
1408                         Expression* value, bool is_static,
1409                         bool is_computed_name);
1410
1411  private:
1412   Expression* key_;
1413   Expression* value_;
1414   FeedbackVectorICSlot slot_;
1415   Kind kind_;
1416   bool emit_store_;
1417   bool is_static_;
1418   bool is_computed_name_;
1419   Handle<Map> receiver_type_;
1420 };
1421
1422
1423 // An object literal has a boilerplate object that is used
1424 // for minimizing the work when constructing it at runtime.
1425 class ObjectLiteral final : public MaterializedLiteral {
1426  public:
1427   typedef ObjectLiteralProperty Property;
1428
1429   DECLARE_NODE_TYPE(ObjectLiteral)
1430
1431   Handle<FixedArray> constant_properties() const {
1432     return constant_properties_;
1433   }
1434   int properties_count() const { return constant_properties_->length() / 2; }
1435   ZoneList<Property*>* properties() const { return properties_; }
1436   bool fast_elements() const { return fast_elements_; }
1437   bool may_store_doubles() const { return may_store_doubles_; }
1438   bool has_function() const { return has_function_; }
1439   bool has_elements() const { return has_elements_; }
1440
1441   // Decide if a property should be in the object boilerplate.
1442   static bool IsBoilerplateProperty(Property* property);
1443
1444   // Populate the constant properties fixed array.
1445   void BuildConstantProperties(Isolate* isolate);
1446
1447   // Mark all computed expressions that are bound to a key that
1448   // is shadowed by a later occurrence of the same key. For the
1449   // marked expressions, no store code is emitted.
1450   void CalculateEmitStore(Zone* zone);
1451
1452   // Assemble bitfield of flags for the CreateObjectLiteral helper.
1453   int ComputeFlags(bool disable_mementos = false) const {
1454     int flags = fast_elements() ? kFastElements : kNoFlags;
1455     flags |= has_function() ? kHasFunction : kNoFlags;
1456     if (depth() == 1 && !has_elements() && !may_store_doubles()) {
1457       flags |= kShallowProperties;
1458     }
1459     if (disable_mementos) {
1460       flags |= kDisableMementos;
1461     }
1462     if (is_strong()) {
1463       flags |= kIsStrong;
1464     }
1465     return flags;
1466   }
1467
1468   enum Flags {
1469     kNoFlags = 0,
1470     kFastElements = 1,
1471     kHasFunction = 1 << 1,
1472     kShallowProperties = 1 << 2,
1473     kDisableMementos = 1 << 3,
1474     kIsStrong = 1 << 4
1475   };
1476
1477   struct Accessors: public ZoneObject {
1478     Accessors() : getter(NULL), setter(NULL) {}
1479     ObjectLiteralProperty* getter;
1480     ObjectLiteralProperty* setter;
1481   };
1482
1483   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
1484
1485   // Return an AST id for a property that is used in simulate instructions.
1486   BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 1)); }
1487
1488   // Unlike other AST nodes, this number of bailout IDs allocated for an
1489   // ObjectLiteral can vary, so num_ids() is not a static method.
1490   int num_ids() const { return parent_num_ids() + 1 + properties()->length(); }
1491
1492   // Object literals need one feedback slot for each non-trivial value, as well
1493   // as some slots for home objects.
1494   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
1495                                  ICSlotCache* cache) override;
1496
1497  protected:
1498   ObjectLiteral(Zone* zone, ZoneList<Property*>* properties, int literal_index,
1499                 int boilerplate_properties, bool has_function, bool is_strong,
1500                 int pos)
1501       : MaterializedLiteral(zone, literal_index, is_strong, pos),
1502         properties_(properties),
1503         boilerplate_properties_(boilerplate_properties),
1504         fast_elements_(false),
1505         has_elements_(false),
1506         may_store_doubles_(false),
1507         has_function_(has_function),
1508         slot_(FeedbackVectorICSlot::Invalid()) {
1509   }
1510   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
1511
1512  private:
1513   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1514   Handle<FixedArray> constant_properties_;
1515   ZoneList<Property*>* properties_;
1516   int boilerplate_properties_;
1517   bool fast_elements_;
1518   bool has_elements_;
1519   bool may_store_doubles_;
1520   bool has_function_;
1521   FeedbackVectorICSlot slot_;
1522 };
1523
1524
1525 // Node for capturing a regexp literal.
1526 class RegExpLiteral final : public MaterializedLiteral {
1527  public:
1528   DECLARE_NODE_TYPE(RegExpLiteral)
1529
1530   Handle<String> pattern() const { return pattern_->string(); }
1531   Handle<String> flags() const { return flags_->string(); }
1532
1533  protected:
1534   RegExpLiteral(Zone* zone, const AstRawString* pattern,
1535                 const AstRawString* flags, int literal_index, bool is_strong,
1536                 int pos)
1537       : MaterializedLiteral(zone, literal_index, is_strong, pos),
1538         pattern_(pattern),
1539         flags_(flags) {
1540     set_depth(1);
1541   }
1542
1543  private:
1544   const AstRawString* pattern_;
1545   const AstRawString* flags_;
1546 };
1547
1548
1549 // An array literal has a literals object that is used
1550 // for minimizing the work when constructing it at runtime.
1551 class ArrayLiteral final : public MaterializedLiteral {
1552  public:
1553   DECLARE_NODE_TYPE(ArrayLiteral)
1554
1555   Handle<FixedArray> constant_elements() const { return constant_elements_; }
1556   ElementsKind constant_elements_kind() const {
1557     DCHECK_EQ(2, constant_elements_->length());
1558     return static_cast<ElementsKind>(
1559         Smi::cast(constant_elements_->get(0))->value());
1560   }
1561
1562   ZoneList<Expression*>* values() const { return values_; }
1563
1564   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
1565
1566   // Return an AST id for an element that is used in simulate instructions.
1567   BailoutId GetIdForElement(int i) { return BailoutId(local_id(i + 1)); }
1568
1569   // Unlike other AST nodes, this number of bailout IDs allocated for an
1570   // ArrayLiteral can vary, so num_ids() is not a static method.
1571   int num_ids() const { return parent_num_ids() + 1 + values()->length(); }
1572
1573   // Populate the constant elements fixed array.
1574   void BuildConstantElements(Isolate* isolate);
1575
1576   // Assemble bitfield of flags for the CreateArrayLiteral helper.
1577   int ComputeFlags(bool disable_mementos = false) const {
1578     int flags = depth() == 1 ? kShallowElements : kNoFlags;
1579     if (disable_mementos) {
1580       flags |= kDisableMementos;
1581     }
1582     if (is_strong()) {
1583       flags |= kIsStrong;
1584     }
1585     return flags;
1586   }
1587
1588   enum Flags {
1589     kNoFlags = 0,
1590     kShallowElements = 1,
1591     kDisableMementos = 1 << 1,
1592     kIsStrong = 1 << 2
1593   };
1594
1595  protected:
1596   ArrayLiteral(Zone* zone, ZoneList<Expression*>* values,
1597                int first_spread_index, int literal_index, bool is_strong,
1598                int pos)
1599       : MaterializedLiteral(zone, literal_index, is_strong, pos),
1600         values_(values),
1601         first_spread_index_(first_spread_index) {}
1602   static int parent_num_ids() { return MaterializedLiteral::num_ids(); }
1603
1604  private:
1605   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1606
1607   Handle<FixedArray> constant_elements_;
1608   ZoneList<Expression*>* values_;
1609   int first_spread_index_;
1610 };
1611
1612
1613 class VariableProxy final : public Expression {
1614  public:
1615   DECLARE_NODE_TYPE(VariableProxy)
1616
1617   bool IsValidReferenceExpression() const override {
1618     return !is_this() && !is_new_target();
1619   }
1620
1621   bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
1622
1623   Handle<String> name() const { return raw_name()->string(); }
1624   const AstRawString* raw_name() const {
1625     return is_resolved() ? var_->raw_name() : raw_name_;
1626   }
1627
1628   Variable* var() const {
1629     DCHECK(is_resolved());
1630     return var_;
1631   }
1632   void set_var(Variable* v) {
1633     DCHECK(!is_resolved());
1634     DCHECK_NOT_NULL(v);
1635     var_ = v;
1636   }
1637
1638   bool is_this() const { return IsThisField::decode(bit_field_); }
1639
1640   bool is_assigned() const { return IsAssignedField::decode(bit_field_); }
1641   void set_is_assigned() {
1642     bit_field_ = IsAssignedField::update(bit_field_, true);
1643   }
1644
1645   bool is_resolved() const { return IsResolvedField::decode(bit_field_); }
1646   void set_is_resolved() {
1647     bit_field_ = IsResolvedField::update(bit_field_, true);
1648   }
1649
1650   bool is_new_target() const { return IsNewTargetField::decode(bit_field_); }
1651   void set_is_new_target() {
1652     bit_field_ = IsNewTargetField::update(bit_field_, true);
1653   }
1654
1655   int end_position() const { return end_position_; }
1656
1657   // Bind this proxy to the variable var.
1658   void BindTo(Variable* var);
1659
1660   bool UsesVariableFeedbackSlot() const {
1661     return var()->IsUnallocated() || var()->IsLookupSlot();
1662   }
1663
1664   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
1665                                  ICSlotCache* cache) override;
1666
1667   FeedbackVectorICSlot VariableFeedbackSlot() {
1668     return variable_feedback_slot_;
1669   }
1670
1671   static int num_ids() { return parent_num_ids() + 1; }
1672   BailoutId BeforeId() const { return BailoutId(local_id(0)); }
1673
1674  protected:
1675   VariableProxy(Zone* zone, Variable* var, int start_position,
1676                 int end_position);
1677
1678   VariableProxy(Zone* zone, const AstRawString* name,
1679                 Variable::Kind variable_kind, int start_position,
1680                 int end_position);
1681   static int parent_num_ids() { return Expression::num_ids(); }
1682   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1683
1684   class IsThisField : public BitField8<bool, 0, 1> {};
1685   class IsAssignedField : public BitField8<bool, 1, 1> {};
1686   class IsResolvedField : public BitField8<bool, 2, 1> {};
1687   class IsNewTargetField : public BitField8<bool, 3, 1> {};
1688
1689   // Start with 16-bit (or smaller) field, which should get packed together
1690   // with Expression's trailing 16-bit field.
1691   uint8_t bit_field_;
1692   FeedbackVectorICSlot variable_feedback_slot_;
1693   union {
1694     const AstRawString* raw_name_;  // if !is_resolved_
1695     Variable* var_;                 // if is_resolved_
1696   };
1697   // Position is stored in the AstNode superclass, but VariableProxy needs to
1698   // know its end position too (for error messages). It cannot be inferred from
1699   // the variable name length because it can contain escapes.
1700   int end_position_;
1701 };
1702
1703
1704 // Left-hand side can only be a property, a global or a (parameter or local)
1705 // slot.
1706 enum LhsKind {
1707   VARIABLE,
1708   NAMED_PROPERTY,
1709   KEYED_PROPERTY,
1710   NAMED_SUPER_PROPERTY,
1711   KEYED_SUPER_PROPERTY
1712 };
1713
1714
1715 class Property final : public Expression {
1716  public:
1717   DECLARE_NODE_TYPE(Property)
1718
1719   bool IsValidReferenceExpression() const override { return true; }
1720
1721   Expression* obj() const { return obj_; }
1722   Expression* key() const { return key_; }
1723
1724   static int num_ids() { return parent_num_ids() + 1; }
1725   BailoutId LoadId() const { return BailoutId(local_id(0)); }
1726
1727   bool IsStringAccess() const {
1728     return IsStringAccessField::decode(bit_field_);
1729   }
1730
1731   // Type feedback information.
1732   bool IsMonomorphic() override { return receiver_types_.length() == 1; }
1733   SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
1734   KeyedAccessStoreMode GetStoreMode() const override { return STANDARD_STORE; }
1735   IcCheckType GetKeyType() const override {
1736     return KeyTypeField::decode(bit_field_);
1737   }
1738   bool IsUninitialized() const {
1739     return !is_for_call() && HasNoTypeInformation();
1740   }
1741   bool HasNoTypeInformation() const {
1742     return GetInlineCacheState() == UNINITIALIZED;
1743   }
1744   InlineCacheState GetInlineCacheState() const {
1745     return InlineCacheStateField::decode(bit_field_);
1746   }
1747   void set_is_string_access(bool b) {
1748     bit_field_ = IsStringAccessField::update(bit_field_, b);
1749   }
1750   void set_key_type(IcCheckType key_type) {
1751     bit_field_ = KeyTypeField::update(bit_field_, key_type);
1752   }
1753   void set_inline_cache_state(InlineCacheState state) {
1754     bit_field_ = InlineCacheStateField::update(bit_field_, state);
1755   }
1756   void mark_for_call() {
1757     bit_field_ = IsForCallField::update(bit_field_, true);
1758   }
1759   bool is_for_call() const { return IsForCallField::decode(bit_field_); }
1760
1761   bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
1762
1763   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
1764                                  ICSlotCache* cache) override {
1765     FeedbackVectorSlotKind kind = key()->IsPropertyName()
1766                                       ? FeedbackVectorSlotKind::LOAD_IC
1767                                       : FeedbackVectorSlotKind::KEYED_LOAD_IC;
1768     property_feedback_slot_ = spec->AddSlot(kind);
1769   }
1770
1771   FeedbackVectorICSlot PropertyFeedbackSlot() const {
1772     return property_feedback_slot_;
1773   }
1774
1775   static LhsKind GetAssignType(Property* property) {
1776     if (property == NULL) return VARIABLE;
1777     bool super_access = property->IsSuperAccess();
1778     return (property->key()->IsPropertyName())
1779                ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
1780                : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
1781   }
1782
1783  protected:
1784   Property(Zone* zone, Expression* obj, Expression* key, int pos)
1785       : Expression(zone, pos),
1786         bit_field_(IsForCallField::encode(false) |
1787                    IsStringAccessField::encode(false) |
1788                    InlineCacheStateField::encode(UNINITIALIZED)),
1789         property_feedback_slot_(FeedbackVectorICSlot::Invalid()),
1790         obj_(obj),
1791         key_(key) {}
1792   static int parent_num_ids() { return Expression::num_ids(); }
1793
1794  private:
1795   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1796
1797   class IsForCallField : public BitField8<bool, 0, 1> {};
1798   class IsStringAccessField : public BitField8<bool, 1, 1> {};
1799   class KeyTypeField : public BitField8<IcCheckType, 2, 1> {};
1800   class InlineCacheStateField : public BitField8<InlineCacheState, 3, 4> {};
1801   uint8_t bit_field_;
1802   FeedbackVectorICSlot property_feedback_slot_;
1803   Expression* obj_;
1804   Expression* key_;
1805   SmallMapList receiver_types_;
1806 };
1807
1808
1809 class Call final : public Expression {
1810  public:
1811   DECLARE_NODE_TYPE(Call)
1812
1813   Expression* expression() const { return expression_; }
1814   ZoneList<Expression*>* arguments() const { return arguments_; }
1815
1816   // Type feedback information.
1817   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
1818                                  ICSlotCache* cache) override;
1819
1820   FeedbackVectorSlot CallFeedbackSlot() const { return slot_; }
1821
1822   FeedbackVectorICSlot CallFeedbackICSlot() const { return ic_slot_; }
1823
1824   SmallMapList* GetReceiverTypes() override {
1825     if (expression()->IsProperty()) {
1826       return expression()->AsProperty()->GetReceiverTypes();
1827     }
1828     return NULL;
1829   }
1830
1831   bool IsMonomorphic() override {
1832     if (expression()->IsProperty()) {
1833       return expression()->AsProperty()->IsMonomorphic();
1834     }
1835     return !target_.is_null();
1836   }
1837
1838   bool global_call() const {
1839     VariableProxy* proxy = expression_->AsVariableProxy();
1840     return proxy != NULL && proxy->var()->IsUnallocatedOrGlobalSlot();
1841   }
1842
1843   bool known_global_function() const {
1844     return global_call() && !target_.is_null();
1845   }
1846
1847   Handle<JSFunction> target() { return target_; }
1848
1849   Handle<AllocationSite> allocation_site() { return allocation_site_; }
1850
1851   void SetKnownGlobalTarget(Handle<JSFunction> target) {
1852     target_ = target;
1853     set_is_uninitialized(false);
1854   }
1855   void set_target(Handle<JSFunction> target) { target_ = target; }
1856   void set_allocation_site(Handle<AllocationSite> site) {
1857     allocation_site_ = site;
1858   }
1859
1860   static int num_ids() { return parent_num_ids() + 3; }
1861   BailoutId ReturnId() const { return BailoutId(local_id(0)); }
1862   BailoutId EvalId() const { return BailoutId(local_id(1)); }
1863   BailoutId LookupId() const { return BailoutId(local_id(2)); }
1864
1865   bool is_uninitialized() const {
1866     return IsUninitializedField::decode(bit_field_);
1867   }
1868   void set_is_uninitialized(bool b) {
1869     bit_field_ = IsUninitializedField::update(bit_field_, b);
1870   }
1871
1872   enum CallType {
1873     POSSIBLY_EVAL_CALL,
1874     GLOBAL_CALL,
1875     LOOKUP_SLOT_CALL,
1876     PROPERTY_CALL,
1877     SUPER_CALL,
1878     OTHER_CALL
1879   };
1880
1881   // Helpers to determine how to handle the call.
1882   CallType GetCallType(Isolate* isolate) const;
1883   bool IsUsingCallFeedbackSlot(Isolate* isolate) const;
1884   bool IsUsingCallFeedbackICSlot(Isolate* isolate) const;
1885
1886 #ifdef DEBUG
1887   // Used to assert that the FullCodeGenerator records the return site.
1888   bool return_is_recorded_;
1889 #endif
1890
1891  protected:
1892   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
1893        int pos)
1894       : Expression(zone, pos),
1895         ic_slot_(FeedbackVectorICSlot::Invalid()),
1896         slot_(FeedbackVectorSlot::Invalid()),
1897         expression_(expression),
1898         arguments_(arguments),
1899         bit_field_(IsUninitializedField::encode(false)) {
1900     if (expression->IsProperty()) {
1901       expression->AsProperty()->mark_for_call();
1902     }
1903   }
1904   static int parent_num_ids() { return Expression::num_ids(); }
1905
1906  private:
1907   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1908
1909   FeedbackVectorICSlot ic_slot_;
1910   FeedbackVectorSlot slot_;
1911   Expression* expression_;
1912   ZoneList<Expression*>* arguments_;
1913   Handle<JSFunction> target_;
1914   Handle<AllocationSite> allocation_site_;
1915   class IsUninitializedField : public BitField8<bool, 0, 1> {};
1916   uint8_t bit_field_;
1917 };
1918
1919
1920 class CallNew final : public Expression {
1921  public:
1922   DECLARE_NODE_TYPE(CallNew)
1923
1924   Expression* expression() const { return expression_; }
1925   ZoneList<Expression*>* arguments() const { return arguments_; }
1926
1927   // Type feedback information.
1928   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
1929                                  ICSlotCache* cache) override {
1930     callnew_feedback_slot_ = spec->AddStubSlot();
1931   }
1932
1933   FeedbackVectorSlot CallNewFeedbackSlot() {
1934     DCHECK(!callnew_feedback_slot_.IsInvalid());
1935     return callnew_feedback_slot_;
1936   }
1937
1938   bool IsMonomorphic() override { return is_monomorphic_; }
1939   Handle<JSFunction> target() const { return target_; }
1940   Handle<AllocationSite> allocation_site() const {
1941     return allocation_site_;
1942   }
1943
1944   static int num_ids() { return parent_num_ids() + 1; }
1945   static int feedback_slots() { return 1; }
1946   BailoutId ReturnId() const { return BailoutId(local_id(0)); }
1947
1948   void set_allocation_site(Handle<AllocationSite> site) {
1949     allocation_site_ = site;
1950   }
1951   void set_is_monomorphic(bool monomorphic) { is_monomorphic_ = monomorphic; }
1952   void set_target(Handle<JSFunction> target) { target_ = target; }
1953   void SetKnownGlobalTarget(Handle<JSFunction> target) {
1954     target_ = target;
1955     is_monomorphic_ = true;
1956   }
1957
1958  protected:
1959   CallNew(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
1960           int pos)
1961       : Expression(zone, pos),
1962         expression_(expression),
1963         arguments_(arguments),
1964         is_monomorphic_(false),
1965         callnew_feedback_slot_(FeedbackVectorSlot::Invalid()) {}
1966
1967   static int parent_num_ids() { return Expression::num_ids(); }
1968
1969  private:
1970   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
1971
1972   Expression* expression_;
1973   ZoneList<Expression*>* arguments_;
1974   bool is_monomorphic_;
1975   Handle<JSFunction> target_;
1976   Handle<AllocationSite> allocation_site_;
1977   FeedbackVectorSlot callnew_feedback_slot_;
1978 };
1979
1980
1981 // The CallRuntime class does not represent any official JavaScript
1982 // language construct. Instead it is used to call a C or JS function
1983 // with a set of arguments. This is used from the builtins that are
1984 // implemented in JavaScript (see "v8natives.js").
1985 class CallRuntime final : public Expression {
1986  public:
1987   DECLARE_NODE_TYPE(CallRuntime)
1988
1989   ZoneList<Expression*>* arguments() const { return arguments_; }
1990   bool is_jsruntime() const { return function_ == NULL; }
1991
1992   int context_index() const {
1993     DCHECK(is_jsruntime());
1994     return context_index_;
1995   }
1996   const Runtime::Function* function() const {
1997     DCHECK(!is_jsruntime());
1998     return function_;
1999   }
2000
2001   static int num_ids() { return parent_num_ids() + 1; }
2002   BailoutId CallId() { return BailoutId(local_id(0)); }
2003
2004   const char* debug_name() {
2005     return is_jsruntime() ? "(context function)" : function_->name;
2006   }
2007
2008  protected:
2009   CallRuntime(Zone* zone, const Runtime::Function* function,
2010               ZoneList<Expression*>* arguments, int pos)
2011       : Expression(zone, pos), function_(function), arguments_(arguments) {}
2012
2013   CallRuntime(Zone* zone, int context_index, ZoneList<Expression*>* arguments,
2014               int pos)
2015       : Expression(zone, pos),
2016         function_(NULL),
2017         context_index_(context_index),
2018         arguments_(arguments) {}
2019
2020   static int parent_num_ids() { return Expression::num_ids(); }
2021
2022  private:
2023   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2024
2025   const Runtime::Function* function_;
2026   int context_index_;
2027   ZoneList<Expression*>* arguments_;
2028 };
2029
2030
2031 class UnaryOperation final : public Expression {
2032  public:
2033   DECLARE_NODE_TYPE(UnaryOperation)
2034
2035   Token::Value op() const { return op_; }
2036   Expression* expression() const { return expression_; }
2037
2038   // For unary not (Token::NOT), the AST ids where true and false will
2039   // actually be materialized, respectively.
2040   static int num_ids() { return parent_num_ids() + 2; }
2041   BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
2042   BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
2043
2044   virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
2045
2046  protected:
2047   UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
2048       : Expression(zone, pos), op_(op), expression_(expression) {
2049     DCHECK(Token::IsUnaryOp(op));
2050   }
2051   static int parent_num_ids() { return Expression::num_ids(); }
2052
2053  private:
2054   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2055
2056   Token::Value op_;
2057   Expression* expression_;
2058 };
2059
2060
2061 class BinaryOperation final : public Expression {
2062  public:
2063   DECLARE_NODE_TYPE(BinaryOperation)
2064
2065   Token::Value op() const { return static_cast<Token::Value>(op_); }
2066   Expression* left() const { return left_; }
2067   Expression* right() const { return right_; }
2068   Handle<AllocationSite> allocation_site() const { return allocation_site_; }
2069   void set_allocation_site(Handle<AllocationSite> allocation_site) {
2070     allocation_site_ = allocation_site;
2071   }
2072
2073   // The short-circuit logical operations need an AST ID for their
2074   // right-hand subexpression.
2075   static int num_ids() { return parent_num_ids() + 2; }
2076   BailoutId RightId() const { return BailoutId(local_id(0)); }
2077
2078   TypeFeedbackId BinaryOperationFeedbackId() const {
2079     return TypeFeedbackId(local_id(1));
2080   }
2081   Maybe<int> fixed_right_arg() const {
2082     return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
2083   }
2084   void set_fixed_right_arg(Maybe<int> arg) {
2085     has_fixed_right_arg_ = arg.IsJust();
2086     if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
2087   }
2088
2089   virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
2090
2091  protected:
2092   BinaryOperation(Zone* zone, Token::Value op, Expression* left,
2093                   Expression* right, int pos)
2094       : Expression(zone, pos),
2095         op_(static_cast<byte>(op)),
2096         has_fixed_right_arg_(false),
2097         fixed_right_arg_value_(0),
2098         left_(left),
2099         right_(right) {
2100     DCHECK(Token::IsBinaryOp(op));
2101   }
2102   static int parent_num_ids() { return Expression::num_ids(); }
2103
2104  private:
2105   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2106
2107   const byte op_;  // actually Token::Value
2108   // TODO(rossberg): the fixed arg should probably be represented as a Constant
2109   // type for the RHS. Currenty it's actually a Maybe<int>
2110   bool has_fixed_right_arg_;
2111   int fixed_right_arg_value_;
2112   Expression* left_;
2113   Expression* right_;
2114   Handle<AllocationSite> allocation_site_;
2115 };
2116
2117
2118 class CountOperation final : public Expression {
2119  public:
2120   DECLARE_NODE_TYPE(CountOperation)
2121
2122   bool is_prefix() const { return IsPrefixField::decode(bit_field_); }
2123   bool is_postfix() const { return !is_prefix(); }
2124
2125   Token::Value op() const { return TokenField::decode(bit_field_); }
2126   Token::Value binary_op() {
2127     return (op() == Token::INC) ? Token::ADD : Token::SUB;
2128   }
2129
2130   Expression* expression() const { return expression_; }
2131
2132   bool IsMonomorphic() override { return receiver_types_.length() == 1; }
2133   SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
2134   IcCheckType GetKeyType() const override {
2135     return KeyTypeField::decode(bit_field_);
2136   }
2137   KeyedAccessStoreMode GetStoreMode() const override {
2138     return StoreModeField::decode(bit_field_);
2139   }
2140   Type* type() const { return type_; }
2141   void set_key_type(IcCheckType type) {
2142     bit_field_ = KeyTypeField::update(bit_field_, type);
2143   }
2144   void set_store_mode(KeyedAccessStoreMode mode) {
2145     bit_field_ = StoreModeField::update(bit_field_, mode);
2146   }
2147   void set_type(Type* type) { type_ = type; }
2148
2149   static int num_ids() { return parent_num_ids() + 4; }
2150   BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
2151   BailoutId ToNumberId() const { return BailoutId(local_id(1)); }
2152   TypeFeedbackId CountBinOpFeedbackId() const {
2153     return TypeFeedbackId(local_id(2));
2154   }
2155   TypeFeedbackId CountStoreFeedbackId() const {
2156     return TypeFeedbackId(local_id(3));
2157   }
2158
2159   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
2160                                  ICSlotCache* cache) override;
2161   FeedbackVectorICSlot CountSlot() const { return slot_; }
2162
2163  protected:
2164   CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
2165                  int pos)
2166       : Expression(zone, pos),
2167         bit_field_(
2168             IsPrefixField::encode(is_prefix) | KeyTypeField::encode(ELEMENT) |
2169             StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
2170         type_(NULL),
2171         expression_(expr),
2172         slot_(FeedbackVectorICSlot::Invalid()) {}
2173   static int parent_num_ids() { return Expression::num_ids(); }
2174
2175  private:
2176   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2177
2178   class IsPrefixField : public BitField16<bool, 0, 1> {};
2179   class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
2180   class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
2181   class TokenField : public BitField16<Token::Value, 5, 8> {};
2182
2183   // Starts with 16-bit field, which should get packed together with
2184   // Expression's trailing 16-bit field.
2185   uint16_t bit_field_;
2186   Type* type_;
2187   Expression* expression_;
2188   SmallMapList receiver_types_;
2189   FeedbackVectorICSlot slot_;
2190 };
2191
2192
2193 class CompareOperation final : public Expression {
2194  public:
2195   DECLARE_NODE_TYPE(CompareOperation)
2196
2197   Token::Value op() const { return op_; }
2198   Expression* left() const { return left_; }
2199   Expression* right() const { return right_; }
2200
2201   // Type feedback information.
2202   static int num_ids() { return parent_num_ids() + 1; }
2203   TypeFeedbackId CompareOperationFeedbackId() const {
2204     return TypeFeedbackId(local_id(0));
2205   }
2206   Type* combined_type() const { return combined_type_; }
2207   void set_combined_type(Type* type) { combined_type_ = type; }
2208
2209   // Match special cases.
2210   bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
2211   bool IsLiteralCompareUndefined(Expression** expr, Isolate* isolate);
2212   bool IsLiteralCompareNull(Expression** expr);
2213
2214  protected:
2215   CompareOperation(Zone* zone, Token::Value op, Expression* left,
2216                    Expression* right, int pos)
2217       : Expression(zone, pos),
2218         op_(op),
2219         left_(left),
2220         right_(right),
2221         combined_type_(Type::None(zone)) {
2222     DCHECK(Token::IsCompareOp(op));
2223   }
2224   static int parent_num_ids() { return Expression::num_ids(); }
2225
2226  private:
2227   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2228
2229   Token::Value op_;
2230   Expression* left_;
2231   Expression* right_;
2232
2233   Type* combined_type_;
2234 };
2235
2236
2237 class Spread final : public Expression {
2238  public:
2239   DECLARE_NODE_TYPE(Spread)
2240
2241   Expression* expression() const { return expression_; }
2242
2243   static int num_ids() { return parent_num_ids(); }
2244
2245  protected:
2246   Spread(Zone* zone, Expression* expression, int pos)
2247       : Expression(zone, pos), expression_(expression) {}
2248   static int parent_num_ids() { return Expression::num_ids(); }
2249
2250  private:
2251   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2252
2253   Expression* expression_;
2254 };
2255
2256
2257 class Conditional final : public Expression {
2258  public:
2259   DECLARE_NODE_TYPE(Conditional)
2260
2261   Expression* condition() const { return condition_; }
2262   Expression* then_expression() const { return then_expression_; }
2263   Expression* else_expression() const { return else_expression_; }
2264
2265   static int num_ids() { return parent_num_ids() + 2; }
2266   BailoutId ThenId() const { return BailoutId(local_id(0)); }
2267   BailoutId ElseId() const { return BailoutId(local_id(1)); }
2268
2269  protected:
2270   Conditional(Zone* zone, Expression* condition, Expression* then_expression,
2271               Expression* else_expression, int position)
2272       : Expression(zone, position),
2273         condition_(condition),
2274         then_expression_(then_expression),
2275         else_expression_(else_expression) {}
2276   static int parent_num_ids() { return Expression::num_ids(); }
2277
2278  private:
2279   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2280
2281   Expression* condition_;
2282   Expression* then_expression_;
2283   Expression* else_expression_;
2284 };
2285
2286
2287 class Assignment final : public Expression {
2288  public:
2289   DECLARE_NODE_TYPE(Assignment)
2290
2291   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
2292
2293   Token::Value binary_op() const;
2294
2295   Token::Value op() const { return TokenField::decode(bit_field_); }
2296   Expression* target() const { return target_; }
2297   Expression* value() const { return value_; }
2298   BinaryOperation* binary_operation() const { return binary_operation_; }
2299
2300   // This check relies on the definition order of token in token.h.
2301   bool is_compound() const { return op() > Token::ASSIGN; }
2302
2303   static int num_ids() { return parent_num_ids() + 2; }
2304   BailoutId AssignmentId() const { return BailoutId(local_id(0)); }
2305
2306   // Type feedback information.
2307   TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
2308   bool IsMonomorphic() override { return receiver_types_.length() == 1; }
2309   bool IsUninitialized() const {
2310     return IsUninitializedField::decode(bit_field_);
2311   }
2312   bool HasNoTypeInformation() {
2313     return IsUninitializedField::decode(bit_field_);
2314   }
2315   SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
2316   IcCheckType GetKeyType() const override {
2317     return KeyTypeField::decode(bit_field_);
2318   }
2319   KeyedAccessStoreMode GetStoreMode() const override {
2320     return StoreModeField::decode(bit_field_);
2321   }
2322   void set_is_uninitialized(bool b) {
2323     bit_field_ = IsUninitializedField::update(bit_field_, b);
2324   }
2325   void set_key_type(IcCheckType key_type) {
2326     bit_field_ = KeyTypeField::update(bit_field_, key_type);
2327   }
2328   void set_store_mode(KeyedAccessStoreMode mode) {
2329     bit_field_ = StoreModeField::update(bit_field_, mode);
2330   }
2331
2332   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
2333                                  ICSlotCache* cache) override;
2334   FeedbackVectorICSlot AssignmentSlot() const { return slot_; }
2335
2336  protected:
2337   Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
2338              int pos);
2339   static int parent_num_ids() { return Expression::num_ids(); }
2340
2341  private:
2342   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2343
2344   class IsUninitializedField : public BitField16<bool, 0, 1> {};
2345   class KeyTypeField : public BitField16<IcCheckType, 1, 1> {};
2346   class StoreModeField : public BitField16<KeyedAccessStoreMode, 2, 3> {};
2347   class TokenField : public BitField16<Token::Value, 5, 8> {};
2348
2349   // Starts with 16-bit field, which should get packed together with
2350   // Expression's trailing 16-bit field.
2351   uint16_t bit_field_;
2352   Expression* target_;
2353   Expression* value_;
2354   BinaryOperation* binary_operation_;
2355   SmallMapList receiver_types_;
2356   FeedbackVectorICSlot slot_;
2357 };
2358
2359
2360 class Yield final : public Expression {
2361  public:
2362   DECLARE_NODE_TYPE(Yield)
2363
2364   enum Kind {
2365     kInitial,  // The initial yield that returns the unboxed generator object.
2366     kSuspend,  // A normal yield: { value: EXPRESSION, done: false }
2367     kDelegating,  // A yield*.
2368     kFinal        // A return: { value: EXPRESSION, done: true }
2369   };
2370
2371   Expression* generator_object() const { return generator_object_; }
2372   Expression* expression() const { return expression_; }
2373   Kind yield_kind() const { return yield_kind_; }
2374
2375   // Type feedback information.
2376   bool HasFeedbackSlots() const { return yield_kind() == kDelegating; }
2377   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
2378                                  ICSlotCache* cache) override {
2379     if (HasFeedbackSlots()) {
2380       yield_first_feedback_slot_ = spec->AddKeyedLoadICSlot();
2381       spec->AddLoadICSlots(2);
2382     }
2383   }
2384
2385   FeedbackVectorICSlot KeyedLoadFeedbackSlot() {
2386     DCHECK(!HasFeedbackSlots() || !yield_first_feedback_slot_.IsInvalid());
2387     return yield_first_feedback_slot_;
2388   }
2389
2390   FeedbackVectorICSlot DoneFeedbackSlot() {
2391     return KeyedLoadFeedbackSlot().next();
2392   }
2393
2394   FeedbackVectorICSlot ValueFeedbackSlot() { return DoneFeedbackSlot().next(); }
2395
2396  protected:
2397   Yield(Zone* zone, Expression* generator_object, Expression* expression,
2398         Kind yield_kind, int pos)
2399       : Expression(zone, pos),
2400         generator_object_(generator_object),
2401         expression_(expression),
2402         yield_kind_(yield_kind),
2403         yield_first_feedback_slot_(FeedbackVectorICSlot::Invalid()) {}
2404
2405  private:
2406   Expression* generator_object_;
2407   Expression* expression_;
2408   Kind yield_kind_;
2409   FeedbackVectorICSlot yield_first_feedback_slot_;
2410 };
2411
2412
2413 class Throw final : public Expression {
2414  public:
2415   DECLARE_NODE_TYPE(Throw)
2416
2417   Expression* exception() const { return exception_; }
2418
2419  protected:
2420   Throw(Zone* zone, Expression* exception, int pos)
2421       : Expression(zone, pos), exception_(exception) {}
2422
2423  private:
2424   Expression* exception_;
2425 };
2426
2427
2428 class FunctionLiteral final : public Expression {
2429  public:
2430   enum FunctionType {
2431     ANONYMOUS_EXPRESSION,
2432     NAMED_EXPRESSION,
2433     DECLARATION
2434   };
2435
2436   enum ParameterFlag {
2437     kNoDuplicateParameters = 0,
2438     kHasDuplicateParameters = 1
2439   };
2440
2441   enum IsFunctionFlag {
2442     kGlobalOrEval,
2443     kIsFunction
2444   };
2445
2446   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
2447
2448   enum ShouldBeUsedOnceHint { kShouldBeUsedOnce, kDontKnowIfShouldBeUsedOnce };
2449
2450   enum ArityRestriction {
2451     NORMAL_ARITY,
2452     GETTER_ARITY,
2453     SETTER_ARITY
2454   };
2455
2456   DECLARE_NODE_TYPE(FunctionLiteral)
2457
2458   Handle<String> name() const { return raw_name_->string(); }
2459   const AstRawString* raw_name() const { return raw_name_; }
2460   Scope* scope() const { return scope_; }
2461   ZoneList<Statement*>* body() const { return body_; }
2462   void set_function_token_position(int pos) { function_token_position_ = pos; }
2463   int function_token_position() const { return function_token_position_; }
2464   int start_position() const;
2465   int end_position() const;
2466   int SourceSize() const { return end_position() - start_position(); }
2467   bool is_expression() const { return IsExpression::decode(bitfield_); }
2468   bool is_anonymous() const { return IsAnonymous::decode(bitfield_); }
2469   LanguageMode language_mode() const;
2470
2471   static bool NeedsHomeObject(Expression* expr);
2472
2473   int materialized_literal_count() { return materialized_literal_count_; }
2474   int expected_property_count() { return expected_property_count_; }
2475   int parameter_count() { return parameter_count_; }
2476
2477   bool AllowsLazyCompilation();
2478   bool AllowsLazyCompilationWithoutContext();
2479
2480   Handle<String> debug_name() const {
2481     if (raw_name_ != NULL && !raw_name_->IsEmpty()) {
2482       return raw_name_->string();
2483     }
2484     return inferred_name();
2485   }
2486
2487   Handle<String> inferred_name() const {
2488     if (!inferred_name_.is_null()) {
2489       DCHECK(raw_inferred_name_ == NULL);
2490       return inferred_name_;
2491     }
2492     if (raw_inferred_name_ != NULL) {
2493       return raw_inferred_name_->string();
2494     }
2495     UNREACHABLE();
2496     return Handle<String>();
2497   }
2498
2499   // Only one of {set_inferred_name, set_raw_inferred_name} should be called.
2500   void set_inferred_name(Handle<String> inferred_name) {
2501     DCHECK(!inferred_name.is_null());
2502     inferred_name_ = inferred_name;
2503     DCHECK(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
2504     raw_inferred_name_ = NULL;
2505   }
2506
2507   void set_raw_inferred_name(const AstString* raw_inferred_name) {
2508     DCHECK(raw_inferred_name != NULL);
2509     raw_inferred_name_ = raw_inferred_name;
2510     DCHECK(inferred_name_.is_null());
2511     inferred_name_ = Handle<String>();
2512   }
2513
2514   bool pretenure() { return Pretenure::decode(bitfield_); }
2515   void set_pretenure() { bitfield_ |= Pretenure::encode(true); }
2516
2517   bool has_duplicate_parameters() {
2518     return HasDuplicateParameters::decode(bitfield_);
2519   }
2520
2521   bool is_function() { return IsFunction::decode(bitfield_) == kIsFunction; }
2522
2523   // This is used as a heuristic on when to eagerly compile a function
2524   // literal. We consider the following constructs as hints that the
2525   // function will be called immediately:
2526   // - (function() { ... })();
2527   // - var x = function() { ... }();
2528   bool should_eager_compile() const {
2529     return EagerCompileHintBit::decode(bitfield_) == kShouldEagerCompile;
2530   }
2531   void set_should_eager_compile() {
2532     bitfield_ = EagerCompileHintBit::update(bitfield_, kShouldEagerCompile);
2533   }
2534
2535   // A hint that we expect this function to be called (exactly) once,
2536   // i.e. we suspect it's an initialization function.
2537   bool should_be_used_once_hint() const {
2538     return ShouldBeUsedOnceHintBit::decode(bitfield_) == kShouldBeUsedOnce;
2539   }
2540   void set_should_be_used_once_hint() {
2541     bitfield_ = ShouldBeUsedOnceHintBit::update(bitfield_, kShouldBeUsedOnce);
2542   }
2543
2544   FunctionKind kind() const { return FunctionKindBits::decode(bitfield_); }
2545
2546   int ast_node_count() { return ast_properties_.node_count(); }
2547   AstProperties::Flags flags() const { return ast_properties_.flags(); }
2548   void set_ast_properties(AstProperties* ast_properties) {
2549     ast_properties_ = *ast_properties;
2550   }
2551   const FeedbackVectorSpec* feedback_vector_spec() const {
2552     return ast_properties_.get_spec();
2553   }
2554   bool dont_optimize() { return dont_optimize_reason_ != kNoReason; }
2555   BailoutReason dont_optimize_reason() { return dont_optimize_reason_; }
2556   void set_dont_optimize_reason(BailoutReason reason) {
2557     dont_optimize_reason_ = reason;
2558   }
2559
2560  protected:
2561   FunctionLiteral(Zone* zone, const AstRawString* name,
2562                   AstValueFactory* ast_value_factory, Scope* scope,
2563                   ZoneList<Statement*>* body, int materialized_literal_count,
2564                   int expected_property_count, int parameter_count,
2565                   FunctionType function_type,
2566                   ParameterFlag has_duplicate_parameters,
2567                   IsFunctionFlag is_function,
2568                   EagerCompileHint eager_compile_hint, FunctionKind kind,
2569                   int position)
2570       : Expression(zone, position),
2571         raw_name_(name),
2572         scope_(scope),
2573         body_(body),
2574         raw_inferred_name_(ast_value_factory->empty_string()),
2575         ast_properties_(zone),
2576         dont_optimize_reason_(kNoReason),
2577         materialized_literal_count_(materialized_literal_count),
2578         expected_property_count_(expected_property_count),
2579         parameter_count_(parameter_count),
2580         function_token_position_(RelocInfo::kNoPosition) {
2581     bitfield_ = IsExpression::encode(function_type != DECLARATION) |
2582                 IsAnonymous::encode(function_type == ANONYMOUS_EXPRESSION) |
2583                 Pretenure::encode(false) |
2584                 HasDuplicateParameters::encode(has_duplicate_parameters) |
2585                 IsFunction::encode(is_function) |
2586                 EagerCompileHintBit::encode(eager_compile_hint) |
2587                 FunctionKindBits::encode(kind) |
2588                 ShouldBeUsedOnceHintBit::encode(kDontKnowIfShouldBeUsedOnce);
2589     DCHECK(IsValidFunctionKind(kind));
2590   }
2591
2592  private:
2593   const AstRawString* raw_name_;
2594   Handle<String> name_;
2595   Scope* scope_;
2596   ZoneList<Statement*>* body_;
2597   const AstString* raw_inferred_name_;
2598   Handle<String> inferred_name_;
2599   AstProperties ast_properties_;
2600   BailoutReason dont_optimize_reason_;
2601
2602   int materialized_literal_count_;
2603   int expected_property_count_;
2604   int parameter_count_;
2605   int function_token_position_;
2606
2607   unsigned bitfield_;
2608   class IsExpression : public BitField<bool, 0, 1> {};
2609   class IsAnonymous : public BitField<bool, 1, 1> {};
2610   class Pretenure : public BitField<bool, 2, 1> {};
2611   class HasDuplicateParameters : public BitField<ParameterFlag, 3, 1> {};
2612   class IsFunction : public BitField<IsFunctionFlag, 4, 1> {};
2613   class EagerCompileHintBit : public BitField<EagerCompileHint, 5, 1> {};
2614   class FunctionKindBits : public BitField<FunctionKind, 6, 8> {};
2615   class ShouldBeUsedOnceHintBit : public BitField<ShouldBeUsedOnceHint, 15, 1> {
2616   };
2617 };
2618
2619
2620 class ClassLiteral final : public Expression {
2621  public:
2622   typedef ObjectLiteralProperty Property;
2623
2624   DECLARE_NODE_TYPE(ClassLiteral)
2625
2626   Handle<String> name() const { return raw_name_->string(); }
2627   const AstRawString* raw_name() const { return raw_name_; }
2628   Scope* scope() const { return scope_; }
2629   VariableProxy* class_variable_proxy() const { return class_variable_proxy_; }
2630   Expression* extends() const { return extends_; }
2631   FunctionLiteral* constructor() const { return constructor_; }
2632   ZoneList<Property*>* properties() const { return properties_; }
2633   int start_position() const { return position(); }
2634   int end_position() const { return end_position_; }
2635
2636   BailoutId EntryId() const { return BailoutId(local_id(0)); }
2637   BailoutId DeclsId() const { return BailoutId(local_id(1)); }
2638   BailoutId ExitId() { return BailoutId(local_id(2)); }
2639   BailoutId CreateLiteralId() const { return BailoutId(local_id(3)); }
2640
2641   // Return an AST id for a property that is used in simulate instructions.
2642   BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 4)); }
2643
2644   // Unlike other AST nodes, this number of bailout IDs allocated for an
2645   // ClassLiteral can vary, so num_ids() is not a static method.
2646   int num_ids() const { return parent_num_ids() + 4 + properties()->length(); }
2647
2648   // Object literals need one feedback slot for each non-trivial value, as well
2649   // as some slots for home objects.
2650   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
2651                                  ICSlotCache* cache) override;
2652
2653   bool NeedsProxySlot() const {
2654     return FLAG_vector_stores && scope() != NULL &&
2655            class_variable_proxy()->var()->IsUnallocated();
2656   }
2657
2658   FeedbackVectorICSlot ProxySlot() const { return slot_; }
2659
2660  protected:
2661   ClassLiteral(Zone* zone, const AstRawString* name, Scope* scope,
2662                VariableProxy* class_variable_proxy, Expression* extends,
2663                FunctionLiteral* constructor, ZoneList<Property*>* properties,
2664                int start_position, int end_position)
2665       : Expression(zone, start_position),
2666         raw_name_(name),
2667         scope_(scope),
2668         class_variable_proxy_(class_variable_proxy),
2669         extends_(extends),
2670         constructor_(constructor),
2671         properties_(properties),
2672         end_position_(end_position),
2673         slot_(FeedbackVectorICSlot::Invalid()) {
2674   }
2675
2676   static int parent_num_ids() { return Expression::num_ids(); }
2677
2678  private:
2679   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
2680
2681   const AstRawString* raw_name_;
2682   Scope* scope_;
2683   VariableProxy* class_variable_proxy_;
2684   Expression* extends_;
2685   FunctionLiteral* constructor_;
2686   ZoneList<Property*>* properties_;
2687   int end_position_;
2688   FeedbackVectorICSlot slot_;
2689 };
2690
2691
2692 class NativeFunctionLiteral final : public Expression {
2693  public:
2694   DECLARE_NODE_TYPE(NativeFunctionLiteral)
2695
2696   Handle<String> name() const { return name_->string(); }
2697   v8::Extension* extension() const { return extension_; }
2698
2699  protected:
2700   NativeFunctionLiteral(Zone* zone, const AstRawString* name,
2701                         v8::Extension* extension, int pos)
2702       : Expression(zone, pos), name_(name), extension_(extension) {}
2703
2704  private:
2705   const AstRawString* name_;
2706   v8::Extension* extension_;
2707 };
2708
2709
2710 class ThisFunction final : public Expression {
2711  public:
2712   DECLARE_NODE_TYPE(ThisFunction)
2713
2714  protected:
2715   ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
2716 };
2717
2718
2719 class SuperPropertyReference final : public Expression {
2720  public:
2721   DECLARE_NODE_TYPE(SuperPropertyReference)
2722
2723   VariableProxy* this_var() const { return this_var_; }
2724   Expression* home_object() const { return home_object_; }
2725
2726  protected:
2727   SuperPropertyReference(Zone* zone, VariableProxy* this_var,
2728                          Expression* home_object, int pos)
2729       : Expression(zone, pos), this_var_(this_var), home_object_(home_object) {
2730     DCHECK(this_var->is_this());
2731     DCHECK(home_object->IsProperty());
2732   }
2733
2734  private:
2735   VariableProxy* this_var_;
2736   Expression* home_object_;
2737 };
2738
2739
2740 class SuperCallReference final : public Expression {
2741  public:
2742   DECLARE_NODE_TYPE(SuperCallReference)
2743
2744   VariableProxy* this_var() const { return this_var_; }
2745   VariableProxy* new_target_var() const { return new_target_var_; }
2746   VariableProxy* this_function_var() const { return this_function_var_; }
2747
2748  protected:
2749   SuperCallReference(Zone* zone, VariableProxy* this_var,
2750                      VariableProxy* new_target_var,
2751                      VariableProxy* this_function_var, int pos)
2752       : Expression(zone, pos),
2753         this_var_(this_var),
2754         new_target_var_(new_target_var),
2755         this_function_var_(this_function_var) {
2756     DCHECK(this_var->is_this());
2757     DCHECK(new_target_var->raw_name()->IsOneByteEqualTo(".new.target"));
2758     DCHECK(this_function_var->raw_name()->IsOneByteEqualTo(".this_function"));
2759   }
2760
2761  private:
2762   VariableProxy* this_var_;
2763   VariableProxy* new_target_var_;
2764   VariableProxy* this_function_var_;
2765 };
2766
2767
2768 // This class is produced when parsing the () in arrow functions without any
2769 // arguments and is not actually a valid expression.
2770 class EmptyParentheses final : public Expression {
2771  public:
2772   DECLARE_NODE_TYPE(EmptyParentheses)
2773
2774  private:
2775   EmptyParentheses(Zone* zone, int pos) : Expression(zone, pos) {}
2776 };
2777
2778
2779 #undef DECLARE_NODE_TYPE
2780
2781
2782 // ----------------------------------------------------------------------------
2783 // Regular expressions
2784
2785
2786 class RegExpVisitor BASE_EMBEDDED {
2787  public:
2788   virtual ~RegExpVisitor() { }
2789 #define MAKE_CASE(Name)                                              \
2790   virtual void* Visit##Name(RegExp##Name*, void* data) = 0;
2791   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
2792 #undef MAKE_CASE
2793 };
2794
2795
2796 class RegExpTree : public ZoneObject {
2797  public:
2798   static const int kInfinity = kMaxInt;
2799   virtual ~RegExpTree() {}
2800   virtual void* Accept(RegExpVisitor* visitor, void* data) = 0;
2801   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2802                              RegExpNode* on_success) = 0;
2803   virtual bool IsTextElement() { return false; }
2804   virtual bool IsAnchoredAtStart() { return false; }
2805   virtual bool IsAnchoredAtEnd() { return false; }
2806   virtual int min_match() = 0;
2807   virtual int max_match() = 0;
2808   // Returns the interval of registers used for captures within this
2809   // expression.
2810   virtual Interval CaptureRegisters() { return Interval::Empty(); }
2811   virtual void AppendToText(RegExpText* text, Zone* zone);
2812   std::ostream& Print(std::ostream& os, Zone* zone);  // NOLINT
2813 #define MAKE_ASTYPE(Name)                                                  \
2814   virtual RegExp##Name* As##Name();                                        \
2815   virtual bool Is##Name();
2816   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ASTYPE)
2817 #undef MAKE_ASTYPE
2818 };
2819
2820
2821 class RegExpDisjunction final : public RegExpTree {
2822  public:
2823   explicit RegExpDisjunction(ZoneList<RegExpTree*>* alternatives);
2824   void* Accept(RegExpVisitor* visitor, void* data) override;
2825   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2826                              RegExpNode* on_success) override;
2827   RegExpDisjunction* AsDisjunction() override;
2828   Interval CaptureRegisters() override;
2829   bool IsDisjunction() override;
2830   bool IsAnchoredAtStart() override;
2831   bool IsAnchoredAtEnd() override;
2832   int min_match() override { return min_match_; }
2833   int max_match() override { return max_match_; }
2834   ZoneList<RegExpTree*>* alternatives() { return alternatives_; }
2835  private:
2836   bool SortConsecutiveAtoms(RegExpCompiler* compiler);
2837   void RationalizeConsecutiveAtoms(RegExpCompiler* compiler);
2838   void FixSingleCharacterDisjunctions(RegExpCompiler* compiler);
2839   ZoneList<RegExpTree*>* alternatives_;
2840   int min_match_;
2841   int max_match_;
2842 };
2843
2844
2845 class RegExpAlternative final : public RegExpTree {
2846  public:
2847   explicit RegExpAlternative(ZoneList<RegExpTree*>* nodes);
2848   void* Accept(RegExpVisitor* visitor, void* data) override;
2849   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2850                              RegExpNode* on_success) override;
2851   RegExpAlternative* AsAlternative() override;
2852   Interval CaptureRegisters() override;
2853   bool IsAlternative() override;
2854   bool IsAnchoredAtStart() override;
2855   bool IsAnchoredAtEnd() override;
2856   int min_match() override { return min_match_; }
2857   int max_match() override { return max_match_; }
2858   ZoneList<RegExpTree*>* nodes() { return nodes_; }
2859  private:
2860   ZoneList<RegExpTree*>* nodes_;
2861   int min_match_;
2862   int max_match_;
2863 };
2864
2865
2866 class RegExpAssertion final : public RegExpTree {
2867  public:
2868   enum AssertionType {
2869     START_OF_LINE,
2870     START_OF_INPUT,
2871     END_OF_LINE,
2872     END_OF_INPUT,
2873     BOUNDARY,
2874     NON_BOUNDARY
2875   };
2876   explicit RegExpAssertion(AssertionType type) : assertion_type_(type) { }
2877   void* Accept(RegExpVisitor* visitor, void* data) override;
2878   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2879                              RegExpNode* on_success) override;
2880   RegExpAssertion* AsAssertion() override;
2881   bool IsAssertion() override;
2882   bool IsAnchoredAtStart() override;
2883   bool IsAnchoredAtEnd() override;
2884   int min_match() override { return 0; }
2885   int max_match() override { return 0; }
2886   AssertionType assertion_type() { return assertion_type_; }
2887  private:
2888   AssertionType assertion_type_;
2889 };
2890
2891
2892 class CharacterSet final BASE_EMBEDDED {
2893  public:
2894   explicit CharacterSet(uc16 standard_set_type)
2895       : ranges_(NULL),
2896         standard_set_type_(standard_set_type) {}
2897   explicit CharacterSet(ZoneList<CharacterRange>* ranges)
2898       : ranges_(ranges),
2899         standard_set_type_(0) {}
2900   ZoneList<CharacterRange>* ranges(Zone* zone);
2901   uc16 standard_set_type() { return standard_set_type_; }
2902   void set_standard_set_type(uc16 special_set_type) {
2903     standard_set_type_ = special_set_type;
2904   }
2905   bool is_standard() { return standard_set_type_ != 0; }
2906   void Canonicalize();
2907  private:
2908   ZoneList<CharacterRange>* ranges_;
2909   // If non-zero, the value represents a standard set (e.g., all whitespace
2910   // characters) without having to expand the ranges.
2911   uc16 standard_set_type_;
2912 };
2913
2914
2915 class RegExpCharacterClass final : public RegExpTree {
2916  public:
2917   RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
2918       : set_(ranges),
2919         is_negated_(is_negated) { }
2920   explicit RegExpCharacterClass(uc16 type)
2921       : set_(type),
2922         is_negated_(false) { }
2923   void* Accept(RegExpVisitor* visitor, void* data) override;
2924   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2925                              RegExpNode* on_success) override;
2926   RegExpCharacterClass* AsCharacterClass() override;
2927   bool IsCharacterClass() override;
2928   bool IsTextElement() override { return true; }
2929   int min_match() override { return 1; }
2930   int max_match() override { return 1; }
2931   void AppendToText(RegExpText* text, Zone* zone) override;
2932   CharacterSet character_set() { return set_; }
2933   // TODO(lrn): Remove need for complex version if is_standard that
2934   // recognizes a mangled standard set and just do { return set_.is_special(); }
2935   bool is_standard(Zone* zone);
2936   // Returns a value representing the standard character set if is_standard()
2937   // returns true.
2938   // Currently used values are:
2939   // s : unicode whitespace
2940   // S : unicode non-whitespace
2941   // w : ASCII word character (digit, letter, underscore)
2942   // W : non-ASCII word character
2943   // d : ASCII digit
2944   // D : non-ASCII digit
2945   // . : non-unicode non-newline
2946   // * : All characters
2947   uc16 standard_type() { return set_.standard_set_type(); }
2948   ZoneList<CharacterRange>* ranges(Zone* zone) { return set_.ranges(zone); }
2949   bool is_negated() { return is_negated_; }
2950
2951  private:
2952   CharacterSet set_;
2953   bool is_negated_;
2954 };
2955
2956
2957 class RegExpAtom final : public RegExpTree {
2958  public:
2959   explicit RegExpAtom(Vector<const uc16> data) : data_(data) { }
2960   void* Accept(RegExpVisitor* visitor, void* data) override;
2961   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2962                              RegExpNode* on_success) override;
2963   RegExpAtom* AsAtom() override;
2964   bool IsAtom() override;
2965   bool IsTextElement() override { return true; }
2966   int min_match() override { return data_.length(); }
2967   int max_match() override { return data_.length(); }
2968   void AppendToText(RegExpText* text, Zone* zone) override;
2969   Vector<const uc16> data() { return data_; }
2970   int length() { return data_.length(); }
2971  private:
2972   Vector<const uc16> data_;
2973 };
2974
2975
2976 class RegExpText final : public RegExpTree {
2977  public:
2978   explicit RegExpText(Zone* zone) : elements_(2, zone), length_(0) {}
2979   void* Accept(RegExpVisitor* visitor, void* data) override;
2980   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
2981                              RegExpNode* on_success) override;
2982   RegExpText* AsText() override;
2983   bool IsText() override;
2984   bool IsTextElement() override { return true; }
2985   int min_match() override { return length_; }
2986   int max_match() override { return length_; }
2987   void AppendToText(RegExpText* text, Zone* zone) override;
2988   void AddElement(TextElement elm, Zone* zone)  {
2989     elements_.Add(elm, zone);
2990     length_ += elm.length();
2991   }
2992   ZoneList<TextElement>* elements() { return &elements_; }
2993  private:
2994   ZoneList<TextElement> elements_;
2995   int length_;
2996 };
2997
2998
2999 class RegExpQuantifier final : public RegExpTree {
3000  public:
3001   enum QuantifierType { GREEDY, NON_GREEDY, POSSESSIVE };
3002   RegExpQuantifier(int min, int max, QuantifierType type, RegExpTree* body)
3003       : body_(body),
3004         min_(min),
3005         max_(max),
3006         min_match_(min * body->min_match()),
3007         quantifier_type_(type) {
3008     if (max > 0 && body->max_match() > kInfinity / max) {
3009       max_match_ = kInfinity;
3010     } else {
3011       max_match_ = max * body->max_match();
3012     }
3013   }
3014   void* Accept(RegExpVisitor* visitor, void* data) override;
3015   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
3016                              RegExpNode* on_success) override;
3017   static RegExpNode* ToNode(int min,
3018                             int max,
3019                             bool is_greedy,
3020                             RegExpTree* body,
3021                             RegExpCompiler* compiler,
3022                             RegExpNode* on_success,
3023                             bool not_at_start = false);
3024   RegExpQuantifier* AsQuantifier() override;
3025   Interval CaptureRegisters() override;
3026   bool IsQuantifier() override;
3027   int min_match() override { return min_match_; }
3028   int max_match() override { return max_match_; }
3029   int min() { return min_; }
3030   int max() { return max_; }
3031   bool is_possessive() { return quantifier_type_ == POSSESSIVE; }
3032   bool is_non_greedy() { return quantifier_type_ == NON_GREEDY; }
3033   bool is_greedy() { return quantifier_type_ == GREEDY; }
3034   RegExpTree* body() { return body_; }
3035
3036  private:
3037   RegExpTree* body_;
3038   int min_;
3039   int max_;
3040   int min_match_;
3041   int max_match_;
3042   QuantifierType quantifier_type_;
3043 };
3044
3045
3046 class RegExpCapture final : public RegExpTree {
3047  public:
3048   explicit RegExpCapture(RegExpTree* body, int index)
3049       : body_(body), index_(index) { }
3050   void* Accept(RegExpVisitor* visitor, void* data) override;
3051   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
3052                              RegExpNode* on_success) override;
3053   static RegExpNode* ToNode(RegExpTree* body,
3054                             int index,
3055                             RegExpCompiler* compiler,
3056                             RegExpNode* on_success);
3057   RegExpCapture* AsCapture() override;
3058   bool IsAnchoredAtStart() override;
3059   bool IsAnchoredAtEnd() override;
3060   Interval CaptureRegisters() override;
3061   bool IsCapture() override;
3062   int min_match() override { return body_->min_match(); }
3063   int max_match() override { return body_->max_match(); }
3064   RegExpTree* body() { return body_; }
3065   int index() { return index_; }
3066   static int StartRegister(int index) { return index * 2; }
3067   static int EndRegister(int index) { return index * 2 + 1; }
3068
3069  private:
3070   RegExpTree* body_;
3071   int index_;
3072 };
3073
3074
3075 class RegExpLookahead final : public RegExpTree {
3076  public:
3077   RegExpLookahead(RegExpTree* body,
3078                   bool is_positive,
3079                   int capture_count,
3080                   int capture_from)
3081       : body_(body),
3082         is_positive_(is_positive),
3083         capture_count_(capture_count),
3084         capture_from_(capture_from) { }
3085
3086   void* Accept(RegExpVisitor* visitor, void* data) override;
3087   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
3088                              RegExpNode* on_success) override;
3089   RegExpLookahead* AsLookahead() override;
3090   Interval CaptureRegisters() override;
3091   bool IsLookahead() override;
3092   bool IsAnchoredAtStart() override;
3093   int min_match() override { return 0; }
3094   int max_match() override { return 0; }
3095   RegExpTree* body() { return body_; }
3096   bool is_positive() { return is_positive_; }
3097   int capture_count() { return capture_count_; }
3098   int capture_from() { return capture_from_; }
3099
3100  private:
3101   RegExpTree* body_;
3102   bool is_positive_;
3103   int capture_count_;
3104   int capture_from_;
3105 };
3106
3107
3108 class RegExpBackReference final : public RegExpTree {
3109  public:
3110   explicit RegExpBackReference(RegExpCapture* capture)
3111       : capture_(capture) { }
3112   void* Accept(RegExpVisitor* visitor, void* data) override;
3113   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
3114                              RegExpNode* on_success) override;
3115   RegExpBackReference* AsBackReference() override;
3116   bool IsBackReference() override;
3117   int min_match() override { return 0; }
3118   int max_match() override { return capture_->max_match(); }
3119   int index() { return capture_->index(); }
3120   RegExpCapture* capture() { return capture_; }
3121  private:
3122   RegExpCapture* capture_;
3123 };
3124
3125
3126 class RegExpEmpty final : public RegExpTree {
3127  public:
3128   RegExpEmpty() { }
3129   void* Accept(RegExpVisitor* visitor, void* data) override;
3130   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
3131                              RegExpNode* on_success) override;
3132   RegExpEmpty* AsEmpty() override;
3133   bool IsEmpty() override;
3134   int min_match() override { return 0; }
3135   int max_match() override { return 0; }
3136 };
3137
3138
3139 // ----------------------------------------------------------------------------
3140 // Basic visitor
3141 // - leaf node visitors are abstract.
3142
3143 class AstVisitor BASE_EMBEDDED {
3144  public:
3145   AstVisitor() {}
3146   virtual ~AstVisitor() {}
3147
3148   // Stack overflow check and dynamic dispatch.
3149   virtual void Visit(AstNode* node) = 0;
3150
3151   // Iteration left-to-right.
3152   virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
3153   virtual void VisitStatements(ZoneList<Statement*>* statements);
3154   virtual void VisitExpressions(ZoneList<Expression*>* expressions);
3155
3156   // Individual AST nodes.
3157 #define DEF_VISIT(type)                         \
3158   virtual void Visit##type(type* node) = 0;
3159   AST_NODE_LIST(DEF_VISIT)
3160 #undef DEF_VISIT
3161 };
3162
3163
3164 #define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
3165  public:                                                    \
3166   void Visit(AstNode* node) final {                         \
3167     if (!CheckStackOverflow()) node->Accept(this);          \
3168   }                                                         \
3169                                                             \
3170   void SetStackOverflow() { stack_overflow_ = true; }       \
3171   void ClearStackOverflow() { stack_overflow_ = false; }    \
3172   bool HasStackOverflow() const { return stack_overflow_; } \
3173                                                             \
3174   bool CheckStackOverflow() {                               \
3175     if (stack_overflow_) return true;                       \
3176     StackLimitCheck check(isolate_);                        \
3177     if (!check.HasOverflowed()) return false;               \
3178     stack_overflow_ = true;                                 \
3179     return true;                                            \
3180   }                                                         \
3181                                                             \
3182  private:                                                   \
3183   void InitializeAstVisitor(Isolate* isolate, Zone* zone) { \
3184     isolate_ = isolate;                                     \
3185     zone_ = zone;                                           \
3186     stack_overflow_ = false;                                \
3187   }                                                         \
3188   Zone* zone() { return zone_; }                            \
3189   Isolate* isolate() { return isolate_; }                   \
3190                                                             \
3191   Isolate* isolate_;                                        \
3192   Zone* zone_;                                              \
3193   bool stack_overflow_
3194
3195
3196 // ----------------------------------------------------------------------------
3197 // AstNode factory
3198
3199 class AstNodeFactory final BASE_EMBEDDED {
3200  public:
3201   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
3202       : local_zone_(ast_value_factory->zone()),
3203         parser_zone_(ast_value_factory->zone()),
3204         ast_value_factory_(ast_value_factory) {}
3205
3206   VariableDeclaration* NewVariableDeclaration(
3207       VariableProxy* proxy, VariableMode mode, Scope* scope, int pos,
3208       bool is_class_declaration = false, int declaration_group_start = -1) {
3209     return new (parser_zone_)
3210         VariableDeclaration(parser_zone_, proxy, mode, scope, pos,
3211                             is_class_declaration, declaration_group_start);
3212   }
3213
3214   FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
3215                                               VariableMode mode,
3216                                               FunctionLiteral* fun,
3217                                               Scope* scope,
3218                                               int pos) {
3219     return new (parser_zone_)
3220         FunctionDeclaration(parser_zone_, proxy, mode, fun, scope, pos);
3221   }
3222
3223   ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,
3224                                           const AstRawString* import_name,
3225                                           const AstRawString* module_specifier,
3226                                           Scope* scope, int pos) {
3227     return new (parser_zone_) ImportDeclaration(
3228         parser_zone_, proxy, import_name, module_specifier, scope, pos);
3229   }
3230
3231   ExportDeclaration* NewExportDeclaration(VariableProxy* proxy,
3232                                           Scope* scope,
3233                                           int pos) {
3234     return new (parser_zone_)
3235         ExportDeclaration(parser_zone_, proxy, scope, pos);
3236   }
3237
3238   Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
3239                   bool ignore_completion_value, int pos) {
3240     return new (local_zone_)
3241         Block(local_zone_, labels, capacity, ignore_completion_value, pos);
3242   }
3243
3244 #define STATEMENT_WITH_LABELS(NodeType)                                     \
3245   NodeType* New##NodeType(ZoneList<const AstRawString*>* labels, int pos) { \
3246     return new (local_zone_) NodeType(local_zone_, labels, pos);            \
3247   }
3248   STATEMENT_WITH_LABELS(DoWhileStatement)
3249   STATEMENT_WITH_LABELS(WhileStatement)
3250   STATEMENT_WITH_LABELS(ForStatement)
3251   STATEMENT_WITH_LABELS(SwitchStatement)
3252 #undef STATEMENT_WITH_LABELS
3253
3254   ForEachStatement* NewForEachStatement(ForEachStatement::VisitMode visit_mode,
3255                                         ZoneList<const AstRawString*>* labels,
3256                                         int pos) {
3257     switch (visit_mode) {
3258       case ForEachStatement::ENUMERATE: {
3259         return new (local_zone_) ForInStatement(local_zone_, labels, pos);
3260       }
3261       case ForEachStatement::ITERATE: {
3262         return new (local_zone_) ForOfStatement(local_zone_, labels, pos);
3263       }
3264     }
3265     UNREACHABLE();
3266     return NULL;
3267   }
3268
3269   ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
3270     return new (local_zone_) ExpressionStatement(local_zone_, expression, pos);
3271   }
3272
3273   ContinueStatement* NewContinueStatement(IterationStatement* target, int pos) {
3274     return new (local_zone_) ContinueStatement(local_zone_, target, pos);
3275   }
3276
3277   BreakStatement* NewBreakStatement(BreakableStatement* target, int pos) {
3278     return new (local_zone_) BreakStatement(local_zone_, target, pos);
3279   }
3280
3281   ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
3282     return new (local_zone_) ReturnStatement(local_zone_, expression, pos);
3283   }
3284
3285   WithStatement* NewWithStatement(Scope* scope,
3286                                   Expression* expression,
3287                                   Statement* statement,
3288                                   int pos) {
3289     return new (local_zone_)
3290         WithStatement(local_zone_, scope, expression, statement, pos);
3291   }
3292
3293   IfStatement* NewIfStatement(Expression* condition,
3294                               Statement* then_statement,
3295                               Statement* else_statement,
3296                               int pos) {
3297     return new (local_zone_) IfStatement(local_zone_, condition, then_statement,
3298                                          else_statement, pos);
3299   }
3300
3301   TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
3302                                           Variable* variable,
3303                                           Block* catch_block, int pos) {
3304     return new (local_zone_) TryCatchStatement(local_zone_, try_block, scope,
3305                                                variable, catch_block, pos);
3306   }
3307
3308   TryFinallyStatement* NewTryFinallyStatement(Block* try_block,
3309                                               Block* finally_block, int pos) {
3310     return new (local_zone_)
3311         TryFinallyStatement(local_zone_, try_block, finally_block, pos);
3312   }
3313
3314   DebuggerStatement* NewDebuggerStatement(int pos) {
3315     return new (local_zone_) DebuggerStatement(local_zone_, pos);
3316   }
3317
3318   EmptyStatement* NewEmptyStatement(int pos) {
3319     return new (local_zone_) EmptyStatement(local_zone_, pos);
3320   }
3321
3322   SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(
3323       Statement* statement, Scope* scope) {
3324     return new (local_zone_)
3325         SloppyBlockFunctionStatement(local_zone_, statement, scope);
3326   }
3327
3328   CaseClause* NewCaseClause(
3329       Expression* label, ZoneList<Statement*>* statements, int pos) {
3330     return new (local_zone_) CaseClause(local_zone_, label, statements, pos);
3331   }
3332
3333   Literal* NewStringLiteral(const AstRawString* string, int pos) {
3334     return new (local_zone_)
3335         Literal(local_zone_, ast_value_factory_->NewString(string), pos);
3336   }
3337
3338   // A JavaScript symbol (ECMA-262 edition 6).
3339   Literal* NewSymbolLiteral(const char* name, int pos) {
3340     return new (local_zone_)
3341         Literal(local_zone_, ast_value_factory_->NewSymbol(name), pos);
3342   }
3343
3344   Literal* NewNumberLiteral(double number, int pos, bool with_dot = false) {
3345     return new (local_zone_) Literal(
3346         local_zone_, ast_value_factory_->NewNumber(number, with_dot), pos);
3347   }
3348
3349   Literal* NewSmiLiteral(int number, int pos) {
3350     return new (local_zone_)
3351         Literal(local_zone_, ast_value_factory_->NewSmi(number), pos);
3352   }
3353
3354   Literal* NewBooleanLiteral(bool b, int pos) {
3355     return new (local_zone_)
3356         Literal(local_zone_, ast_value_factory_->NewBoolean(b), pos);
3357   }
3358
3359   Literal* NewNullLiteral(int pos) {
3360     return new (local_zone_)
3361         Literal(local_zone_, ast_value_factory_->NewNull(), pos);
3362   }
3363
3364   Literal* NewUndefinedLiteral(int pos) {
3365     return new (local_zone_)
3366         Literal(local_zone_, ast_value_factory_->NewUndefined(), pos);
3367   }
3368
3369   Literal* NewTheHoleLiteral(int pos) {
3370     return new (local_zone_)
3371         Literal(local_zone_, ast_value_factory_->NewTheHole(), pos);
3372   }
3373
3374   ObjectLiteral* NewObjectLiteral(
3375       ZoneList<ObjectLiteral::Property*>* properties,
3376       int literal_index,
3377       int boilerplate_properties,
3378       bool has_function,
3379       bool is_strong,
3380       int pos) {
3381     return new (local_zone_)
3382         ObjectLiteral(local_zone_, properties, literal_index,
3383                       boilerplate_properties, has_function, is_strong, pos);
3384   }
3385
3386   ObjectLiteral::Property* NewObjectLiteralProperty(
3387       Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
3388       bool is_static, bool is_computed_name) {
3389     return new (local_zone_)
3390         ObjectLiteral::Property(key, value, kind, is_static, is_computed_name);
3391   }
3392
3393   ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
3394                                                     Expression* value,
3395                                                     bool is_static,
3396                                                     bool is_computed_name) {
3397     return new (local_zone_) ObjectLiteral::Property(
3398         ast_value_factory_, key, value, is_static, is_computed_name);
3399   }
3400
3401   RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern,
3402                                   const AstRawString* flags,
3403                                   int literal_index,
3404                                   bool is_strong,
3405                                   int pos) {
3406     return new (local_zone_) RegExpLiteral(local_zone_, pattern, flags,
3407                                            literal_index, is_strong, pos);
3408   }
3409
3410   ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3411                                 int literal_index,
3412                                 bool is_strong,
3413                                 int pos) {
3414     return new (local_zone_)
3415         ArrayLiteral(local_zone_, values, -1, literal_index, is_strong, pos);
3416   }
3417
3418   ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3419                                 int first_spread_index, int literal_index,
3420                                 bool is_strong, int pos) {
3421     return new (local_zone_) ArrayLiteral(
3422         local_zone_, values, first_spread_index, literal_index, is_strong, pos);
3423   }
3424
3425   VariableProxy* NewVariableProxy(Variable* var,
3426                                   int start_position = RelocInfo::kNoPosition,
3427                                   int end_position = RelocInfo::kNoPosition) {
3428     return new (parser_zone_)
3429         VariableProxy(parser_zone_, var, start_position, end_position);
3430   }
3431
3432   VariableProxy* NewVariableProxy(const AstRawString* name,
3433                                   Variable::Kind variable_kind,
3434                                   int start_position = RelocInfo::kNoPosition,
3435                                   int end_position = RelocInfo::kNoPosition) {
3436     DCHECK_NOT_NULL(name);
3437     return new (parser_zone_) VariableProxy(parser_zone_, name, variable_kind,
3438                                             start_position, end_position);
3439   }
3440
3441   Property* NewProperty(Expression* obj, Expression* key, int pos) {
3442     return new (local_zone_) Property(local_zone_, obj, key, pos);
3443   }
3444
3445   Call* NewCall(Expression* expression,
3446                 ZoneList<Expression*>* arguments,
3447                 int pos) {
3448     return new (local_zone_) Call(local_zone_, expression, arguments, pos);
3449   }
3450
3451   CallNew* NewCallNew(Expression* expression,
3452                       ZoneList<Expression*>* arguments,
3453                       int pos) {
3454     return new (local_zone_) CallNew(local_zone_, expression, arguments, pos);
3455   }
3456
3457   CallRuntime* NewCallRuntime(Runtime::FunctionId id,
3458                               ZoneList<Expression*>* arguments, int pos) {
3459     return new (local_zone_)
3460         CallRuntime(local_zone_, Runtime::FunctionForId(id), arguments, pos);
3461   }
3462
3463   CallRuntime* NewCallRuntime(const Runtime::Function* function,
3464                               ZoneList<Expression*>* arguments, int pos) {
3465     return new (local_zone_) CallRuntime(local_zone_, function, arguments, pos);
3466   }
3467
3468   CallRuntime* NewCallRuntime(int context_index,
3469                               ZoneList<Expression*>* arguments, int pos) {
3470     return new (local_zone_)
3471         CallRuntime(local_zone_, context_index, arguments, pos);
3472   }
3473
3474   UnaryOperation* NewUnaryOperation(Token::Value op,
3475                                     Expression* expression,
3476                                     int pos) {
3477     return new (local_zone_) UnaryOperation(local_zone_, op, expression, pos);
3478   }
3479
3480   BinaryOperation* NewBinaryOperation(Token::Value op,
3481                                       Expression* left,
3482                                       Expression* right,
3483                                       int pos) {
3484     return new (local_zone_) BinaryOperation(local_zone_, op, left, right, pos);
3485   }
3486
3487   CountOperation* NewCountOperation(Token::Value op,
3488                                     bool is_prefix,
3489                                     Expression* expr,
3490                                     int pos) {
3491     return new (local_zone_)
3492         CountOperation(local_zone_, op, is_prefix, expr, pos);
3493   }
3494
3495   CompareOperation* NewCompareOperation(Token::Value op,
3496                                         Expression* left,
3497                                         Expression* right,
3498                                         int pos) {
3499     return new (local_zone_)
3500         CompareOperation(local_zone_, op, left, right, pos);
3501   }
3502
3503   Spread* NewSpread(Expression* expression, int pos) {
3504     return new (local_zone_) Spread(local_zone_, expression, pos);
3505   }
3506
3507   Conditional* NewConditional(Expression* condition,
3508                               Expression* then_expression,
3509                               Expression* else_expression,
3510                               int position) {
3511     return new (local_zone_) Conditional(
3512         local_zone_, condition, then_expression, else_expression, position);
3513   }
3514
3515   Assignment* NewAssignment(Token::Value op,
3516                             Expression* target,
3517                             Expression* value,
3518                             int pos) {
3519     DCHECK(Token::IsAssignmentOp(op));
3520     Assignment* assign =
3521         new (local_zone_) Assignment(local_zone_, op, target, value, pos);
3522     if (assign->is_compound()) {
3523       DCHECK(Token::IsAssignmentOp(op));
3524       assign->binary_operation_ =
3525           NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
3526     }
3527     return assign;
3528   }
3529
3530   Yield* NewYield(Expression *generator_object,
3531                   Expression* expression,
3532                   Yield::Kind yield_kind,
3533                   int pos) {
3534     if (!expression) expression = NewUndefinedLiteral(pos);
3535     return new (local_zone_)
3536         Yield(local_zone_, generator_object, expression, yield_kind, pos);
3537   }
3538
3539   Throw* NewThrow(Expression* exception, int pos) {
3540     return new (local_zone_) Throw(local_zone_, exception, pos);
3541   }
3542
3543   FunctionLiteral* NewFunctionLiteral(
3544       const AstRawString* name, AstValueFactory* ast_value_factory,
3545       Scope* scope, ZoneList<Statement*>* body, int materialized_literal_count,
3546       int expected_property_count, int parameter_count,
3547       FunctionLiteral::ParameterFlag has_duplicate_parameters,
3548       FunctionLiteral::FunctionType function_type,
3549       FunctionLiteral::IsFunctionFlag is_function,
3550       FunctionLiteral::EagerCompileHint eager_compile_hint, FunctionKind kind,
3551       int position) {
3552     return new (parser_zone_) FunctionLiteral(
3553         parser_zone_, name, ast_value_factory, scope, body,
3554         materialized_literal_count, expected_property_count, parameter_count,
3555         function_type, has_duplicate_parameters, is_function,
3556         eager_compile_hint, kind, position);
3557   }
3558
3559   ClassLiteral* NewClassLiteral(const AstRawString* name, Scope* scope,
3560                                 VariableProxy* proxy, Expression* extends,
3561                                 FunctionLiteral* constructor,
3562                                 ZoneList<ObjectLiteral::Property*>* properties,
3563                                 int start_position, int end_position) {
3564     return new (parser_zone_)
3565         ClassLiteral(parser_zone_, name, scope, proxy, extends, constructor,
3566                      properties, start_position, end_position);
3567   }
3568
3569   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
3570                                                   v8::Extension* extension,
3571                                                   int pos) {
3572     return new (parser_zone_)
3573         NativeFunctionLiteral(parser_zone_, name, extension, pos);
3574   }
3575
3576   ThisFunction* NewThisFunction(int pos) {
3577     return new (local_zone_) ThisFunction(local_zone_, pos);
3578   }
3579
3580   SuperPropertyReference* NewSuperPropertyReference(VariableProxy* this_var,
3581                                                     Expression* home_object,
3582                                                     int pos) {
3583     return new (parser_zone_)
3584         SuperPropertyReference(parser_zone_, this_var, home_object, pos);
3585   }
3586
3587   SuperCallReference* NewSuperCallReference(VariableProxy* this_var,
3588                                             VariableProxy* new_target_var,
3589                                             VariableProxy* this_function_var,
3590                                             int pos) {
3591     return new (parser_zone_) SuperCallReference(
3592         parser_zone_, this_var, new_target_var, this_function_var, pos);
3593   }
3594
3595   EmptyParentheses* NewEmptyParentheses(int pos) {
3596     return new (local_zone_) EmptyParentheses(local_zone_, pos);
3597   }
3598
3599   Zone* zone() const { return local_zone_; }
3600
3601   // Handles use of temporary zones when parsing inner function bodies.
3602   class BodyScope {
3603    public:
3604     BodyScope(AstNodeFactory* factory, Zone* temp_zone, bool use_temp_zone)
3605         : factory_(factory), prev_zone_(factory->local_zone_) {
3606       if (use_temp_zone) {
3607         factory->local_zone_ = temp_zone;
3608       }
3609     }
3610
3611     ~BodyScope() { factory_->local_zone_ = prev_zone_; }
3612
3613    private:
3614     AstNodeFactory* factory_;
3615     Zone* prev_zone_;
3616   };
3617
3618  private:
3619   // This zone may be deallocated upon returning from parsing a function body
3620   // which we can guarantee is not going to be compiled or have its AST
3621   // inspected.
3622   // See ParseFunctionLiteral in parser.cc for preconditions.
3623   Zone* local_zone_;
3624   // ZoneObjects which need to persist until scope analysis must be allocated in
3625   // the parser-level zone.
3626   Zone* parser_zone_;
3627   AstValueFactory* ast_value_factory_;
3628 };
3629
3630
3631 } }  // namespace v8::internal
3632
3633 #endif  // V8_AST_H_