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