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