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