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