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