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