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