src/ast.h

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