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