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