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