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