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