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