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