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