Add OVERRIDE and virtual where appropriate
[WebKit-https.git] / Source / JavaScriptCore / parser / Nodes.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
5  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
6  *  Copyright (C) 2007 Maks Orlovich
7  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
8  *
9  *  This library is free software; you can redistribute it and/or
10  *  modify it under the terms of the GNU Library General Public
11  *  License as published by the Free Software Foundation; either
12  *  version 2 of the License, or (at your option) any later version.
13  *
14  *  This library is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  Library General Public License for more details.
18  *
19  *  You should have received a copy of the GNU Library General Public License
20  *  along with this library; see the file COPYING.LIB.  If not, write to
21  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  *  Boston, MA 02110-1301, USA.
23  *
24  */
25
26 #ifndef Nodes_h
27 #define Nodes_h
28
29 #include "Error.h"
30 #include "JITCode.h"
31 #include "Opcode.h"
32 #include "ParserArena.h"
33 #include "ParserTokens.h"
34 #include "ResultType.h"
35 #include "SourceCode.h"
36 #include "SymbolTable.h"
37 #include <wtf/MathExtras.h>
38
39 namespace JSC {
40
41     class ArgumentListNode;
42     class BytecodeGenerator;
43     class FunctionBodyNode;
44     class Label;
45     class PropertyListNode;
46     class ReadModifyResolveNode;
47     class RegisterID;
48     class JSScope;
49     class ScopeNode;
50
51     enum Operator {
52         OpEqual,
53         OpPlusEq,
54         OpMinusEq,
55         OpMultEq,
56         OpDivEq,
57         OpPlusPlus,
58         OpMinusMinus,
59         OpAndEq,
60         OpXOrEq,
61         OpOrEq,
62         OpModEq,
63         OpLShift,
64         OpRShift,
65         OpURShift
66     };
67     
68     enum LogicalOperator {
69         OpLogicalAnd,
70         OpLogicalOr
71     };
72
73     enum FallThroughMode {
74         FallThroughMeansTrue = 0,
75         FallThroughMeansFalse = 1
76     };
77     inline FallThroughMode invert(FallThroughMode fallThroughMode) { return static_cast<FallThroughMode>(!fallThroughMode); }
78
79     typedef HashSet<RefPtr<StringImpl>, IdentifierRepHash> IdentifierSet;
80
81     namespace DeclarationStacks {
82         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
83         typedef Vector<std::pair<Identifier, unsigned> > VarStack;
84         typedef Vector<FunctionBodyNode*> FunctionStack;
85     }
86
87     struct SwitchInfo {
88         enum SwitchType { SwitchNone, SwitchImmediate, SwitchCharacter, SwitchString };
89         uint32_t bytecodeOffset;
90         SwitchType switchType;
91     };
92
93     class ParserArenaFreeable {
94     public:
95         // ParserArenaFreeable objects are are freed when the arena is deleted.
96         // Destructors are not called. Clients must not call delete on such objects.
97         void* operator new(size_t, VM*);
98     };
99
100     class ParserArenaDeletable {
101     public:
102         virtual ~ParserArenaDeletable() { }
103
104         // ParserArenaDeletable objects are deleted when the arena is deleted.
105         // Clients must not call delete directly on such objects.
106         void* operator new(size_t, VM*);
107     };
108
109     template <typename T>
110     struct ParserArenaData : ParserArenaDeletable {
111         T data;
112     };
113
114     class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {
115     protected:
116         ParserArenaRefCounted(VM*);
117
118     public:
119         virtual ~ParserArenaRefCounted()
120         {
121             ASSERT(deletionHasBegun());
122         }
123     };
124
125     class Node : public ParserArenaFreeable {
126     protected:
127         Node(const JSTokenLocation&);
128
129     public:
130         virtual ~Node() { }
131
132         int lineNo() const { return m_position.line; }
133         int startOffset() const { return m_position.offset; }
134         int lineStartOffset() const { return m_position.lineStartOffset; }
135         const JSTextPosition& position() const { return m_position; }
136
137     protected:
138         JSTextPosition m_position;
139     };
140
141     class ExpressionNode : public Node {
142     protected:
143         ExpressionNode(const JSTokenLocation&, ResultType = ResultType::unknownType());
144
145     public:
146         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
147
148         virtual bool isNumber() const { return false; }
149         virtual bool isString() const { return false; }
150         virtual bool isNull() const { return false; }
151         virtual bool isPure(BytecodeGenerator&) const { return false; }        
152         virtual bool isConstant() const { return false; }
153         virtual bool isLocation() const { return false; }
154         virtual bool isResolveNode() const { return false; }
155         virtual bool isBracketAccessorNode() const { return false; }
156         virtual bool isDotAccessorNode() const { return false; }
157         virtual bool isDeconstructionNode() const { return false; }
158         virtual bool isFuncExprNode() const { return false; }
159         virtual bool isCommaNode() const { return false; }
160         virtual bool isSimpleArray() const { return false; }
161         virtual bool isAdd() const { return false; }
162         virtual bool isSubtract() const { return false; }
163         virtual bool isBoolean() const { return false; }
164
165         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, FallThroughMode);
166
167         virtual ExpressionNode* stripUnaryPlus() { return this; }
168
169         ResultType resultDescriptor() const { return m_resultType; }
170
171     private:
172         ResultType m_resultType;
173     };
174
175     class StatementNode : public Node {
176     protected:
177         StatementNode(const JSTokenLocation&);
178
179     public:
180         virtual void emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
181
182         void setLoc(unsigned firstLine, unsigned lastLine, int startOffset, int lineStartOffset);
183         unsigned firstLine() const { return lineNo(); }
184         unsigned lastLine() const { return m_lastLine; }
185
186         virtual bool isEmptyStatement() const { return false; }
187         virtual bool isReturnNode() const { return false; }
188         virtual bool isExprStatement() const { return false; }
189         virtual bool isBreak() const { return false; }
190         virtual bool isContinue() const { return false; }
191         virtual bool isBlock() const { return false; }
192
193     private:
194         int m_lastLine;
195     };
196
197     class ConstantNode : public ExpressionNode {
198     public:
199         ConstantNode(const JSTokenLocation&, ResultType);
200         virtual bool isPure(BytecodeGenerator&) const OVERRIDE { return true; }
201         virtual bool isConstant() const  OVERRIDE { return true; }
202         virtual JSValue jsValue(BytecodeGenerator&) const = 0;
203     private:
204         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
205         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;
206     };
207
208     class NullNode : public ConstantNode {
209     public:
210         NullNode(const JSTokenLocation&);
211
212     private:
213         virtual bool isNull() const OVERRIDE { return true; }
214         virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsNull(); }
215     };
216
217     class BooleanNode : public ConstantNode {
218     public:
219         BooleanNode(const JSTokenLocation&, bool value);
220         bool value() { return m_value; }
221
222     private:
223         virtual bool isBoolean() const OVERRIDE { return true; }
224         virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsBoolean(m_value); }
225
226         bool m_value;
227     };
228
229     class NumberNode : public ConstantNode {
230     public:
231         NumberNode(const JSTokenLocation&, double value);
232         double value() { return m_value; }
233         void setValue(double value) { m_value = value; }
234
235     private:
236         virtual bool isNumber() const OVERRIDE { return true; }
237         virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE { return jsNumber(m_value); }
238
239         double m_value;
240     };
241
242     class StringNode : public ConstantNode {
243     public:
244         StringNode(const JSTokenLocation&, const Identifier&);
245         const Identifier& value() { return m_value; }
246
247     private:
248         virtual bool isString() const OVERRIDE { return true; }
249         virtual JSValue jsValue(BytecodeGenerator&) const OVERRIDE;
250
251         const Identifier& m_value;
252     };
253     
254     class ThrowableExpressionData {
255     public:
256         ThrowableExpressionData()
257             : m_divot(-1, -1, -1)
258             , m_divotStart(-1, -1, -1)
259             , m_divotEnd(-1, -1, -1)
260         {
261         }
262         
263         ThrowableExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)
264             : m_divot(divot)
265             , m_divotStart(start)
266             , m_divotEnd(end)
267         {
268             ASSERT(m_divot.offset >= m_divot.lineStartOffset);
269             ASSERT(m_divotStart.offset >= m_divotStart.lineStartOffset);
270             ASSERT(m_divotEnd.offset >= m_divotEnd.lineStartOffset);
271         }
272
273         void setExceptionSourceCode(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
274         {
275             ASSERT(divot.offset >= divot.lineStartOffset);
276             ASSERT(divotStart.offset >= divotStart.lineStartOffset);
277             ASSERT(divotEnd.offset >= divotEnd.lineStartOffset);
278             m_divot = divot;
279             m_divotStart = divotStart;
280             m_divotEnd = divotEnd;
281         }
282
283         const JSTextPosition& divot() const { return m_divot; }
284         const JSTextPosition& divotStart() const { return m_divotStart; }
285         const JSTextPosition& divotEnd() const { return m_divotEnd; }
286
287     protected:
288         RegisterID* emitThrowReferenceError(BytecodeGenerator&, const String& message);
289
290     private:
291         JSTextPosition m_divot;
292         JSTextPosition m_divotStart;
293         JSTextPosition m_divotEnd;
294     };
295
296     class ThrowableSubExpressionData : public ThrowableExpressionData {
297     public:
298         ThrowableSubExpressionData()
299             : m_subexpressionDivotOffset(0)
300             , m_subexpressionEndOffset(0)
301             , m_subexpressionLineOffset(0)
302             , m_subexpressionLineStartOffset(0)
303         {
304         }
305
306         ThrowableSubExpressionData(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
307             : ThrowableExpressionData(divot, divotStart, divotEnd)
308             , m_subexpressionDivotOffset(0)
309             , m_subexpressionEndOffset(0)
310             , m_subexpressionLineOffset(0)
311             , m_subexpressionLineStartOffset(0)
312         {
313         }
314
315         void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)
316         {
317             ASSERT(subexpressionDivot.offset <= divot().offset);
318             // Overflow means we can't do this safely, so just point at the primary divot,
319             // divotLine, or divotLineStart.
320             if ((divot() - subexpressionDivot.offset) & ~0xFFFF)
321                 return;
322             if ((divot().line - subexpressionDivot.line) & ~0xFFFF)
323                 return;
324             if ((divot().lineStartOffset - subexpressionDivot.lineStartOffset) & ~0xFFFF)
325                 return;
326             if ((divotEnd() - subexpressionOffset) & ~0xFFFF)
327                 return;
328             m_subexpressionDivotOffset = divot() - subexpressionDivot.offset;
329             m_subexpressionEndOffset = divotEnd() - subexpressionOffset;
330             m_subexpressionLineOffset = divot().line - subexpressionDivot.line;
331             m_subexpressionLineStartOffset = divot().lineStartOffset - subexpressionDivot.lineStartOffset;
332         }
333
334         JSTextPosition subexpressionDivot()
335         {
336             int newLine = divot().line - m_subexpressionLineOffset;
337             int newOffset = divot().offset - m_subexpressionDivotOffset;
338             int newLineStartOffset = divot().lineStartOffset - m_subexpressionLineStartOffset;
339             return JSTextPosition(newLine, newOffset, newLineStartOffset);
340         }
341         JSTextPosition subexpressionStart() { return divotStart(); }
342         JSTextPosition subexpressionEnd() { return divotEnd() - static_cast<int>(m_subexpressionEndOffset); }
343
344     protected:
345         uint16_t m_subexpressionDivotOffset;
346         uint16_t m_subexpressionEndOffset;
347         uint16_t m_subexpressionLineOffset;
348         uint16_t m_subexpressionLineStartOffset;
349     };
350     
351     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {
352     public:
353         ThrowablePrefixedSubExpressionData()
354             : m_subexpressionDivotOffset(0)
355             , m_subexpressionStartOffset(0)
356             , m_subexpressionLineOffset(0)
357             , m_subexpressionLineStartOffset(0)
358         {
359         }
360
361         ThrowablePrefixedSubExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)
362             : ThrowableExpressionData(divot, start, end)
363             , m_subexpressionDivotOffset(0)
364             , m_subexpressionStartOffset(0)
365             , m_subexpressionLineOffset(0)
366             , m_subexpressionLineStartOffset(0)
367         {
368         }
369
370         void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)
371         {
372             ASSERT(subexpressionDivot.offset >= divot().offset);
373             // Overflow means we can't do this safely, so just point at the primary divot,
374             // divotLine, or divotLineStart.
375             if ((subexpressionDivot.offset - divot()) & ~0xFFFF) 
376                 return;
377             if ((subexpressionDivot.line - divot().line) & ~0xFFFF)
378                 return;
379             if ((subexpressionDivot.lineStartOffset - divot().lineStartOffset) & ~0xFFFF)
380                 return;
381             if ((subexpressionOffset - divotStart()) & ~0xFFFF) 
382                 return;
383             m_subexpressionDivotOffset = subexpressionDivot.offset - divot();
384             m_subexpressionStartOffset = subexpressionOffset - divotStart();
385             m_subexpressionLineOffset = subexpressionDivot.line - divot().line;
386             m_subexpressionLineStartOffset = subexpressionDivot.lineStartOffset - divot().lineStartOffset;
387         }
388
389         JSTextPosition subexpressionDivot()
390         {
391             int newLine = divot().line + m_subexpressionLineOffset;
392             int newOffset = divot().offset + m_subexpressionDivotOffset;
393             int newLineStartOffset = divot().lineStartOffset + m_subexpressionLineStartOffset;
394             return JSTextPosition(newLine, newOffset, newLineStartOffset);
395         }
396         JSTextPosition subexpressionStart() { return divotStart() + static_cast<int>(m_subexpressionStartOffset); }
397         JSTextPosition subexpressionEnd() { return divotEnd(); }
398
399     protected:
400         uint16_t m_subexpressionDivotOffset;
401         uint16_t m_subexpressionStartOffset;
402         uint16_t m_subexpressionLineOffset;
403         uint16_t m_subexpressionLineStartOffset;
404     };
405
406     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
407     public:
408         RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);
409
410     private:
411         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
412
413         const Identifier& m_pattern;
414         const Identifier& m_flags;
415     };
416
417     class ThisNode : public ExpressionNode {
418     public:
419         ThisNode(const JSTokenLocation&);
420
421     private:
422         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
423     };
424
425     class ResolveNode : public ExpressionNode {
426     public:
427         ResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& start);
428
429         const Identifier& identifier() const { return m_ident; }
430
431     private:
432         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
433
434         virtual bool isPure(BytecodeGenerator&) const OVERRIDE;
435         virtual bool isLocation() const OVERRIDE { return true; }
436         virtual bool isResolveNode() const OVERRIDE { return true; }
437
438         const Identifier& m_ident;
439         JSTextPosition m_start;
440     };
441
442     class ElementNode : public ParserArenaFreeable {
443     public:
444         ElementNode(int elision, ExpressionNode*);
445         ElementNode(ElementNode*, int elision, ExpressionNode*);
446
447         int elision() const { return m_elision; }
448         ExpressionNode* value() { return m_node; }
449         ElementNode* next() { return m_next; }
450
451     private:
452         ElementNode* m_next;
453         int m_elision;
454         ExpressionNode* m_node;
455     };
456
457     class ArrayNode : public ExpressionNode {
458     public:
459         ArrayNode(const JSTokenLocation&, int elision);
460         ArrayNode(const JSTokenLocation&, ElementNode*);
461         ArrayNode(const JSTokenLocation&, int elision, ElementNode*);
462
463         ArgumentListNode* toArgumentList(VM*, int, int) const;
464
465         ElementNode* elements() const { ASSERT(isSimpleArray()); return m_element; }
466     private:
467         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
468
469         virtual bool isSimpleArray() const OVERRIDE;
470
471         ElementNode* m_element;
472         int m_elision;
473         bool m_optional;
474     };
475
476     class PropertyNode : public ParserArenaFreeable {
477     public:
478         enum Type { Constant = 1, Getter = 2, Setter = 4 };
479
480         PropertyNode(VM*, const Identifier&, ExpressionNode*, Type);
481         PropertyNode(VM*, double, ExpressionNode*, Type);
482
483         const Identifier& name() const { return m_name; }
484         Type type() const { return m_type; }
485
486     private:
487         friend class PropertyListNode;
488         const Identifier& m_name;
489         ExpressionNode* m_assign;
490         Type m_type;
491     };
492
493     class PropertyListNode : public ExpressionNode {
494     public:
495         PropertyListNode(const JSTokenLocation&, PropertyNode*);
496         PropertyListNode(const JSTokenLocation&, PropertyNode*, PropertyListNode*);
497
498         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
499
500     private:
501         PropertyNode* m_node;
502         PropertyListNode* m_next;
503     };
504
505     class ObjectLiteralNode : public ExpressionNode {
506     public:
507         ObjectLiteralNode(const JSTokenLocation&);
508         ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);
509
510     private:
511         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
512
513         PropertyListNode* m_list;
514     };
515     
516     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
517     public:
518         BracketAccessorNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
519
520         ExpressionNode* base() const { return m_base; }
521         ExpressionNode* subscript() const { return m_subscript; }
522
523         bool subscriptHasAssignments() const { return m_subscriptHasAssignments; }
524
525     private:
526         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
527
528         virtual bool isLocation() const OVERRIDE { return true; }
529         virtual bool isBracketAccessorNode() const OVERRIDE { return true; }
530
531         ExpressionNode* m_base;
532         ExpressionNode* m_subscript;
533         bool m_subscriptHasAssignments;
534     };
535
536     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
537     public:
538         DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);
539
540         ExpressionNode* base() const { return m_base; }
541         const Identifier& identifier() const { return m_ident; }
542
543     private:
544         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
545
546         virtual bool isLocation() const OVERRIDE { return true; }
547         virtual bool isDotAccessorNode() const OVERRIDE { return true; }
548
549         ExpressionNode* m_base;
550         const Identifier& m_ident;
551     };
552
553     class ArgumentListNode : public ExpressionNode {
554     public:
555         ArgumentListNode(const JSTokenLocation&, ExpressionNode*);
556         ArgumentListNode(const JSTokenLocation&, ArgumentListNode*, ExpressionNode*);
557
558         ArgumentListNode* m_next;
559         ExpressionNode* m_expr;
560
561     private:
562         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
563     };
564
565     class ArgumentsNode : public ParserArenaFreeable {
566     public:
567         ArgumentsNode();
568         ArgumentsNode(ArgumentListNode*);
569
570         ArgumentListNode* m_listNode;
571     };
572
573     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
574     public:
575         NewExprNode(const JSTokenLocation&, ExpressionNode*);
576         NewExprNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*);
577
578     private:
579         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
580
581         ExpressionNode* m_expr;
582         ArgumentsNode* m_args;
583     };
584
585     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
586     public:
587         EvalFunctionCallNode(const JSTokenLocation&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
588
589     private:
590         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
591
592         ArgumentsNode* m_args;
593     };
594
595     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
596     public:
597         FunctionCallValueNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
598
599     private:
600         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
601
602         ExpressionNode* m_expr;
603         ArgumentsNode* m_args;
604     };
605
606     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
607     public:
608         FunctionCallResolveNode(const JSTokenLocation&, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
609
610     private:
611         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
612
613         const Identifier& m_ident;
614         ArgumentsNode* m_args;
615     };
616     
617     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
618     public:
619         FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
620
621     private:
622         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
623
624         ExpressionNode* m_base;
625         ExpressionNode* m_subscript;
626         ArgumentsNode* m_args;
627     };
628
629     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
630     public:
631         FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
632
633     private:
634         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
635
636     protected:
637         ExpressionNode* m_base;
638         const Identifier& m_ident;
639         ArgumentsNode* m_args;
640     };
641
642     class CallFunctionCallDotNode : public FunctionCallDotNode {
643     public:
644         CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
645
646     private:
647         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
648     };
649     
650     class ApplyFunctionCallDotNode : public FunctionCallDotNode {
651     public:
652         ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
653
654     private:
655         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
656     };
657
658     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
659     public:
660         DeleteResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
661
662     private:
663         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
664
665         const Identifier& m_ident;
666     };
667
668     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
669     public:
670         DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
671
672     private:
673         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
674
675         ExpressionNode* m_base;
676         ExpressionNode* m_subscript;
677     };
678
679     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
680     public:
681         DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
682
683     private:
684         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
685
686         ExpressionNode* m_base;
687         const Identifier& m_ident;
688     };
689
690     class DeleteValueNode : public ExpressionNode {
691     public:
692         DeleteValueNode(const JSTokenLocation&, ExpressionNode*);
693
694     private:
695         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
696
697         ExpressionNode* m_expr;
698     };
699
700     class VoidNode : public ExpressionNode {
701     public:
702         VoidNode(const JSTokenLocation&, ExpressionNode*);
703
704     private:
705         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
706
707         ExpressionNode* m_expr;
708     };
709
710     class TypeOfResolveNode : public ExpressionNode {
711     public:
712         TypeOfResolveNode(const JSTokenLocation&, const Identifier&);
713
714         const Identifier& identifier() const { return m_ident; }
715
716     private:
717         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
718
719         const Identifier& m_ident;
720     };
721
722     class TypeOfValueNode : public ExpressionNode {
723     public:
724         TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);
725
726     private:
727         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
728
729         ExpressionNode* m_expr;
730     };
731
732     class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
733     public:
734         PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
735
736     protected:
737         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
738         virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
739         virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
740         virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);
741
742         ExpressionNode* m_expr;
743         Operator m_operator;
744     };
745
746     class PostfixNode : public PrefixNode {
747     public:
748         PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
749
750     private:
751         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
752         virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
753         virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
754         virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
755     };
756
757     class UnaryOpNode : public ExpressionNode {
758     public:
759         UnaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode*, OpcodeID);
760
761     protected:
762         ExpressionNode* expr() { return m_expr; }
763         const ExpressionNode* expr() const { return m_expr; }
764
765     private:
766         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
767
768         OpcodeID opcodeID() const { return m_opcodeID; }
769
770         ExpressionNode* m_expr;
771         OpcodeID m_opcodeID;
772     };
773
774     class UnaryPlusNode : public UnaryOpNode {
775     public:
776         UnaryPlusNode(const JSTokenLocation&, ExpressionNode*);
777
778     private:
779         virtual ExpressionNode* stripUnaryPlus() OVERRIDE { return expr(); }
780     };
781
782     class NegateNode : public UnaryOpNode {
783     public:
784         NegateNode(const JSTokenLocation&, ExpressionNode*);
785     };
786
787     class BitwiseNotNode : public ExpressionNode {
788     public:
789         BitwiseNotNode(const JSTokenLocation&, ExpressionNode*);
790
791     protected:
792         ExpressionNode* expr() { return m_expr; }
793         const ExpressionNode* expr() const { return m_expr; }
794
795     private:
796         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
797
798         ExpressionNode* m_expr;
799     };
800  
801     class LogicalNotNode : public UnaryOpNode {
802     public:
803         LogicalNotNode(const JSTokenLocation&, ExpressionNode*);
804     private:
805         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;
806     };
807
808     class BinaryOpNode : public ExpressionNode {
809     public:
810         BinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
811         BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
812
813         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
814         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;
815
816         ExpressionNode* lhs() { return m_expr1; };
817         ExpressionNode* rhs() { return m_expr2; };
818
819     private:
820         void tryFoldToBranch(BytecodeGenerator&, TriState& branchCondition, ExpressionNode*& branchExpression);
821         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
822
823     protected:
824         OpcodeID opcodeID() const { return m_opcodeID; }
825
826     protected:
827         ExpressionNode* m_expr1;
828         ExpressionNode* m_expr2;
829     private:
830         OpcodeID m_opcodeID;
831     protected:
832         bool m_rightHasAssignments;
833     };
834
835     class MultNode : public BinaryOpNode {
836     public:
837         MultNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
838     };
839
840     class DivNode : public BinaryOpNode {
841     public:
842         DivNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
843     };
844
845     class ModNode : public BinaryOpNode {
846     public:
847         ModNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
848     };
849
850     class AddNode : public BinaryOpNode {
851     public:
852         AddNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
853
854         virtual bool isAdd() const OVERRIDE { return true; }
855     };
856
857     class SubNode : public BinaryOpNode {
858     public:
859         SubNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
860
861         virtual bool isSubtract() const OVERRIDE { return true; }
862     };
863
864     class LeftShiftNode : public BinaryOpNode {
865     public:
866         LeftShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
867     };
868
869     class RightShiftNode : public BinaryOpNode {
870     public:
871         RightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
872     };
873
874     class UnsignedRightShiftNode : public BinaryOpNode {
875     public:
876         UnsignedRightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
877     };
878
879     class LessNode : public BinaryOpNode {
880     public:
881         LessNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
882     };
883
884     class GreaterNode : public BinaryOpNode {
885     public:
886         GreaterNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
887     };
888
889     class LessEqNode : public BinaryOpNode {
890     public:
891         LessEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
892     };
893
894     class GreaterEqNode : public BinaryOpNode {
895     public:
896         GreaterEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
897     };
898
899     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
900     public:
901         ThrowableBinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
902         ThrowableBinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
903
904     private:
905         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
906     };
907     
908     class InstanceOfNode : public ThrowableBinaryOpNode {
909     public:
910         InstanceOfNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
911
912     private:
913         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
914     };
915
916     class InNode : public ThrowableBinaryOpNode {
917     public:
918         InNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
919     };
920
921     class EqualNode : public BinaryOpNode {
922     public:
923         EqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
924
925     private:
926         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
927     };
928
929     class NotEqualNode : public BinaryOpNode {
930     public:
931         NotEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
932     };
933
934     class StrictEqualNode : public BinaryOpNode {
935     public:
936         StrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
937
938     private:
939         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
940     };
941
942     class NotStrictEqualNode : public BinaryOpNode {
943     public:
944         NotStrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
945     };
946
947     class BitAndNode : public BinaryOpNode {
948     public:
949         BitAndNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
950     };
951
952     class BitOrNode : public BinaryOpNode {
953     public:
954         BitOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
955     };
956
957     class BitXOrNode : public BinaryOpNode {
958     public:
959         BitXOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
960     };
961
962     // m_expr1 && m_expr2, m_expr1 || m_expr2
963     class LogicalOpNode : public ExpressionNode {
964     public:
965         LogicalOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
966
967     private:
968         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
969         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) OVERRIDE;
970
971         ExpressionNode* m_expr1;
972         ExpressionNode* m_expr2;
973         LogicalOperator m_operator;
974     };
975
976     // The ternary operator, "m_logical ? m_expr1 : m_expr2"
977     class ConditionalNode : public ExpressionNode {
978     public:
979         ConditionalNode(const JSTokenLocation&, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
980
981     private:
982         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
983
984         ExpressionNode* m_logical;
985         ExpressionNode* m_expr1;
986         ExpressionNode* m_expr2;
987     };
988
989     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
990     public:
991         ReadModifyResolveNode(const JSTokenLocation&, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
992
993     private:
994         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
995
996         const Identifier& m_ident;
997         ExpressionNode* m_right;
998         Operator m_operator;
999         bool m_rightHasAssignments;
1000     };
1001
1002     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
1003     public:
1004         AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right);
1005
1006     private:
1007         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1008
1009         const Identifier& m_ident;
1010         ExpressionNode* m_right;
1011     };
1012
1013     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
1014     public:
1015         ReadModifyBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
1016
1017     private:
1018         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1019
1020         ExpressionNode* m_base;
1021         ExpressionNode* m_subscript;
1022         ExpressionNode* m_right;
1023         Operator m_operator : 30;
1024         bool m_subscriptHasAssignments : 1;
1025         bool m_rightHasAssignments : 1;
1026     };
1027
1028     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
1029     public:
1030         AssignBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
1031
1032     private:
1033         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1034
1035         ExpressionNode* m_base;
1036         ExpressionNode* m_subscript;
1037         ExpressionNode* m_right;
1038         bool m_subscriptHasAssignments : 1;
1039         bool m_rightHasAssignments : 1;
1040     };
1041
1042     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
1043     public:
1044         AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
1045
1046     private:
1047         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1048
1049         ExpressionNode* m_base;
1050         const Identifier& m_ident;
1051         ExpressionNode* m_right;
1052         bool m_rightHasAssignments;
1053     };
1054
1055     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
1056     public:
1057         ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
1058
1059     private:
1060         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1061
1062         ExpressionNode* m_base;
1063         const Identifier& m_ident;
1064         ExpressionNode* m_right;
1065         Operator m_operator : 31;
1066         bool m_rightHasAssignments : 1;
1067     };
1068
1069     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
1070     public:
1071         AssignErrorNode(const JSTokenLocation&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
1072
1073     private:
1074         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1075     };
1076     
1077     typedef Vector<ExpressionNode*, 8> ExpressionVector;
1078
1079     class CommaNode : public ExpressionNode, public ParserArenaDeletable {
1080     public:
1081         CommaNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2);
1082
1083         using ParserArenaDeletable::operator new;
1084
1085         void append(ExpressionNode* expr) { ASSERT(expr); m_expressions.append(expr); }
1086
1087     private:
1088         virtual bool isCommaNode() const OVERRIDE { return true; }
1089         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1090
1091         ExpressionVector m_expressions;
1092     };
1093     
1094     class ConstDeclNode : public ExpressionNode {
1095     public:
1096         ConstDeclNode(const JSTokenLocation&, const Identifier&, ExpressionNode*);
1097
1098         bool hasInitializer() const { return m_init; }
1099         const Identifier& ident() { return m_ident; }
1100
1101     private:
1102         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1103         virtual RegisterID* emitCodeSingle(BytecodeGenerator&);
1104
1105         const Identifier& m_ident;
1106
1107     public:
1108         ConstDeclNode* m_next;
1109
1110     private:
1111         ExpressionNode* m_init;
1112     };
1113
1114     class ConstStatementNode : public StatementNode {
1115     public:
1116         ConstStatementNode(const JSTokenLocation&, ConstDeclNode* next);
1117
1118     private:
1119         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1120
1121         ConstDeclNode* m_next;
1122     };
1123
1124     class SourceElements : public ParserArenaDeletable {
1125     public:
1126         SourceElements();
1127
1128         void append(StatementNode*);
1129
1130         StatementNode* singleStatement() const;
1131         StatementNode* lastStatement() const;
1132
1133         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
1134
1135     private:
1136         Vector<StatementNode*> m_statements;
1137     };
1138
1139     class BlockNode : public StatementNode {
1140     public:
1141         BlockNode(const JSTokenLocation&, SourceElements* = 0);
1142
1143         StatementNode* singleStatement() const;
1144         StatementNode* lastStatement() const;
1145
1146     private:
1147         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1148
1149         virtual bool isBlock() const OVERRIDE { return true; }
1150
1151         SourceElements* m_statements;
1152     };
1153
1154     class EmptyStatementNode : public StatementNode {
1155     public:
1156         EmptyStatementNode(const JSTokenLocation&);
1157
1158     private:
1159         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1160
1161         virtual bool isEmptyStatement() const OVERRIDE { return true; }
1162     };
1163     
1164     class DebuggerStatementNode : public StatementNode {
1165     public:
1166         DebuggerStatementNode(const JSTokenLocation&);
1167         
1168     private:
1169         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1170     };
1171
1172     class ExprStatementNode : public StatementNode {
1173     public:
1174         ExprStatementNode(const JSTokenLocation&, ExpressionNode*);
1175
1176         ExpressionNode* expr() const { return m_expr; }
1177
1178     private:
1179         virtual bool isExprStatement() const OVERRIDE { return true; }
1180
1181         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1182
1183         ExpressionNode* m_expr;
1184     };
1185
1186     class VarStatementNode : public StatementNode {
1187     public:
1188         VarStatementNode(const JSTokenLocation&, ExpressionNode*);
1189     private:
1190         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1191
1192         ExpressionNode* m_expr;
1193     };
1194
1195     class IfElseNode : public StatementNode {
1196     public:
1197         IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
1198
1199     private:
1200         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1201         bool tryFoldBreakAndContinue(BytecodeGenerator&, StatementNode* ifBlock,
1202             Label*& trueTarget, FallThroughMode&);
1203
1204         ExpressionNode* m_condition;
1205         StatementNode* m_ifBlock;
1206         StatementNode* m_elseBlock;
1207     };
1208
1209     class DoWhileNode : public StatementNode {
1210     public:
1211         DoWhileNode(const JSTokenLocation&, StatementNode*, ExpressionNode*);
1212
1213     private:
1214         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1215
1216         StatementNode* m_statement;
1217         ExpressionNode* m_expr;
1218     };
1219
1220     class WhileNode : public StatementNode {
1221     public:
1222         WhileNode(const JSTokenLocation&, ExpressionNode*, StatementNode*);
1223
1224     private:
1225         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1226
1227         ExpressionNode* m_expr;
1228         StatementNode* m_statement;
1229     };
1230
1231     class ForNode : public StatementNode {
1232     public:
1233         ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);
1234
1235     private:
1236         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1237
1238         ExpressionNode* m_expr1;
1239         ExpressionNode* m_expr2;
1240         ExpressionNode* m_expr3;
1241         StatementNode* m_statement;
1242     };
1243     
1244     class DeconstructionPatternNode;
1245     
1246     class EnumerationNode : public StatementNode, public ThrowableExpressionData {
1247     public:
1248         EnumerationNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
1249         EnumerationNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, ExpressionNode*, StatementNode*);
1250         
1251     protected:
1252         ExpressionNode* m_lexpr;
1253         ExpressionNode* m_expr;
1254         StatementNode* m_statement;
1255     };
1256     
1257     class ForInNode : public EnumerationNode {
1258     public:
1259         ForInNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
1260         ForInNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, ExpressionNode*, StatementNode*);
1261
1262     private:
1263         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1264     };
1265     
1266     class ForOfNode : public EnumerationNode {
1267     public:
1268         ForOfNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
1269         ForOfNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, ExpressionNode*, StatementNode*);
1270         
1271     private:
1272         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1273     };
1274
1275     class ContinueNode : public StatementNode, public ThrowableExpressionData {
1276     public:
1277         ContinueNode(VM*, const JSTokenLocation&);
1278         ContinueNode(const JSTokenLocation&, const Identifier&);
1279         Label* trivialTarget(BytecodeGenerator&);
1280         
1281     private:
1282         virtual bool isContinue() const OVERRIDE { return true; }
1283         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1284
1285         const Identifier& m_ident;
1286     };
1287
1288     class BreakNode : public StatementNode, public ThrowableExpressionData {
1289     public:
1290         BreakNode(VM*, const JSTokenLocation&);
1291         BreakNode(const JSTokenLocation&, const Identifier&);
1292         Label* trivialTarget(BytecodeGenerator&);
1293         
1294     private:
1295         virtual bool isBreak() const OVERRIDE { return true; }
1296         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1297
1298         const Identifier& m_ident;
1299     };
1300
1301     class ReturnNode : public StatementNode, public ThrowableExpressionData {
1302     public:
1303         ReturnNode(const JSTokenLocation&, ExpressionNode* value);
1304
1305         ExpressionNode* value() { return m_value; }
1306
1307     private:
1308         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1309
1310         virtual bool isReturnNode() const OVERRIDE { return true; }
1311
1312         ExpressionNode* m_value;
1313     };
1314
1315     class WithNode : public StatementNode {
1316     public:
1317         WithNode(const JSTokenLocation&, ExpressionNode*, StatementNode*, const JSTextPosition& divot, uint32_t expressionLength);
1318
1319     private:
1320         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1321
1322         ExpressionNode* m_expr;
1323         StatementNode* m_statement;
1324         JSTextPosition m_divot;
1325         uint32_t m_expressionLength;
1326     };
1327
1328     class LabelNode : public StatementNode, public ThrowableExpressionData {
1329     public:
1330         LabelNode(const JSTokenLocation&, const Identifier& name, StatementNode*);
1331
1332     private:
1333         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1334
1335         const Identifier& m_name;
1336         StatementNode* m_statement;
1337     };
1338
1339     class ThrowNode : public StatementNode, public ThrowableExpressionData {
1340     public:
1341         ThrowNode(const JSTokenLocation&, ExpressionNode*);
1342
1343     private:
1344         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1345
1346         ExpressionNode* m_expr;
1347     };
1348
1349     class TryNode : public StatementNode {
1350     public:
1351         TryNode(const JSTokenLocation&, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);
1352
1353     private:
1354         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1355
1356         StatementNode* m_tryBlock;
1357         const Identifier& m_exceptionIdent;
1358         StatementNode* m_catchBlock;
1359         StatementNode* m_finallyBlock;
1360     };
1361
1362     class ParameterNode : public ParserArenaDeletable {
1363     public:
1364         ParameterNode(PassRefPtr<DeconstructionPatternNode>);
1365         ParameterNode(ParameterNode*, PassRefPtr<DeconstructionPatternNode>);
1366
1367         DeconstructionPatternNode* pattern() const { return m_pattern.get(); }
1368         ParameterNode* nextParam() const { return m_next; }
1369
1370     private:
1371         RefPtr<DeconstructionPatternNode> m_pattern;
1372         ParameterNode* m_next;
1373     };
1374
1375     class ScopeNode : public StatementNode, public ParserArenaRefCounted {
1376     public:
1377         typedef DeclarationStacks::VarStack VarStack;
1378         typedef DeclarationStacks::FunctionStack FunctionStack;
1379
1380         ScopeNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, bool inStrictContext);
1381         ScopeNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
1382
1383         using ParserArenaRefCounted::operator new;
1384
1385         void destroyData()
1386         {
1387             m_arena.reset();
1388             m_varStack.clear();
1389             m_functionStack.clear();
1390             m_statements = 0;
1391             m_capturedVariables.clear();
1392         }
1393
1394         const SourceCode& source() const { return m_source; }
1395         const String& sourceURL() const { return m_source.provider()->url(); }
1396         intptr_t sourceID() const { return m_source.providerID(); }
1397
1398         int startLine() const { return m_startLineNumber; }
1399         int startStartOffset() const { return m_startStartOffset; }
1400         int startLineStartOffset() const { return m_startLineStartOffset; }
1401
1402         void setFeatures(CodeFeatures features) { m_features = features; }
1403         CodeFeatures features() { return m_features; }
1404
1405         bool usesEval() const { return m_features & EvalFeature; }
1406         bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }
1407         bool modifiesParameter() const { return m_features & ModifiedParameterFeature; }
1408         bool isStrictMode() const { return m_features & StrictModeFeature; }
1409         void setUsesArguments() { m_features |= ArgumentsFeature; }
1410         bool usesThis() const { return m_features & ThisFeature; }
1411         bool needsActivationForMoreThanVariables() const { return m_features & (EvalFeature | WithFeature | CatchFeature); }
1412         bool needsActivation() const { return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature | CatchFeature)); }
1413         bool hasCapturedVariables() const { return !!m_capturedVariables.size(); }
1414         size_t capturedVariableCount() const { return m_capturedVariables.size(); }
1415         bool captures(const Identifier& ident) { return m_capturedVariables.contains(ident.impl()); }
1416
1417         VarStack& varStack() { return m_varStack; }
1418         FunctionStack& functionStack() { return m_functionStack; }
1419
1420         int neededConstants()
1421         {
1422             // We may need 2 more constants than the count given by the parser,
1423             // because of the various uses of jsUndefined() and jsNull().
1424             return m_numConstants + 2;
1425         }
1426
1427         StatementNode* singleStatement() const;
1428
1429         void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination);
1430
1431     protected:
1432         void setSource(const SourceCode& source) { m_source = source; }
1433         ParserArena m_arena;
1434
1435         int m_startLineNumber;
1436         unsigned m_startStartOffset;
1437         unsigned m_startLineStartOffset;
1438
1439     private:
1440         CodeFeatures m_features;
1441         SourceCode m_source;
1442         VarStack m_varStack;
1443         FunctionStack m_functionStack;
1444         int m_numConstants;
1445         SourceElements* m_statements;
1446         IdentifierSet m_capturedVariables;
1447     };
1448
1449     class ProgramNode : public ScopeNode {
1450     public:
1451         static const bool isFunctionNode = false;
1452         static PassRefPtr<ProgramNode> create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1453
1454         unsigned startColumn() { return m_startColumn; }
1455
1456         static const bool scopeIsFunction = false;
1457
1458     private:
1459         ProgramNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1460
1461         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1462
1463         unsigned m_startColumn;
1464     };
1465
1466     class EvalNode : public ScopeNode {
1467     public:
1468         static const bool isFunctionNode = false;
1469         static PassRefPtr<EvalNode> create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1470
1471         unsigned startColumn() { return 1; }
1472
1473         static const bool scopeIsFunction = false;
1474
1475     private:
1476         EvalNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1477
1478         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1479     };
1480
1481     class FunctionParameters : public RefCounted<FunctionParameters> {
1482         WTF_MAKE_FAST_ALLOCATED;
1483         WTF_MAKE_NONCOPYABLE(FunctionParameters);
1484     public:
1485         static PassRefPtr<FunctionParameters> create(ParameterNode*);
1486         ~FunctionParameters();
1487
1488         unsigned size() const { return m_size; }
1489         DeconstructionPatternNode* at(unsigned index) { ASSERT(index < m_size); return patterns()[index]; }
1490
1491     private:
1492         FunctionParameters(ParameterNode*, unsigned size);
1493
1494         DeconstructionPatternNode** patterns() { return &m_storage; }
1495
1496         unsigned m_size;
1497         DeconstructionPatternNode* m_storage;
1498     };
1499
1500     class FunctionBodyNode : public ScopeNode {
1501     public:
1502         static const bool isFunctionNode = true;
1503         static FunctionBodyNode* create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, bool isStrictMode);
1504         static PassRefPtr<FunctionBodyNode> create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1505
1506         FunctionParameters* parameters() const { return m_parameters.get(); }
1507         size_t parameterCount() const { return m_parameters->size(); }
1508
1509         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1510
1511         void finishParsing(const SourceCode&, ParameterNode*, const Identifier&, FunctionNameIsInScopeToggle);
1512         void finishParsing(PassRefPtr<FunctionParameters>, const Identifier&, FunctionNameIsInScopeToggle);
1513         
1514         const Identifier& ident() { return m_ident; }
1515         void setInferredName(const Identifier& inferredName) { ASSERT(!inferredName.isNull()); m_inferredName = inferredName; }
1516         const Identifier& inferredName() { return m_inferredName.isEmpty() ? m_ident : m_inferredName; }
1517
1518         bool functionNameIsInScope() { return m_functionNameIsInScopeToggle == FunctionNameIsInScope; }
1519         FunctionNameIsInScopeToggle functionNameIsInScopeToggle() { return m_functionNameIsInScopeToggle; }
1520
1521         void setFunctionStart(int functionStart) { m_functionStart = functionStart; }
1522         int functionStart() const { return m_functionStart; }
1523         unsigned startColumn() const { return m_startColumn; }
1524
1525         static const bool scopeIsFunction = true;
1526
1527     private:
1528         FunctionBodyNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, bool inStrictContext);
1529         FunctionBodyNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
1530
1531         Identifier m_ident;
1532         Identifier m_inferredName;
1533         FunctionNameIsInScopeToggle m_functionNameIsInScopeToggle;
1534         RefPtr<FunctionParameters> m_parameters;
1535         int m_functionStart;
1536         unsigned m_startColumn;
1537     };
1538
1539     class FuncExprNode : public ExpressionNode {
1540     public:
1541         FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
1542
1543         FunctionBodyNode* body() { return m_body; }
1544
1545     private:
1546         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1547
1548         virtual bool isFuncExprNode() const OVERRIDE { return true; }
1549
1550         FunctionBodyNode* m_body;
1551     };
1552
1553     class DeconstructionPatternNode : public RefCounted<DeconstructionPatternNode> {
1554         WTF_MAKE_NONCOPYABLE(DeconstructionPatternNode);
1555         WTF_MAKE_FAST_ALLOCATED;
1556
1557     public:
1558         virtual void collectBoundIdentifiers(Vector<Identifier>&) const = 0;
1559         virtual void emitBytecode(BytecodeGenerator&, RegisterID* source) const = 0;
1560         virtual void toString(StringBuilder&) const = 0;
1561
1562         virtual bool isBindingNode() const { return false; }
1563         virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID*, ExpressionNode*) { return 0; }
1564         
1565         virtual ~DeconstructionPatternNode() = 0;
1566         
1567     protected:
1568         DeconstructionPatternNode(VM*);
1569     };
1570
1571     class ArrayPatternNode : public DeconstructionPatternNode {
1572     public:
1573         static PassRefPtr<ArrayPatternNode> create(VM*);
1574         void appendIndex(const JSTokenLocation&, DeconstructionPatternNode* node)
1575         {
1576             m_targetPatterns.append(node);
1577         }
1578
1579     private:
1580         ArrayPatternNode(VM*);
1581         virtual void collectBoundIdentifiers(Vector<Identifier>&) const OVERRIDE;
1582         virtual void emitBytecode(BytecodeGenerator&, RegisterID*) const OVERRIDE;
1583         virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID* dst, ExpressionNode*) OVERRIDE;
1584         virtual void toString(StringBuilder&) const OVERRIDE;
1585
1586         Vector<RefPtr<DeconstructionPatternNode>> m_targetPatterns;
1587     };
1588     
1589     class ObjectPatternNode : public DeconstructionPatternNode {
1590     public:
1591         static PassRefPtr<ObjectPatternNode> create(VM*);
1592         void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DeconstructionPatternNode* pattern)
1593         {
1594             m_targetPatterns.append(Entry(identifier, wasString, pattern));
1595         }
1596         
1597     private:
1598         ObjectPatternNode(VM*);
1599         virtual void collectBoundIdentifiers(Vector<Identifier>&) const OVERRIDE;
1600         virtual void emitBytecode(BytecodeGenerator&, RegisterID*) const OVERRIDE;
1601         virtual void toString(StringBuilder&) const OVERRIDE;
1602         struct Entry {
1603             Entry(const Identifier& propertyName, bool wasString, DeconstructionPatternNode* pattern)
1604                 : propertyName(propertyName)
1605                 , wasString(wasString)
1606                 , pattern(pattern)
1607             {
1608             }
1609             Identifier propertyName;
1610             bool wasString;
1611             RefPtr<DeconstructionPatternNode> pattern;
1612         };
1613         Vector<Entry> m_targetPatterns;
1614     };
1615
1616     class BindingNode : public DeconstructionPatternNode, ThrowableExpressionData {
1617     public:
1618         static PassRefPtr<BindingNode> create(VM*, const Identifier& boundProperty, const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end);
1619         const Identifier& boundProperty() const { return m_boundProperty; }
1620         
1621     private:
1622         BindingNode(VM*, const Identifier& boundProperty, const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end);
1623
1624         virtual void collectBoundIdentifiers(Vector<Identifier>&) const OVERRIDE;
1625         virtual void emitBytecode(BytecodeGenerator&, RegisterID*) const OVERRIDE;
1626         virtual void toString(StringBuilder&) const OVERRIDE;
1627         
1628         virtual bool isBindingNode() const OVERRIDE { return true; }
1629         
1630         Identifier m_boundProperty;
1631     };
1632
1633     class DeconstructingAssignmentNode : public ExpressionNode, public ParserArenaDeletable {
1634     public:
1635         DeconstructingAssignmentNode(const JSTokenLocation&, PassRefPtr<DeconstructionPatternNode>, ExpressionNode*);
1636         DeconstructionPatternNode* bindings() { return m_bindings.get(); }
1637         
1638         using ParserArenaDeletable::operator new;
1639
1640     private:
1641         virtual bool isLocation() const OVERRIDE { return true; }
1642         virtual bool isDeconstructionNode() const OVERRIDE { return true; }
1643         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1644
1645         RefPtr<DeconstructionPatternNode> m_bindings;
1646         ExpressionNode* m_initializer;
1647     };
1648
1649     class FuncDeclNode : public StatementNode {
1650     public:
1651         FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
1652
1653         FunctionBodyNode* body() { return m_body; }
1654
1655     private:
1656         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1657
1658         FunctionBodyNode* m_body;
1659     };
1660
1661     class CaseClauseNode : public ParserArenaFreeable {
1662     public:
1663         CaseClauseNode(ExpressionNode*, SourceElements* = 0);
1664
1665         ExpressionNode* expr() const { return m_expr; }
1666
1667         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
1668
1669     private:
1670         ExpressionNode* m_expr;
1671         SourceElements* m_statements;
1672     };
1673
1674     class ClauseListNode : public ParserArenaFreeable {
1675     public:
1676         ClauseListNode(CaseClauseNode*);
1677         ClauseListNode(ClauseListNode*, CaseClauseNode*);
1678
1679         CaseClauseNode* getClause() const { return m_clause; }
1680         ClauseListNode* getNext() const { return m_next; }
1681
1682     private:
1683         CaseClauseNode* m_clause;
1684         ClauseListNode* m_next;
1685     };
1686
1687     class CaseBlockNode : public ParserArenaFreeable {
1688     public:
1689         CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
1690
1691         void emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination);
1692
1693     private:
1694         SwitchInfo::SwitchType tryTableSwitch(Vector<ExpressionNode*, 8>& literalVector, int32_t& min_num, int32_t& max_num);
1695         static const size_t s_tableSwitchMinimum = 3;
1696         ClauseListNode* m_list1;
1697         CaseClauseNode* m_defaultClause;
1698         ClauseListNode* m_list2;
1699     };
1700
1701     class SwitchNode : public StatementNode {
1702     public:
1703         SwitchNode(const JSTokenLocation&, ExpressionNode*, CaseBlockNode*);
1704
1705     private:
1706         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) OVERRIDE;
1707
1708         ExpressionNode* m_expr;
1709         CaseBlockNode* m_block;
1710     };
1711
1712     struct ElementList {
1713         ElementNode* head;
1714         ElementNode* tail;
1715     };
1716
1717     struct PropertyList {
1718         PropertyListNode* head;
1719         PropertyListNode* tail;
1720     };
1721
1722     struct ArgumentList {
1723         ArgumentListNode* head;
1724         ArgumentListNode* tail;
1725     };
1726
1727     struct ConstDeclList {
1728         ConstDeclNode* head;
1729         ConstDeclNode* tail;
1730     };
1731
1732     struct ParameterList {
1733         ParameterNode* head;
1734         ParameterNode* tail;
1735     };
1736
1737     struct ClauseList {
1738         ClauseListNode* head;
1739         ClauseListNode* tail;
1740     };
1741
1742 } // namespace JSC
1743
1744 #endif // Nodes_h