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