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