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