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