src/ast.h

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