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