JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / parser / Nodes.h

diff --git a/parser/Nodes.h b/parser/Nodes.h
index 6e73c00ccce939286826b3beb5a67d2537d82d4b..f29a5104f8af23625a5ca1091d7fa5836ee9f35a 100644 (file)
--- a/parser/Nodes.h
+++ b/parser/Nodes.h
@@ -1,7 +1,7 @@
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
 /*
  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)

- *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013, 2015 Apple Inc. All rights reserved.

  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
  *  Copyright (C) 2007 Maks Orlovich
  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
  *  Copyright (C) 2007 Maks Orlovich
  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>


@@ -30,6 +30,7 @@
 #include "JITCode.h"
 #include "Opcode.h"
 #include "ParserArena.h"
 #include "JITCode.h"
 #include "Opcode.h"
 #include "ParserArena.h"

+#include "ParserTokens.h"

 #include "ResultType.h"
 #include "SourceCode.h"
 #include "SymbolTable.h"
 #include "ResultType.h"
 #include "SourceCode.h"
 #include "SymbolTable.h"


@@ -44,25 +45,9 @@ namespace JSC {
     class PropertyListNode;
     class ReadModifyResolveNode;
     class RegisterID;
     class PropertyListNode;
     class ReadModifyResolveNode;
     class RegisterID;

-    class ScopeChainNode;
+    class JSScope;

     class ScopeNode;
 
     class ScopeNode;
 

-    typedef unsigned CodeFeatures;
-
-    const CodeFeatures NoFeatures = 0;
-    const CodeFeatures EvalFeature = 1 << 0;
-    const CodeFeatures ClosureFeature = 1 << 1;
-    const CodeFeatures AssignFeature = 1 << 2;
-    const CodeFeatures ArgumentsFeature = 1 << 3;
-    const CodeFeatures WithFeature = 1 << 4;
-    const CodeFeatures CatchFeature = 1 << 5;
-    const CodeFeatures ThisFeature = 1 << 6;
-    const CodeFeatures StrictModeFeature = 1 << 7;
-    const CodeFeatures ShadowsArgumentsFeature = 1 << 8;
-    
-    
-    const CodeFeatures AllFeatures = EvalFeature | ClosureFeature | AssignFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature | StrictModeFeature | ShadowsArgumentsFeature;
-

     enum Operator {
         OpEqual,
         OpPlusEq,
     enum Operator {
         OpEqual,
         OpPlusEq,


@@ -85,11 +70,17 @@ namespace JSC {
         OpLogicalOr
     };
 
         OpLogicalOr
     };
 

-    typedef HashSet<RefPtr<StringImpl>, IdentifierRepHash> IdentifierSet;
+    enum FallThroughMode {
+        FallThroughMeansTrue = 0,
+        FallThroughMeansFalse = 1
+    };
+    inline FallThroughMode invert(FallThroughMode fallThroughMode) { return static_cast<FallThroughMode>(!fallThroughMode); }
+
+    typedef HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash> IdentifierSet;

 
     namespace DeclarationStacks {
         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
 
     namespace DeclarationStacks {
         enum VarAttrs { IsConstant = 1, HasInitializer = 2 };

-        typedef Vector<std::pair<const Identifier*, unsigned> > VarStack;
+        typedef Vector<std::pair<Identifier, unsigned>> VarStack;

         typedef Vector<FunctionBodyNode*> FunctionStack;
     }
 
         typedef Vector<FunctionBodyNode*> FunctionStack;
     }
 


@@ -103,7 +94,7 @@ namespace JSC {
     public:
         // ParserArenaFreeable objects are are freed when the arena is deleted.
         // Destructors are not called. Clients must not call delete on such objects.
     public:
         // ParserArenaFreeable objects are are freed when the arena is deleted.
         // Destructors are not called. Clients must not call delete on such objects.

-        void* operator new(size_t, JSGlobalData*);
+        void* operator new(size_t, ParserArena&);

     };
 
     class ParserArenaDeletable {
     };
 
     class ParserArenaDeletable {


@@ -112,56 +103,70 @@ namespace JSC {
 
         // ParserArenaDeletable objects are deleted when the arena is deleted.
         // Clients must not call delete directly on such objects.
 
         // ParserArenaDeletable objects are deleted when the arena is deleted.
         // Clients must not call delete directly on such objects.

-        void* operator new(size_t, JSGlobalData*);
+        void* operator new(size_t, ParserArena&);

     };
 
     };
 

-    class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {
+    class ParserArenaRoot {
+        WTF_MAKE_FAST_ALLOCATED;

     protected:
     protected:

-        ParserArenaRefCounted(JSGlobalData*);
+        ParserArenaRoot(ParserArena&);

 
     public:
 
     public:

-        virtual ~ParserArenaRefCounted()
-        {
-            ASSERT(deletionHasBegun());
-        }
+        ParserArena& parserArena() { return m_arena; }
+        virtual ~ParserArenaRoot() { }
+
+    protected:
+        ParserArena m_arena;

     };
 
     class Node : public ParserArenaFreeable {
     protected:
     };
 
     class Node : public ParserArenaFreeable {
     protected:

-        Node(JSGlobalData*);
+        Node(const JSTokenLocation&);

 
     public:
         virtual ~Node() { }
 
 
     public:
         virtual ~Node() { }
 

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
-
-        int lineNo() const { return m_line; }
+        int firstLine() const { return m_position.line; }
+        int startOffset() const { return m_position.offset; }
+        int endOffset() const { return m_endOffset; }
+        int lineStartOffset() const { return m_position.lineStartOffset; }
+        const JSTextPosition& position() const { return m_position; }
+        void setEndOffset(int offset) { m_endOffset = offset; }
+        void setStartOffset(int offset) { m_position.offset = offset; }

 
     protected:
 
     protected:

-        int m_line;
+        JSTextPosition m_position;
+        int m_endOffset;

     };
 
     class ExpressionNode : public Node {
     protected:
     };
 
     class ExpressionNode : public Node {
     protected:

-        ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());
+        ExpressionNode(const JSTokenLocation&, ResultType = ResultType::unknownType());

 
     public:
 
     public:

+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
+

         virtual bool isNumber() const { return false; }
         virtual bool isString() const { return false; }
         virtual bool isNull() const { return false; }
         virtual bool isPure(BytecodeGenerator&) const { return false; }        
         virtual bool isNumber() const { return false; }
         virtual bool isString() const { return false; }
         virtual bool isNull() const { return false; }
         virtual bool isPure(BytecodeGenerator&) const { return false; }        

+        virtual bool isConstant() const { return false; }

         virtual bool isLocation() const { return false; }
         virtual bool isLocation() const { return false; }

+        virtual bool isAssignmentLocation() const { return isLocation(); }

         virtual bool isResolveNode() const { return false; }
         virtual bool isBracketAccessorNode() const { return false; }
         virtual bool isDotAccessorNode() const { return false; }
         virtual bool isResolveNode() const { return false; }
         virtual bool isBracketAccessorNode() const { return false; }
         virtual bool isDotAccessorNode() const { return false; }

+        virtual bool isDestructuringNode() const { return false; }

         virtual bool isFuncExprNode() const { return false; }
         virtual bool isCommaNode() const { return false; }
         virtual bool isSimpleArray() const { return false; }
         virtual bool isAdd() const { return false; }
         virtual bool isSubtract() const { return false; }
         virtual bool isFuncExprNode() const { return false; }
         virtual bool isCommaNode() const { return false; }
         virtual bool isSimpleArray() const { return false; }
         virtual bool isAdd() const { return false; }
         virtual bool isSubtract() const { return false; }

-        virtual bool hasConditionContextCodegen() const { return false; }
+        virtual bool isBoolean() const { return false; }
+        virtual bool isSpreadExpression() const { return false; }
+        virtual bool isSuperNode() const { return false; }

 
 

-        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, bool) { ASSERT_NOT_REACHED(); }
+        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, FallThroughMode);

 
         virtual ExpressionNode* stripUnaryPlus() { return this; }
 
 
         virtual ExpressionNode* stripUnaryPlus() { return this; }
 


@@ -173,111 +178,143 @@ namespace JSC {
 
     class StatementNode : public Node {
     protected:
 
     class StatementNode : public Node {
     protected:

-        StatementNode(JSGlobalData*);
+        StatementNode(const JSTokenLocation&);

 
     public:
 
     public:

-        void setLoc(int firstLine, int lastLine);
-        int firstLine() const { return lineNo(); }
-        int lastLine() const { return m_lastLine; }
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
+
+        void setLoc(unsigned firstLine, unsigned lastLine, int startOffset, int lineStartOffset);
+        unsigned lastLine() const { return m_lastLine; }
+
+        StatementNode* next() { return m_next; }
+        void setNext(StatementNode* next) { m_next = next; }

 
         virtual bool isEmptyStatement() const { return false; }
         virtual bool isReturnNode() const { return false; }
         virtual bool isExprStatement() const { return false; }
 
         virtual bool isEmptyStatement() const { return false; }
         virtual bool isReturnNode() const { return false; }
         virtual bool isExprStatement() const { return false; }

-
+        virtual bool isBreak() const { return false; }
+        virtual bool isContinue() const { return false; }

         virtual bool isBlock() const { return false; }
         virtual bool isBlock() const { return false; }

+        virtual bool isFuncDeclNode() const { return false; }

 
 

-    private:
+    protected:
+        StatementNode* m_next;

         int m_lastLine;
     };
 
         int m_lastLine;
     };
 

-    class NullNode : public ExpressionNode {
+    class ConstantNode : public ExpressionNode {

     public:
     public:

-        NullNode(JSGlobalData*);
-
+        ConstantNode(const JSTokenLocation&, ResultType);
+        virtual bool isPure(BytecodeGenerator&) const override { return true; }
+        virtual bool isConstant() const  override { return true; }
+        virtual JSValue jsValue(BytecodeGenerator&) const = 0;

     private:
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        virtual bool isNull() const { return true; }
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) override;

     };
 
     };
 

-    class BooleanNode : public ExpressionNode {
+    class NullNode : public ConstantNode {

     public:
     public:

-        BooleanNode(JSGlobalData*, bool value);
+        NullNode(const JSTokenLocation&);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual bool isNull() const override { return true; }
+        virtual JSValue jsValue(BytecodeGenerator&) const override { return jsNull(); }
+    };
+
+    class BooleanNode : public ConstantNode {
+    public:
+        BooleanNode(const JSTokenLocation&, bool value);
+        bool value() { return m_value; }

 
 

-        virtual bool isPure(BytecodeGenerator&) const { return true; }
+    private:
+        virtual bool isBoolean() const override { return true; }
+        virtual JSValue jsValue(BytecodeGenerator&) const override { return jsBoolean(m_value); }

 
         bool m_value;
     };
 
 
         bool m_value;
     };
 

-    class NumberNode : public ExpressionNode {
+    class NumberNode : public ConstantNode {

     public:
     public:

-        NumberNode(JSGlobalData*, double value);
-
+        NumberNode(const JSTokenLocation&, double value);

         double value() const { return m_value; }
         double value() const { return m_value; }

-        void setValue(double value) { m_value = value; }
+        virtual bool isIntegerNode() const = 0;
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override final;

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        virtual bool isNumber() const { return true; }
-        virtual bool isPure(BytecodeGenerator&) const { return true; }
+        virtual bool isNumber() const override final { return true; }
+        virtual JSValue jsValue(BytecodeGenerator&) const override { return jsNumber(m_value); }

 
         double m_value;
     };
 
 
         double m_value;
     };
 

-    class StringNode : public ExpressionNode {
+    class DoubleNode : public NumberNode {

     public:
     public:

-        StringNode(JSGlobalData*, const Identifier&);
+        DoubleNode(const JSTokenLocation&, double value);

 
 

+    private:
+        virtual bool isIntegerNode() const override { return false; }
+    };
+
+    // An integer node represent a number represented as an integer (e.g. 42 instead of 42., 42.0, 42e0)
+    class IntegerNode : public DoubleNode {
+    public:
+        IntegerNode(const JSTokenLocation&, double value);
+        virtual bool isIntegerNode() const override final { return true; }
+    };
+
+    class StringNode : public ConstantNode {
+    public:
+        StringNode(const JSTokenLocation&, const Identifier&);

         const Identifier& value() { return m_value; }
 
     private:
         const Identifier& value() { return m_value; }
 
     private:

-        virtual bool isPure(BytecodeGenerator&) const { return true; }
-
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-        
-        virtual bool isString() const { return true; }
+        virtual bool isString() const override { return true; }
+        virtual JSValue jsValue(BytecodeGenerator&) const override;

 
         const Identifier& m_value;
     };
 
         const Identifier& m_value;
     };

-    
+

     class ThrowableExpressionData {
     public:
         ThrowableExpressionData()
     class ThrowableExpressionData {
     public:
         ThrowableExpressionData()

-            : m_divot(static_cast<uint32_t>(-1))
-            , m_startOffset(static_cast<uint16_t>(-1))
-            , m_endOffset(static_cast<uint16_t>(-1))
+            : m_divot(-1, -1, -1)
+            , m_divotStart(-1, -1, -1)
+            , m_divotEnd(-1, -1, -1)

         {
         }
         
         {
         }
         

-        ThrowableExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
+        ThrowableExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)

             : m_divot(divot)
             : m_divot(divot)

-            , m_startOffset(startOffset)
-            , m_endOffset(endOffset)
+            , m_divotStart(start)
+            , m_divotEnd(end)

         {
         {

+            ASSERT(m_divot.offset >= m_divot.lineStartOffset);
+            ASSERT(m_divotStart.offset >= m_divotStart.lineStartOffset);
+            ASSERT(m_divotEnd.offset >= m_divotEnd.lineStartOffset);

         }
         }

-        
-        void setExceptionSourceCode(unsigned divot, unsigned startOffset, unsigned endOffset)
+
+        void setExceptionSourceCode(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)

         {
         {

+            ASSERT(divot.offset >= divot.lineStartOffset);
+            ASSERT(divotStart.offset >= divotStart.lineStartOffset);
+            ASSERT(divotEnd.offset >= divotEnd.lineStartOffset);

             m_divot = divot;
             m_divot = divot;

-            m_startOffset = startOffset;
-            m_endOffset = endOffset;
+            m_divotStart = divotStart;
+            m_divotEnd = divotEnd;

         }
 
         }
 

-        uint32_t divot() const { return m_divot; }
-        uint16_t startOffset() const { return m_startOffset; }
-        uint16_t endOffset() const { return m_endOffset; }
+        const JSTextPosition& divot() const { return m_divot; }
+        const JSTextPosition& divotStart() const { return m_divotStart; }
+        const JSTextPosition& divotEnd() const { return m_divotEnd; }

 
     protected:
 
     protected:

-        RegisterID* emitThrowReferenceError(BytecodeGenerator&, const UString& message);
+        RegisterID* emitThrowReferenceError(BytecodeGenerator&, const String& message);

 
     private:
 
     private:

-        uint32_t m_divot;
-        uint16_t m_startOffset;
-        uint16_t m_endOffset;
+        JSTextPosition m_divot;
+        JSTextPosition m_divotStart;
+        JSTextPosition m_divotEnd;

     };
 
     class ThrowableSubExpressionData : public ThrowableExpressionData {
     };
 
     class ThrowableSubExpressionData : public ThrowableExpressionData {


@@ -285,28 +322,54 @@ namespace JSC {
         ThrowableSubExpressionData()
             : m_subexpressionDivotOffset(0)
             , m_subexpressionEndOffset(0)
         ThrowableSubExpressionData()
             : m_subexpressionDivotOffset(0)
             , m_subexpressionEndOffset(0)

+            , m_subexpressionLineOffset(0)
+            , m_subexpressionLineStartOffset(0)

         {
         }
 
         {
         }
 

-        ThrowableSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
-            : ThrowableExpressionData(divot, startOffset, endOffset)
+        ThrowableSubExpressionData(const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+            : ThrowableExpressionData(divot, divotStart, divotEnd)

             , m_subexpressionDivotOffset(0)
             , m_subexpressionEndOffset(0)
             , m_subexpressionDivotOffset(0)
             , m_subexpressionEndOffset(0)

+            , m_subexpressionLineOffset(0)
+            , m_subexpressionLineStartOffset(0)

         {
         }
 
         {
         }
 

-        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
+        void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)

         {
         {

-            ASSERT(subexpressionDivot <= divot());
-            if ((divot() - subexpressionDivot) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
+            ASSERT(subexpressionDivot.offset <= divot().offset);
+            // Overflow means we can't do this safely, so just point at the primary divot,
+            // divotLine, or divotLineStart.
+            if ((divot() - subexpressionDivot.offset) & ~0xFFFF)
+                return;
+            if ((divot().line - subexpressionDivot.line) & ~0xFFFF)

                 return;
                 return;

-            m_subexpressionDivotOffset = divot() - subexpressionDivot;
-            m_subexpressionEndOffset = subexpressionOffset;
+            if ((divot().lineStartOffset - subexpressionDivot.lineStartOffset) & ~0xFFFF)
+                return;
+            if ((divotEnd() - subexpressionOffset) & ~0xFFFF)
+                return;
+            m_subexpressionDivotOffset = divot() - subexpressionDivot.offset;
+            m_subexpressionEndOffset = divotEnd() - subexpressionOffset;
+            m_subexpressionLineOffset = divot().line - subexpressionDivot.line;
+            m_subexpressionLineStartOffset = divot().lineStartOffset - subexpressionDivot.lineStartOffset;
+        }
+
+        JSTextPosition subexpressionDivot()
+        {
+            int newLine = divot().line - m_subexpressionLineOffset;
+            int newOffset = divot().offset - m_subexpressionDivotOffset;
+            int newLineStartOffset = divot().lineStartOffset - m_subexpressionLineStartOffset;
+            return JSTextPosition(newLine, newOffset, newLineStartOffset);

         }
         }

+        JSTextPosition subexpressionStart() { return divotStart(); }
+        JSTextPosition subexpressionEnd() { return divotEnd() - static_cast<int>(m_subexpressionEndOffset); }

 
     protected:
         uint16_t m_subexpressionDivotOffset;
         uint16_t m_subexpressionEndOffset;
 
     protected:
         uint16_t m_subexpressionDivotOffset;
         uint16_t m_subexpressionEndOffset;

+        uint16_t m_subexpressionLineOffset;
+        uint16_t m_subexpressionLineStartOffset;

     };
     
     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {
     };
     
     class ThrowablePrefixedSubExpressionData : public ThrowableExpressionData {


@@ -314,36 +377,132 @@ namespace JSC {
         ThrowablePrefixedSubExpressionData()
             : m_subexpressionDivotOffset(0)
             , m_subexpressionStartOffset(0)
         ThrowablePrefixedSubExpressionData()
             : m_subexpressionDivotOffset(0)
             , m_subexpressionStartOffset(0)

+            , m_subexpressionLineOffset(0)
+            , m_subexpressionLineStartOffset(0)

         {
         }
 
         {
         }
 

-        ThrowablePrefixedSubExpressionData(unsigned divot, unsigned startOffset, unsigned endOffset)
-            : ThrowableExpressionData(divot, startOffset, endOffset)
+        ThrowablePrefixedSubExpressionData(const JSTextPosition& divot, const JSTextPosition& start, const JSTextPosition& end)
+            : ThrowableExpressionData(divot, start, end)

             , m_subexpressionDivotOffset(0)
             , m_subexpressionStartOffset(0)
             , m_subexpressionDivotOffset(0)
             , m_subexpressionStartOffset(0)

+            , m_subexpressionLineOffset(0)
+            , m_subexpressionLineStartOffset(0)

         {
         }
 
         {
         }
 

-        void setSubexpressionInfo(uint32_t subexpressionDivot, uint16_t subexpressionOffset)
+        void setSubexpressionInfo(const JSTextPosition& subexpressionDivot, int subexpressionOffset)

         {
         {

-            ASSERT(subexpressionDivot >= divot());
-            if ((subexpressionDivot - divot()) & ~0xFFFF) // Overflow means we can't do this safely, so just point at the primary divot
+            ASSERT(subexpressionDivot.offset >= divot().offset);
+            // Overflow means we can't do this safely, so just point at the primary divot,
+            // divotLine, or divotLineStart.
+            if ((subexpressionDivot.offset - divot()) & ~0xFFFF) 
+                return;
+            if ((subexpressionDivot.line - divot().line) & ~0xFFFF)

                 return;
                 return;

-            m_subexpressionDivotOffset = subexpressionDivot - divot();
-            m_subexpressionStartOffset = subexpressionOffset;
+            if ((subexpressionDivot.lineStartOffset - divot().lineStartOffset) & ~0xFFFF)
+                return;
+            if ((subexpressionOffset - divotStart()) & ~0xFFFF) 
+                return;
+            m_subexpressionDivotOffset = subexpressionDivot.offset - divot();
+            m_subexpressionStartOffset = subexpressionOffset - divotStart();
+            m_subexpressionLineOffset = subexpressionDivot.line - divot().line;
+            m_subexpressionLineStartOffset = subexpressionDivot.lineStartOffset - divot().lineStartOffset;
+        }
+
+        JSTextPosition subexpressionDivot()
+        {
+            int newLine = divot().line + m_subexpressionLineOffset;
+            int newOffset = divot().offset + m_subexpressionDivotOffset;
+            int newLineStartOffset = divot().lineStartOffset + m_subexpressionLineStartOffset;
+            return JSTextPosition(newLine, newOffset, newLineStartOffset);

         }
         }

+        JSTextPosition subexpressionStart() { return divotStart() + static_cast<int>(m_subexpressionStartOffset); }
+        JSTextPosition subexpressionEnd() { return divotEnd(); }

 
     protected:
         uint16_t m_subexpressionDivotOffset;
         uint16_t m_subexpressionStartOffset;
 
     protected:
         uint16_t m_subexpressionDivotOffset;
         uint16_t m_subexpressionStartOffset;

+        uint16_t m_subexpressionLineOffset;
+        uint16_t m_subexpressionLineStartOffset;
+    };
+
+#if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX)
+    class TemplateExpressionListNode : public ParserArenaFreeable {
+    public:
+        TemplateExpressionListNode(ExpressionNode*);
+        TemplateExpressionListNode(TemplateExpressionListNode*, ExpressionNode*);
+
+        ExpressionNode* value() { return m_node; }
+        TemplateExpressionListNode* next() { return m_next; }
+
+    private:
+        TemplateExpressionListNode* m_next { nullptr };
+        ExpressionNode* m_node { nullptr };
+    };
+
+    class TemplateStringNode : public ExpressionNode {
+    public:
+        TemplateStringNode(const JSTokenLocation&, const Identifier& cooked, const Identifier& raw);
+
+        const Identifier& cooked() { return m_cooked; }
+        const Identifier& raw() { return m_raw; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        const Identifier& m_cooked;
+        const Identifier& m_raw;
+    };
+
+    class TemplateStringListNode : public ParserArenaFreeable {
+    public:
+        TemplateStringListNode(TemplateStringNode*);
+        TemplateStringListNode(TemplateStringListNode*, TemplateStringNode*);
+
+        TemplateStringNode* value() { return m_node; }
+        TemplateStringListNode* next() { return m_next; }
+
+    private:
+        TemplateStringListNode* m_next { nullptr };
+        TemplateStringNode* m_node { nullptr };
+    };
+
+    class TemplateLiteralNode : public ExpressionNode {
+    public:
+        TemplateLiteralNode(const JSTokenLocation&, TemplateStringListNode*);
+        TemplateLiteralNode(const JSTokenLocation&, TemplateStringListNode*, TemplateExpressionListNode*);
+
+        TemplateStringListNode* templateStrings() const { return m_templateStrings; }
+        TemplateExpressionListNode* templateExpressions() const { return m_templateExpressions; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        TemplateStringListNode* m_templateStrings;
+        TemplateExpressionListNode* m_templateExpressions;
+    };
+
+    class TaggedTemplateNode : public ExpressionNode, public ThrowableExpressionData {
+    public:
+        TaggedTemplateNode(const JSTokenLocation&, ExpressionNode*, TemplateLiteralNode*);
+
+        TemplateLiteralNode* templateLiteral() const { return m_templateLiteral; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        ExpressionNode* m_tag;
+        TemplateLiteralNode* m_templateLiteral;

     };
     };

+#endif

 
     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        RegExpNode(JSGlobalData*, const Identifier& pattern, const Identifier& flags);
+        RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_pattern;
         const Identifier& m_flags;
 
         const Identifier& m_pattern;
         const Identifier& m_flags;


@@ -351,33 +510,44 @@ namespace JSC {
 
     class ThisNode : public ExpressionNode {
     public:
 
     class ThisNode : public ExpressionNode {
     public:

-        ThisNode(JSGlobalData*);
+        ThisNode(const JSTokenLocation&, ThisTDZMode);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        bool m_shouldAlwaysEmitTDZCheck;
+    };
+
+    class SuperNode final : public ExpressionNode {
+    public:
+        SuperNode(const JSTokenLocation&);
+
+    private:
+        virtual bool isSuperNode() const override { return true; }
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class ResolveNode : public ExpressionNode {
     public:
     };
 
     class ResolveNode : public ExpressionNode {
     public:

-        ResolveNode(JSGlobalData*, const Identifier&, int startOffset);
+        ResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& start);

 
         const Identifier& identifier() const { return m_ident; }
 
     private:
 
         const Identifier& identifier() const { return m_ident; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isPure(BytecodeGenerator&) const ;
-        virtual bool isLocation() const { return true; }
-        virtual bool isResolveNode() const { return true; }
+        virtual bool isPure(BytecodeGenerator&) const override;
+        virtual bool isLocation() const override { return true; }
+        virtual bool isResolveNode() const override { return true; }

 
         const Identifier& m_ident;
 
         const Identifier& m_ident;

-        int32_t m_startOffset;
+        JSTextPosition m_start;

     };
 
     class ElementNode : public ParserArenaFreeable {
     public:
     };
 
     class ElementNode : public ParserArenaFreeable {
     public:

-        ElementNode(JSGlobalData*, int elision, ExpressionNode*);
-        ElementNode(JSGlobalData*, ElementNode*, int elision, ExpressionNode*);
+        ElementNode(int elision, ExpressionNode*);
+        ElementNode(ElementNode*, int elision, ExpressionNode*);

 
         int elision() const { return m_elision; }
         ExpressionNode* value() { return m_node; }
 
         int elision() const { return m_elision; }
         ExpressionNode* value() { return m_node; }


@@ -391,16 +561,17 @@ namespace JSC {
 
     class ArrayNode : public ExpressionNode {
     public:
 
     class ArrayNode : public ExpressionNode {
     public:

-        ArrayNode(JSGlobalData*, int elision);
-        ArrayNode(JSGlobalData*, ElementNode*);
-        ArrayNode(JSGlobalData*, int elision, ElementNode*);
+        ArrayNode(const JSTokenLocation&, int elision);
+        ArrayNode(const JSTokenLocation&, ElementNode*);
+        ArrayNode(const JSTokenLocation&, int elision, ElementNode*);

 
 

-        ArgumentListNode* toArgumentList(JSGlobalData*) const;
+        ArgumentListNode* toArgumentList(ParserArena&, int, int) const;

 
 

+        ElementNode* elements() const { ASSERT(isSimpleArray()); return m_element; }

     private:
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isSimpleArray() const ;
+        virtual bool isSimpleArray() const override;

 
         ElementNode* m_element;
         int m_elision;
 
         ElementNode* m_element;
         int m_elision;


@@ -409,56 +580,67 @@ namespace JSC {
 
     class PropertyNode : public ParserArenaFreeable {
     public:
 
     class PropertyNode : public ParserArenaFreeable {
     public:

-        enum Type { Constant = 1, Getter = 2, Setter = 4 };
+        enum Type { Constant = 1, Getter = 2, Setter = 4, Computed = 8, Shorthand = 16 };
+        enum PutType { Unknown, KnownDirect };
+
+        PropertyNode(const Identifier&, ExpressionNode*, Type, PutType, SuperBinding);
+        PropertyNode(ExpressionNode* propertyName, ExpressionNode*, Type, PutType);

 
 

-        PropertyNode(JSGlobalData*, const Identifier& name, ExpressionNode* value, Type);
-        PropertyNode(JSGlobalData*, double name, ExpressionNode* value, Type);
+        ExpressionNode* expressionName() const { return m_expression; }
+        const Identifier* name() const { return m_name; }

 
 

-        const Identifier& name() const { return m_name; }
-        Type type() const { return m_type; }
+        Type type() const { return static_cast<Type>(m_type); }
+        bool needsSuperBinding() const { return m_needsSuperBinding; }
+        PutType putType() const { return static_cast<PutType>(m_putType); }

 
     private:
         friend class PropertyListNode;
 
     private:
         friend class PropertyListNode;

-        const Identifier& m_name;
+        const Identifier* m_name;
+        ExpressionNode* m_expression;

         ExpressionNode* m_assign;
         ExpressionNode* m_assign;

-        Type m_type;
+        unsigned m_type : 5;
+        unsigned m_needsSuperBinding : 1;
+        unsigned m_putType : 1;

     };
 
     };
 

-    class PropertyListNode : public Node {
+    class PropertyListNode : public ExpressionNode {

     public:
     public:

-        PropertyListNode(JSGlobalData*, PropertyNode*);
-        PropertyListNode(JSGlobalData*, PropertyNode*, PropertyListNode*);
-
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        PropertyListNode(const JSTokenLocation&, PropertyNode*);
+        PropertyListNode(const JSTokenLocation&, PropertyNode*, PropertyListNode*);

 
     private:
 
     private:

+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        void emitPutConstantProperty(BytecodeGenerator&, RegisterID*, PropertyNode&);
+

         PropertyNode* m_node;
         PropertyListNode* m_next;
     };
 
     class ObjectLiteralNode : public ExpressionNode {
     public:
         PropertyNode* m_node;
         PropertyListNode* m_next;
     };
 
     class ObjectLiteralNode : public ExpressionNode {
     public:

-        ObjectLiteralNode(JSGlobalData*);
-        ObjectLiteralNode(JSGlobalData*, PropertyListNode*);
+        ObjectLiteralNode(const JSTokenLocation&);
+        ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         PropertyListNode* m_list;
     };
     
     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
         PropertyListNode* m_list;
     };
     
     class BracketAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        BracketAccessorNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);
+        BracketAccessorNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments);

 
         ExpressionNode* base() const { return m_base; }
         ExpressionNode* subscript() const { return m_subscript; }
 
 
         ExpressionNode* base() const { return m_base; }
         ExpressionNode* subscript() const { return m_subscript; }
 

+        bool subscriptHasAssignments() const { return m_subscriptHasAssignments; }
+

     private:
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isLocation() const { return true; }
-        virtual bool isBracketAccessorNode() const { return true; }
+        virtual bool isLocation() const override { return true; }
+        virtual bool isBracketAccessorNode() const override { return true; }

 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;


@@ -467,48 +649,61 @@ namespace JSC {
 
     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class DotAccessorNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        DotAccessorNode(JSGlobalData*, ExpressionNode* base, const Identifier&);
+        DotAccessorNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&);

 
         ExpressionNode* base() const { return m_base; }
         const Identifier& identifier() const { return m_ident; }
 
     private:
 
         ExpressionNode* base() const { return m_base; }
         const Identifier& identifier() const { return m_ident; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isLocation() const { return true; }
-        virtual bool isDotAccessorNode() const { return true; }
+        virtual bool isLocation() const override { return true; }
+        virtual bool isDotAccessorNode() const override { return true; }

 
         ExpressionNode* m_base;
         const Identifier& m_ident;
     };
 
 
         ExpressionNode* m_base;
         const Identifier& m_ident;
     };
 

-    class ArgumentListNode : public Node {
+    class SpreadExpressionNode : public ExpressionNode, public ThrowableExpressionData {
+    public:
+        SpreadExpressionNode(const JSTokenLocation&, ExpressionNode*);
+        
+        ExpressionNode* expression() const { return m_expression; }
+        
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        
+        virtual bool isSpreadExpression() const override { return true; }
+        ExpressionNode* m_expression;
+    };
+
+    class ArgumentListNode : public ExpressionNode {

     public:
     public:

-        ArgumentListNode(JSGlobalData*, ExpressionNode*);
-        ArgumentListNode(JSGlobalData*, ArgumentListNode*, ExpressionNode*);
+        ArgumentListNode(const JSTokenLocation&, ExpressionNode*);
+        ArgumentListNode(const JSTokenLocation&, ArgumentListNode*, ExpressionNode*);

 
         ArgumentListNode* m_next;
         ExpressionNode* m_expr;
 
     private:
 
         ArgumentListNode* m_next;
         ExpressionNode* m_expr;
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class ArgumentsNode : public ParserArenaFreeable {
     public:
     };
 
     class ArgumentsNode : public ParserArenaFreeable {
     public:

-        ArgumentsNode(JSGlobalData*);
-        ArgumentsNode(JSGlobalData*, ArgumentListNode*);
+        ArgumentsNode();
+        ArgumentsNode(ArgumentListNode*);

 
         ArgumentListNode* m_listNode;
     };
 
     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
         ArgumentListNode* m_listNode;
     };
 
     class NewExprNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        NewExprNode(JSGlobalData*, ExpressionNode*);
-        NewExprNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*);
+        NewExprNode(const JSTokenLocation&, ExpressionNode*);
+        NewExprNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
         ArgumentsNode* m_args;
 
         ExpressionNode* m_expr;
         ArgumentsNode* m_args;


@@ -516,20 +711,20 @@ namespace JSC {
 
     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class EvalFunctionCallNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        EvalFunctionCallNode(JSGlobalData*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        EvalFunctionCallNode(const JSTokenLocation&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ArgumentsNode* m_args;
     };
 
     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
         ArgumentsNode* m_args;
     };
 
     class FunctionCallValueNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        FunctionCallValueNode(JSGlobalData*, ExpressionNode*, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallValueNode(const JSTokenLocation&, ExpressionNode*, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
         ArgumentsNode* m_args;
 
         ExpressionNode* m_expr;
         ArgumentsNode* m_args;


@@ -537,35 +732,34 @@ namespace JSC {
 
     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class FunctionCallResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        FunctionCallResolveNode(JSGlobalData*, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallResolveNode(const JSTokenLocation&, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
         ArgumentsNode* m_args;
 
         const Identifier& m_ident;
         ArgumentsNode* m_args;

-        size_t m_index; // Used by LocalVarFunctionCallNode.
-        size_t m_scopeDepth; // Used by ScopedVarFunctionCallNode and NonLocalVarFunctionCallNode

     };
     
     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
     };
     
     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:

-        FunctionCallBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ArgumentsNode* m_args;
 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ArgumentsNode* m_args;

+        bool m_subscriptHasAssignments;

     };
 
     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
     };
 
     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:

-        FunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        FunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
     protected:
         ExpressionNode* m_base;
 
     protected:
         ExpressionNode* m_base;


@@ -573,91 +767,58 @@ namespace JSC {
         ArgumentsNode* m_args;
     };
 
         ArgumentsNode* m_args;
     };
 

-    class CallFunctionCallDotNode : public FunctionCallDotNode {
+    class BytecodeIntrinsicNode : public ExpressionNode, public ThrowableExpressionData {

     public:
     public:

-        CallFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
+        typedef RegisterID* (BytecodeIntrinsicNode::* EmitterType)(BytecodeGenerator&, RegisterID*);

 
 

-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-    };
-    
-    class ApplyFunctionCallDotNode : public FunctionCallDotNode {
-    public:
-        ApplyFunctionCallDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-    };
-
-    class PrePostResolveNode : public ExpressionNode, public ThrowableExpressionData {
-    public:
-        PrePostResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
-
-    protected:
-        const Identifier& m_ident;
-    };
-
-    class PostfixResolveNode : public PrePostResolveNode {
-    public:
-        PostfixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        BytecodeIntrinsicNode(const JSTokenLocation&, EmitterType, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
 

-        Operator m_operator;
-    };
+        const Identifier& identifier() const { return m_ident; }

 
 

-    class PostfixBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
-    public:
-        PostfixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+#define JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS(name) RegisterID* emit_intrinsic_##name(BytecodeGenerator&, RegisterID*);
+        JSC_COMMON_BYTECODE_INTRINSICS_EACH_NAME(JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS)
+#undef JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        ExpressionNode* m_base;
-        ExpressionNode* m_subscript;
-        Operator m_operator;
+        EmitterType m_emitter;
+        const Identifier& m_ident;
+        ArgumentsNode* m_args;

     };
 
     };
 

-    class PostfixDotNode : public ExpressionNode, public ThrowableSubExpressionData {
+    class CallFunctionCallDotNode : public FunctionCallDotNode {

     public:
     public:

-        PostfixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        ExpressionNode* m_base;
-        const Identifier& m_ident;
-        Operator m_operator;
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
     };

-
-    class PostfixErrorNode : public ExpressionNode, public ThrowableSubExpressionData {
+    
+    class ApplyFunctionCallDotNode : public FunctionCallDotNode {

     public:
     public:

-        PostfixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ApplyFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        ExpressionNode* m_expr;
-        Operator m_operator;
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
     };
 
     class DeleteResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        DeleteResolveNode(JSGlobalData*, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteResolveNode(const JSTokenLocation&, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
     };
 
     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
         const Identifier& m_ident;
     };
 
     class DeleteBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        DeleteBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;


@@ -665,10 +826,10 @@ namespace JSC {
 
     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class DeleteDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        DeleteDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, unsigned divot, unsigned startOffset, unsigned endOffset);
+        DeleteDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         const Identifier& m_ident;
 
         ExpressionNode* m_base;
         const Identifier& m_ident;


@@ -676,101 +837,81 @@ namespace JSC {
 
     class DeleteValueNode : public ExpressionNode {
     public:
 
     class DeleteValueNode : public ExpressionNode {
     public:

-        DeleteValueNode(JSGlobalData*, ExpressionNode*);
+        DeleteValueNode(const JSTokenLocation&, ExpressionNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
     class VoidNode : public ExpressionNode {
     public:
 
         ExpressionNode* m_expr;
     };
 
     class VoidNode : public ExpressionNode {
     public:

-        VoidNode(JSGlobalData*, ExpressionNode*);
+        VoidNode(const JSTokenLocation&, ExpressionNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
     class TypeOfResolveNode : public ExpressionNode {
     public:
 
         ExpressionNode* m_expr;
     };
 
     class TypeOfResolveNode : public ExpressionNode {
     public:

-        TypeOfResolveNode(JSGlobalData*, const Identifier&);
+        TypeOfResolveNode(const JSTokenLocation&, const Identifier&);

 
         const Identifier& identifier() const { return m_ident; }
 
     private:
 
         const Identifier& identifier() const { return m_ident; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
     };
 
     class TypeOfValueNode : public ExpressionNode {
     public:
 
         const Identifier& m_ident;
     };
 
     class TypeOfValueNode : public ExpressionNode {
     public:

-        TypeOfValueNode(JSGlobalData*, ExpressionNode*);
+        TypeOfValueNode(const JSTokenLocation&, ExpressionNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
 
         ExpressionNode* m_expr;
     };
 

-    class PrefixResolveNode : public PrePostResolveNode {
+    class PrefixNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {

     public:
     public:

-        PrefixResolveNode(JSGlobalData*, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PrefixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
 

-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        Operator m_operator;
-    };
-
-    class PrefixBracketNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
-    public:
-        PrefixBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+    protected:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0);

 
 

-        ExpressionNode* m_base;
-        ExpressionNode* m_subscript;
+        ExpressionNode* m_expr;

         Operator m_operator;
     };
 
         Operator m_operator;
     };
 

-    class PrefixDotNode : public ExpressionNode, public ThrowablePrefixedSubExpressionData {
+    class PostfixNode : public PrefixNode {

     public:
     public:

-        PrefixDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
+        PostfixNode(const JSTokenLocation&, ExpressionNode*, Operator, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        ExpressionNode* m_base;
-        const Identifier& m_ident;
-        Operator m_operator;
-    };
-
-    class PrefixErrorNode : public ExpressionNode, public ThrowableExpressionData {
-    public:
-        PrefixErrorNode(JSGlobalData*, ExpressionNode*, Operator, unsigned divot, unsigned startOffset, unsigned endOffset);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        ExpressionNode* m_expr;
-        Operator m_operator;
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual RegisterID* emitResolve(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual RegisterID* emitBracket(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual RegisterID* emitDot(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class UnaryOpNode : public ExpressionNode {
     public:
     };
 
     class UnaryOpNode : public ExpressionNode {
     public:

-        UnaryOpNode(JSGlobalData*, ResultType, ExpressionNode*, OpcodeID);
+        UnaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode*, OpcodeID);

 
     protected:
         ExpressionNode* expr() { return m_expr; }
         const ExpressionNode* expr() const { return m_expr; }
 
     private:
 
     protected:
         ExpressionNode* expr() { return m_expr; }
         const ExpressionNode* expr() const { return m_expr; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         OpcodeID opcodeID() const { return m_opcodeID; }
 
 
         OpcodeID opcodeID() const { return m_opcodeID; }
 


@@ -780,42 +921,52 @@ namespace JSC {
 
     class UnaryPlusNode : public UnaryOpNode {
     public:
 
     class UnaryPlusNode : public UnaryOpNode {
     public:

-        UnaryPlusNode(JSGlobalData*, ExpressionNode*);
+        UnaryPlusNode(const JSTokenLocation&, ExpressionNode*);

 
     private:
 
     private:

-        virtual ExpressionNode* stripUnaryPlus() { return expr(); }
+        virtual ExpressionNode* stripUnaryPlus() override { return expr(); }

     };
 
     class NegateNode : public UnaryOpNode {
     public:
     };
 
     class NegateNode : public UnaryOpNode {
     public:

-        NegateNode(JSGlobalData*, ExpressionNode*);
+        NegateNode(const JSTokenLocation&, ExpressionNode*);

     };
 
     };
 

-    class BitwiseNotNode : public UnaryOpNode {
+    class BitwiseNotNode : public ExpressionNode {

     public:
     public:

-        BitwiseNotNode(JSGlobalData*, ExpressionNode*);
-    };
+        BitwiseNotNode(const JSTokenLocation&, ExpressionNode*);

 
 

+    protected:
+        ExpressionNode* expr() { return m_expr; }
+        const ExpressionNode* expr() const { return m_expr; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        ExpressionNode* m_expr;
+    };
+ 

     class LogicalNotNode : public UnaryOpNode {
     public:
     class LogicalNotNode : public UnaryOpNode {
     public:

-        LogicalNotNode(JSGlobalData*, ExpressionNode*);
+        LogicalNotNode(const JSTokenLocation&, ExpressionNode*);

     private:
     private:

-        void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
-        virtual bool hasConditionContextCodegen() const { return expr()->hasConditionContextCodegen(); }
+        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) override;

     };
 
     class BinaryOpNode : public ExpressionNode {
     public:
     };
 
     class BinaryOpNode : public ExpressionNode {
     public:

-        BinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-        BinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        BinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        BinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

 
         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);
 
         RegisterID* emitStrcat(BytecodeGenerator& generator, RegisterID* destination, RegisterID* lhs = 0, ReadModifyResolveNode* emitExpressionInfoForMe = 0);

+        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) override;

 
         ExpressionNode* lhs() { return m_expr1; };
         ExpressionNode* rhs() { return m_expr2; };
 
     private:
 
         ExpressionNode* lhs() { return m_expr1; };
         ExpressionNode* rhs() { return m_expr2; };
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        void tryFoldToBranch(BytecodeGenerator&, TriState& branchCondition, ExpressionNode*& branchExpression);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
     protected:
         OpcodeID opcodeID() const { return m_opcodeID; }
 
     protected:
         OpcodeID opcodeID() const { return m_opcodeID; }


@@ -829,150 +980,141 @@ namespace JSC {
         bool m_rightHasAssignments;
     };
 
         bool m_rightHasAssignments;
     };
 

-    class ReverseBinaryOpNode : public BinaryOpNode {
-    public:
-        ReverseBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-        ReverseBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-    };
-

     class MultNode : public BinaryOpNode {
     public:
     class MultNode : public BinaryOpNode {
     public:

-        MultNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        MultNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class DivNode : public BinaryOpNode {
     public:
     };
 
     class DivNode : public BinaryOpNode {
     public:

-        DivNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        DivNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class ModNode : public BinaryOpNode {
     public:
     };
 
     class ModNode : public BinaryOpNode {
     public:

-        ModNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        ModNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class AddNode : public BinaryOpNode {
     public:
     };
 
     class AddNode : public BinaryOpNode {
     public:

-        AddNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        AddNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

 
 

-        virtual bool isAdd() const { return true; }
+        virtual bool isAdd() const override { return true; }

     };
 
     class SubNode : public BinaryOpNode {
     public:
     };
 
     class SubNode : public BinaryOpNode {
     public:

-        SubNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        SubNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

 
 

-        virtual bool isSubtract() const { return true; }
+        virtual bool isSubtract() const override { return true; }

     };
 
     class LeftShiftNode : public BinaryOpNode {
     public:
     };
 
     class LeftShiftNode : public BinaryOpNode {
     public:

-        LeftShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LeftShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class RightShiftNode : public BinaryOpNode {
     public:
     };
 
     class RightShiftNode : public BinaryOpNode {
     public:

-        RightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        RightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class UnsignedRightShiftNode : public BinaryOpNode {
     public:
     };
 
     class UnsignedRightShiftNode : public BinaryOpNode {
     public:

-        UnsignedRightShiftNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        UnsignedRightShiftNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class LessNode : public BinaryOpNode {
     public:
     };
 
     class LessNode : public BinaryOpNode {
     public:

-        LessNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LessNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     };
 

-    class GreaterNode : public ReverseBinaryOpNode {
+    class GreaterNode : public BinaryOpNode {

     public:
     public:

-        GreaterNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        GreaterNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class LessEqNode : public BinaryOpNode {
     public:
     };
 
     class LessEqNode : public BinaryOpNode {
     public:

-        LessEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        LessEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     };
 

-    class GreaterEqNode : public ReverseBinaryOpNode {
+    class GreaterEqNode : public BinaryOpNode {

     public:
     public:

-        GreaterEqNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        GreaterEqNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
     public:
     };
 
     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
     public:

-        ThrowableBinaryOpNode(JSGlobalData*, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
-        ThrowableBinaryOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        ThrowableBinaryOpNode(const JSTokenLocation&, ResultType, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);
+        ThrowableBinaryOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, OpcodeID, bool rightHasAssignments);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
     
     class InstanceOfNode : public ThrowableBinaryOpNode {
     public:
     };
     
     class InstanceOfNode : public ThrowableBinaryOpNode {
     public:

-        InstanceOfNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        InstanceOfNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class InNode : public ThrowableBinaryOpNode {
     public:
     };
 
     class InNode : public ThrowableBinaryOpNode {
     public:

-        InNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        InNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class EqualNode : public BinaryOpNode {
     public:
     };
 
     class EqualNode : public BinaryOpNode {
     public:

-        EqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        EqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class NotEqualNode : public BinaryOpNode {
     public:
     };
 
     class NotEqualNode : public BinaryOpNode {
     public:

-        NotEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        NotEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class StrictEqualNode : public BinaryOpNode {
     public:
     };
 
     class StrictEqualNode : public BinaryOpNode {
     public:

-        StrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        StrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class NotStrictEqualNode : public BinaryOpNode {
     public:
     };
 
     class NotStrictEqualNode : public BinaryOpNode {
     public:

-        NotStrictEqualNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        NotStrictEqualNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class BitAndNode : public BinaryOpNode {
     public:
     };
 
     class BitAndNode : public BinaryOpNode {
     public:

-        BitAndNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitAndNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class BitOrNode : public BinaryOpNode {
     public:
     };
 
     class BitOrNode : public BinaryOpNode {
     public:

-        BitOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     class BitXOrNode : public BinaryOpNode {
     public:
     };
 
     class BitXOrNode : public BinaryOpNode {
     public:

-        BitXOrNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);
+        BitXOrNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments);

     };
 
     // m_expr1 && m_expr2, m_expr1 || m_expr2
     class LogicalOpNode : public ExpressionNode {
     public:
     };
 
     // m_expr1 && m_expr2, m_expr1 || m_expr2
     class LogicalOpNode : public ExpressionNode {
     public:

-        LogicalOpNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);
+        LogicalOpNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, LogicalOperator);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-        void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, bool fallThroughMeansTrue);
-        virtual bool hasConditionContextCodegen() const { return true; }
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label* trueTarget, Label* falseTarget, FallThroughMode) override;

 
         ExpressionNode* m_expr1;
         ExpressionNode* m_expr2;
 
         ExpressionNode* m_expr1;
         ExpressionNode* m_expr2;


@@ -982,10 +1124,10 @@ namespace JSC {
     // The ternary operator, "m_logical ? m_expr1 : m_expr2"
     class ConditionalNode : public ExpressionNode {
     public:
     // The ternary operator, "m_logical ? m_expr1 : m_expr2"
     class ConditionalNode : public ExpressionNode {
     public:

-        ConditionalNode(JSGlobalData*, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);
+        ConditionalNode(const JSTokenLocation&, ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_logical;
         ExpressionNode* m_expr1;
 
         ExpressionNode* m_logical;
         ExpressionNode* m_expr1;


@@ -994,52 +1136,49 @@ namespace JSC {
 
     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class ReadModifyResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        ReadModifyResolveNode(JSGlobalData*, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyResolveNode(const JSTokenLocation&, const Identifier&, Operator, ExpressionNode*  right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
         ExpressionNode* m_right;
 
         const Identifier& m_ident;
         ExpressionNode* m_right;

-        size_t m_index; // Used by ReadModifyLocalVarNode.

         Operator m_operator;
         bool m_rightHasAssignments;
     };
 
     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
         Operator m_operator;
         bool m_rightHasAssignments;
     };
 
     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        AssignResolveNode(JSGlobalData*, const Identifier&, ExpressionNode* right, bool rightHasAssignments);
+        AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
         ExpressionNode* m_right;
 
         const Identifier& m_ident;
         ExpressionNode* m_right;

-        size_t m_index; // Used by ReadModifyLocalVarNode.
-        bool m_rightHasAssignments;

     };
 
     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
     };
 
     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:

-        ReadModifyBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, Operator, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ExpressionNode* m_right;
 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ExpressionNode* m_right;

-        Operator m_operator : 30;
+        unsigned m_operator : 30;

         bool m_subscriptHasAssignments : 1;
         bool m_rightHasAssignments : 1;
     };
 
     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:
         bool m_subscriptHasAssignments : 1;
         bool m_rightHasAssignments : 1;
     };
 
     class AssignBracketNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        AssignBracketNode(JSGlobalData*, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right, bool subscriptHasAssignments, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
 
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;


@@ -1050,10 +1189,10 @@ namespace JSC {
 
     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:
 
     class AssignDotNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        AssignDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         const Identifier& m_ident;
 
         ExpressionNode* m_base;
         const Identifier& m_ident;


@@ -1063,56 +1202,50 @@ namespace JSC {
 
     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
 
     class ReadModifyDotNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:

-        ReadModifyDotNode(JSGlobalData*, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, unsigned divot, unsigned startOffset, unsigned endOffset);
+        ReadModifyDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, Operator, ExpressionNode* right, bool rightHasAssignments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_base;
         const Identifier& m_ident;
         ExpressionNode* m_right;
 
         ExpressionNode* m_base;
         const Identifier& m_ident;
         ExpressionNode* m_right;

-        Operator m_operator : 31;
+        unsigned m_operator : 31;

         bool m_rightHasAssignments : 1;
     };
 
     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
     public:
         bool m_rightHasAssignments : 1;
     };
 
     class AssignErrorNode : public ExpressionNode, public ThrowableExpressionData {
     public:

-        AssignErrorNode(JSGlobalData*, ExpressionNode* left, Operator, ExpressionNode* right, unsigned divot, unsigned startOffset, unsigned endOffset);
+        AssignErrorNode(const JSTokenLocation&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        ExpressionNode* m_left;
-        Operator m_operator;
-        ExpressionNode* m_right;
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
     
     };
     

-    typedef Vector<ExpressionNode*, 8> ExpressionVector;
-
-    class CommaNode : public ExpressionNode, public ParserArenaDeletable {
+    class CommaNode final : public ExpressionNode {

     public:
     public:

-        CommaNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2);
+        CommaNode(const JSTokenLocation&, ExpressionNode*);

 
 

-        using ParserArenaDeletable::operator new;
-
-        void append(ExpressionNode* expr) { m_expressions.append(expr); }
+        void setNext(CommaNode* next) { m_next = next; }
+        CommaNode* next() { return m_next; }

 
     private:
 
     private:

-        virtual bool isCommaNode() const { return true; }
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual bool isCommaNode() const override { return true; }
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        ExpressionVector m_expressions;
+        ExpressionNode* m_expr;
+        CommaNode* m_next;

     };
     
     class ConstDeclNode : public ExpressionNode {
     public:
     };
     
     class ConstDeclNode : public ExpressionNode {
     public:

-        ConstDeclNode(JSGlobalData*, const Identifier&, ExpressionNode*);
+        ConstDeclNode(const JSTokenLocation&, const Identifier&, ExpressionNode*);

 
         bool hasInitializer() const { return m_init; }
         const Identifier& ident() { return m_ident; }
 
     private:
 
         bool hasInitializer() const { return m_init; }
         const Identifier& ident() { return m_ident; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

         virtual RegisterID* emitCodeSingle(BytecodeGenerator&);
 
         const Identifier& m_ident;
         virtual RegisterID* emitCodeSingle(BytecodeGenerator&);
 
         const Identifier& m_ident;


@@ -1126,17 +1259,17 @@ namespace JSC {
 
     class ConstStatementNode : public StatementNode {
     public:
 
     class ConstStatementNode : public StatementNode {
     public:

-        ConstStatementNode(JSGlobalData*, ConstDeclNode* next);
+        ConstStatementNode(const JSTokenLocation&, ConstDeclNode* next);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ConstDeclNode* m_next;
     };
 
 
         ConstDeclNode* m_next;
     };
 

-    class SourceElements : public ParserArenaDeletable {
+    class SourceElements final : public ParserArenaFreeable {

     public:
     public:

-        SourceElements(JSGlobalData*);
+        SourceElements();

 
         void append(StatementNode*);
 
 
         void append(StatementNode*);
 


@@ -1146,93 +1279,97 @@ namespace JSC {
         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
 
     private:
         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
 
     private:

-        Vector<StatementNode*> m_statements;
+        StatementNode* m_head;
+        StatementNode* m_tail;

     };
 
     class BlockNode : public StatementNode {
     public:
     };
 
     class BlockNode : public StatementNode {
     public:

-        BlockNode(JSGlobalData*, SourceElements* = 0);
+        BlockNode(const JSTokenLocation&, SourceElements* = 0);

 
         StatementNode* singleStatement() const;
         StatementNode* lastStatement() const;
 
     private:
 
         StatementNode* singleStatement() const;
         StatementNode* lastStatement() const;
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isBlock() const { return true; }
+        virtual bool isBlock() const override { return true; }

 
         SourceElements* m_statements;
     };
 
     class EmptyStatementNode : public StatementNode {
     public:
 
         SourceElements* m_statements;
     };
 
     class EmptyStatementNode : public StatementNode {
     public:

-        EmptyStatementNode(JSGlobalData*);
+        EmptyStatementNode(const JSTokenLocation&);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isEmptyStatement() const { return true; }
+        virtual bool isEmptyStatement() const override { return true; }

     };
     
     class DebuggerStatementNode : public StatementNode {
     public:
     };
     
     class DebuggerStatementNode : public StatementNode {
     public:

-        DebuggerStatementNode(JSGlobalData*);
+        DebuggerStatementNode(const JSTokenLocation&);

         
     private:
         
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class ExprStatementNode : public StatementNode {
     public:
     };
 
     class ExprStatementNode : public StatementNode {
     public:

-        ExprStatementNode(JSGlobalData*, ExpressionNode*);
+        ExprStatementNode(const JSTokenLocation&, ExpressionNode*);

 
         ExpressionNode* expr() const { return m_expr; }
 
     private:
 
         ExpressionNode* expr() const { return m_expr; }
 
     private:

-        virtual bool isExprStatement() const { return true; }
+        virtual bool isExprStatement() const override { return true; }

 
 

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
     class VarStatementNode : public StatementNode {
     public:
 
         ExpressionNode* m_expr;
     };
 
     class VarStatementNode : public StatementNode {
     public:

-        VarStatementNode(JSGlobalData*, ExpressionNode*);        
-
+        VarStatementNode(const JSTokenLocation&, ExpressionNode*);

     private:
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
 
         ExpressionNode* m_expr;
     };
 

-    class IfNode : public StatementNode {
+    class EmptyVarExpression : public ExpressionNode {

     public:
     public:

-        IfNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock);
+        EmptyVarExpression(const JSTokenLocation&, const Identifier&);

 
 

-    protected:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        ExpressionNode* m_condition;
-        StatementNode* m_ifBlock;
+        const Identifier& m_ident;

     };
 
     };
 

-    class IfElseNode : public IfNode {
+
+    class IfElseNode : public StatementNode {

     public:
     public:

-        IfElseNode(JSGlobalData*, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
+        IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        bool tryFoldBreakAndContinue(BytecodeGenerator&, StatementNode* ifBlock,
+            Label*& trueTarget, FallThroughMode&);

 
 

+        ExpressionNode* m_condition;
+        StatementNode* m_ifBlock;

         StatementNode* m_elseBlock;
     };
 
     class DoWhileNode : public StatementNode {
     public:
         StatementNode* m_elseBlock;
     };
 
     class DoWhileNode : public StatementNode {
     public:

-        DoWhileNode(JSGlobalData*, StatementNode* statement, ExpressionNode*);
+        DoWhileNode(const JSTokenLocation&, StatementNode*, ExpressionNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         StatementNode* m_statement;
         ExpressionNode* m_expr;
 
         StatementNode* m_statement;
         ExpressionNode* m_expr;


@@ -1240,10 +1377,10 @@ namespace JSC {
 
     class WhileNode : public StatementNode {
     public:
 
     class WhileNode : public StatementNode {
     public:

-        WhileNode(JSGlobalData*, ExpressionNode*, StatementNode* statement);
+        WhileNode(const JSTokenLocation&, ExpressionNode*, StatementNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
         StatementNode* m_statement;
 
         ExpressionNode* m_expr;
         StatementNode* m_statement;


@@ -1251,89 +1388,106 @@ namespace JSC {
 
     class ForNode : public StatementNode {
     public:
 
     class ForNode : public StatementNode {
     public:

-        ForNode(JSGlobalData*, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl);
+        ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr1;
         ExpressionNode* m_expr2;
         ExpressionNode* m_expr3;
         StatementNode* m_statement;
 
         ExpressionNode* m_expr1;
         ExpressionNode* m_expr2;
         ExpressionNode* m_expr3;
         StatementNode* m_statement;

-        bool m_expr1WasVarDecl;

     };
     };

-
-    class ForInNode : public StatementNode, public ThrowableExpressionData {
+    
+    class DestructuringPatternNode;
+    
+    class EnumerationNode : public StatementNode, public ThrowableExpressionData {

     public:
     public:

-        ForInNode(JSGlobalData*, ExpressionNode*, ExpressionNode*, StatementNode*);
-        ForInNode(JSGlobalData*, const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*, int divot, int startOffset, int endOffset);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
-
-        const Identifier& m_ident;
-        ExpressionNode* m_init;
+        EnumerationNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+        
+    protected:

         ExpressionNode* m_lexpr;
         ExpressionNode* m_expr;
         StatementNode* m_statement;
         ExpressionNode* m_lexpr;
         ExpressionNode* m_expr;
         StatementNode* m_statement;

-        bool m_identIsVarDecl;
+    };
+    
+    class ForInNode : public EnumerationNode {
+    public:
+        ForInNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+
+    private:
+        RegisterID* tryGetBoundLocal(BytecodeGenerator&);
+        void emitLoopHeader(BytecodeGenerator&, RegisterID* propertyName);
+        void emitMultiLoopBytecode(BytecodeGenerator&, RegisterID* dst);
+
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+    };
+    
+    class ForOfNode : public EnumerationNode {
+    public:
+        ForOfNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+        
+    private:
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

     };
 
     class ContinueNode : public StatementNode, public ThrowableExpressionData {
     public:
     };
 
     class ContinueNode : public StatementNode, public ThrowableExpressionData {
     public:

-        ContinueNode(JSGlobalData*);
-        ContinueNode(JSGlobalData*, const Identifier&);
+        ContinueNode(const JSTokenLocation&, const Identifier&);
+        Label* trivialTarget(BytecodeGenerator&);

         
     private:
         
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual bool isContinue() const override { return true; }
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
     };
 
     class BreakNode : public StatementNode, public ThrowableExpressionData {
     public:
 
         const Identifier& m_ident;
     };
 
     class BreakNode : public StatementNode, public ThrowableExpressionData {
     public:

-        BreakNode(JSGlobalData*);
-        BreakNode(JSGlobalData*, const Identifier&);
+        BreakNode(const JSTokenLocation&, const Identifier&);
+        Label* trivialTarget(BytecodeGenerator&);

         
     private:
         
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual bool isBreak() const override { return true; }
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_ident;
     };
 
     class ReturnNode : public StatementNode, public ThrowableExpressionData {
     public:
 
         const Identifier& m_ident;
     };
 
     class ReturnNode : public StatementNode, public ThrowableExpressionData {
     public:

-        ReturnNode(JSGlobalData*, ExpressionNode* value);
+        ReturnNode(const JSTokenLocation&, ExpressionNode* value);

 
         ExpressionNode* value() { return m_value; }
 
     private:
 
         ExpressionNode* value() { return m_value; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isReturnNode() const { return true; }
+        virtual bool isReturnNode() const override { return true; }

 
         ExpressionNode* m_value;
     };
 
     class WithNode : public StatementNode {
     public:
 
         ExpressionNode* m_value;
     };
 
     class WithNode : public StatementNode {
     public:

-        WithNode(JSGlobalData*, ExpressionNode*, StatementNode*, uint32_t divot, uint32_t expressionLength);
+        WithNode(const JSTokenLocation&, ExpressionNode*, StatementNode*, const JSTextPosition& divot, uint32_t expressionLength);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
         StatementNode* m_statement;
 
         ExpressionNode* m_expr;
         StatementNode* m_statement;

-        uint32_t m_divot;
+        JSTextPosition m_divot;

         uint32_t m_expressionLength;
     };
 
     class LabelNode : public StatementNode, public ThrowableExpressionData {
     public:
         uint32_t m_expressionLength;
     };
 
     class LabelNode : public StatementNode, public ThrowableExpressionData {
     public:

-        LabelNode(JSGlobalData*, const Identifier& name, StatementNode*);
+        LabelNode(const JSTokenLocation&, const Identifier& name, StatementNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         const Identifier& m_name;
         StatementNode* m_statement;
 
         const Identifier& m_name;
         StatementNode* m_statement;


@@ -1341,216 +1495,424 @@ namespace JSC {
 
     class ThrowNode : public StatementNode, public ThrowableExpressionData {
     public:
 
     class ThrowNode : public StatementNode, public ThrowableExpressionData {
     public:

-        ThrowNode(JSGlobalData*, ExpressionNode*);
+        ThrowNode(const JSTokenLocation&, ExpressionNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
     };
 
     class TryNode : public StatementNode {
     public:
 
         ExpressionNode* m_expr;
     };
 
     class TryNode : public StatementNode {
     public:

-        TryNode(JSGlobalData*, StatementNode* tryBlock, const Identifier& exceptionIdent, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock);
+        TryNode(const JSTokenLocation&, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         StatementNode* m_tryBlock;
 
         StatementNode* m_tryBlock;

-        const Identifier& m_exceptionIdent;
+        const Identifier& m_thrownValueIdent;

         StatementNode* m_catchBlock;
         StatementNode* m_finallyBlock;
         StatementNode* m_catchBlock;
         StatementNode* m_finallyBlock;

-        bool m_catchHasEval;

     };
 
     };
 

-    class ParameterNode : public ParserArenaFreeable {
+    class ParameterNode : public ParserArenaDeletable {

     public:
     public:

-        ParameterNode(JSGlobalData*, const Identifier&);
-        ParameterNode(JSGlobalData*, ParameterNode*, const Identifier&);
+        ParameterNode(PassRefPtr<DestructuringPatternNode>);
+        ParameterNode(ParameterNode*, PassRefPtr<DestructuringPatternNode>);

 
 

-        const Identifier& ident() const { return m_ident; }
+        DestructuringPatternNode* pattern() const { return m_pattern.get(); }

         ParameterNode* nextParam() const { return m_next; }
 
     private:
         ParameterNode* nextParam() const { return m_next; }
 
     private:

-        const Identifier& m_ident;
+        RefPtr<DestructuringPatternNode> m_pattern;

         ParameterNode* m_next;
     };
 
         ParameterNode* m_next;
     };
 

-    struct ScopeNodeData {
-        WTF_MAKE_FAST_ALLOCATED;
+    class ScopeNode : public StatementNode, public ParserArenaRoot {

     public:
         typedef DeclarationStacks::VarStack VarStack;
         typedef DeclarationStacks::FunctionStack FunctionStack;
 
     public:
         typedef DeclarationStacks::VarStack VarStack;
         typedef DeclarationStacks::FunctionStack FunctionStack;
 

-        ScopeNodeData(ParserArena&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, int numConstants);
+        ScopeNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, bool inStrictContext);
+        ScopeNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, const SourceCode&, SourceElements*, VarStack&, FunctionStack&, IdentifierSet&, CodeFeatures, int numConstants);

 
 

-        ParserArena m_arena;
-        VarStack m_varStack;
-        FunctionStack m_functionStack;
-        int m_numConstants;
-        SourceElements* m_statements;
-        IdentifierSet m_capturedVariables;
-    };
-
-    class ScopeNode : public StatementNode, public ParserArenaRefCounted {
-    public:
-        typedef DeclarationStacks::VarStack VarStack;
-        typedef DeclarationStacks::FunctionStack FunctionStack;
-
-        ScopeNode(JSGlobalData*, bool inStrictContext);
-        ScopeNode(JSGlobalData*, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
-
-        using ParserArenaRefCounted::operator new;
-
-        ScopeNodeData* data() const { return m_data.get(); }
-        void destroyData() { m_data.clear(); }
+        using ParserArenaRoot::operator new;

 
         const SourceCode& source() const { return m_source; }
 
         const SourceCode& source() const { return m_source; }

-        const UString& sourceURL() const { return m_source.provider()->url(); }
-        intptr_t sourceID() const { return m_source.provider()->asID(); }
+        const String& sourceURL() const { return m_source.provider()->url(); }
+        intptr_t sourceID() const { return m_source.providerID(); }
+
+        int startLine() const { return m_startLineNumber; }
+        int startStartOffset() const { return m_startStartOffset; }
+        int startLineStartOffset() const { return m_startLineStartOffset; }

 
         void setFeatures(CodeFeatures features) { m_features = features; }
         CodeFeatures features() { return m_features; }
 
         bool usesEval() const { return m_features & EvalFeature; }
         bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }
 
         void setFeatures(CodeFeatures features) { m_features = features; }
         CodeFeatures features() { return m_features; }
 
         bool usesEval() const { return m_features & EvalFeature; }
         bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }

+        bool modifiesParameter() const { return m_features & ModifiedParameterFeature; }
+        bool modifiesArguments() const { return m_features & (EvalFeature | ModifiedArgumentsFeature); }

         bool isStrictMode() const { return m_features & StrictModeFeature; }
         void setUsesArguments() { m_features |= ArgumentsFeature; }
         bool usesThis() const { return m_features & ThisFeature; }
         bool isStrictMode() const { return m_features & StrictModeFeature; }
         void setUsesArguments() { m_features |= ArgumentsFeature; }
         bool usesThis() const { return m_features & ThisFeature; }

-        bool needsActivationForMoreThanVariables() const { ASSERT(m_data); return m_features & (EvalFeature | WithFeature | CatchFeature); }
-        bool needsActivation() const { ASSERT(m_data); return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature | CatchFeature)); }
-        bool hasCapturedVariables() const { return !!m_data->m_capturedVariables.size(); }
-        size_t capturedVariableCount() const { return m_data->m_capturedVariables.size(); }
-        bool captures(const Identifier& ident) { return m_data->m_capturedVariables.contains(ident.impl()); }
+        bool needsActivationForMoreThanVariables() const { return m_features & (EvalFeature | WithFeature | CatchFeature); }
+        bool needsActivation() const { return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature | CatchFeature)); }
+        bool hasCapturedVariables() const { return !!m_capturedVariables.size(); }
+        size_t capturedVariableCount() const { return m_capturedVariables.size(); }
+        const IdentifierSet& capturedVariables() const { return m_capturedVariables; }
+        bool captures(UniquedStringImpl* uid) { return m_capturedVariables.contains(uid); }
+        bool captures(const Identifier& ident) { return captures(ident.impl()); }

 
 

-        VarStack& varStack() { ASSERT(m_data); return m_data->m_varStack; }
-        FunctionStack& functionStack() { ASSERT(m_data); return m_data->m_functionStack; }
+        VarStack& varStack() { return m_varStack; }
+        FunctionStack& functionStack() { return m_functionStack; }

 
         int neededConstants()
         {
 
         int neededConstants()
         {

-            ASSERT(m_data);

             // We may need 2 more constants than the count given by the parser,
             // because of the various uses of jsUndefined() and jsNull().
             // We may need 2 more constants than the count given by the parser,
             // because of the various uses of jsUndefined() and jsNull().

-            return m_data->m_numConstants + 2;
+            return m_numConstants + 2;

         }
 
         StatementNode* singleStatement() const;
 
         void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination);
         }
 
         StatementNode* singleStatement() const;
 
         void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination);

+        
+        void setClosedVariables(Vector<RefPtr<UniquedStringImpl>>&&) { }

 
     protected:
 
     protected:

-        void setSource(const SourceCode& source) { m_source = source; }
+        int m_startLineNumber;
+        unsigned m_startStartOffset;
+        unsigned m_startLineStartOffset;

 
     private:
 
     private:

-        OwnPtr<ScopeNodeData> m_data;

         CodeFeatures m_features;
         SourceCode m_source;
         CodeFeatures m_features;
         SourceCode m_source;

+        VarStack m_varStack;
+        FunctionStack m_functionStack;
+        int m_numConstants;
+        SourceElements* m_statements;
+        IdentifierSet m_capturedVariables;

     };
 
     class ProgramNode : public ScopeNode {
     public:
     };
 
     class ProgramNode : public ScopeNode {
     public:

-        static const bool isFunctionNode = false;
-        static PassRefPtr<ProgramNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        ProgramNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack&, FunctionStack&, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+
+        unsigned startColumn() const { return m_startColumn; }
+        unsigned endColumn() const { return m_endColumn; }

 
         static const bool scopeIsFunction = false;
 
 
         static const bool scopeIsFunction = false;
 

-    private:
-        ProgramNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        void setClosedVariables(Vector<RefPtr<UniquedStringImpl>>&&);
+        const Vector<RefPtr<UniquedStringImpl>>& closedVariables() const { return m_closedVariables; }

 
 

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+    private:
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        Vector<RefPtr<UniquedStringImpl>> m_closedVariables;
+        unsigned m_startColumn;
+        unsigned m_endColumn;

     };
 
     class EvalNode : public ScopeNode {
     public:
     };
 
     class EvalNode : public ScopeNode {
     public:

-        static const bool isFunctionNode = false;
-        static PassRefPtr<EvalNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        EvalNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack&, FunctionStack&, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+
+        ALWAYS_INLINE unsigned startColumn() const { return 0; }
+        unsigned endColumn() const { return m_endColumn; }

 
         static const bool scopeIsFunction = false;
 
     private:
 
         static const bool scopeIsFunction = false;
 
     private:

-        EvalNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        unsigned m_endColumn;

     };
 
     };
 

-    class FunctionParameters : public Vector<Identifier>, public RefCounted<FunctionParameters> {
+    class FunctionParameters : public RefCounted<FunctionParameters> {

         WTF_MAKE_FAST_ALLOCATED;
         WTF_MAKE_FAST_ALLOCATED;

+        WTF_MAKE_NONCOPYABLE(FunctionParameters);

     public:
     public:

-        static PassRefPtr<FunctionParameters> create(ParameterNode* firstParameter) { return adoptRef(new FunctionParameters(firstParameter)); }
+        static Ref<FunctionParameters> create(ParameterNode*);
+        ~FunctionParameters();
+
+        unsigned size() const { return m_size; }
+        DestructuringPatternNode* at(unsigned index) { ASSERT(index < m_size); return patterns()[index]; }

 
     private:
 
     private:

-        FunctionParameters(ParameterNode*);
+        FunctionParameters(ParameterNode*, unsigned size);
+
+        DestructuringPatternNode** patterns() { return &m_storage; }
+
+        unsigned m_size;
+        DestructuringPatternNode* m_storage;

     };
 
     };
 

-    class FunctionBodyNode : public ScopeNode {
+    class FunctionBodyNode final : public StatementNode, public ParserArenaDeletable {

     public:
     public:

-        static const bool isFunctionNode = true;
-        static FunctionBodyNode* create(JSGlobalData*, bool isStrictMode);
-        static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+        using ParserArenaDeletable::operator new;
+
+        FunctionBodyNode(
+            ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, 
+            unsigned startColumn, unsigned endColumn, int functionKeywordStart, 
+            int functionNameStart, int parametersStart, bool isInStrictContext, 
+            ConstructorKind);

 
         FunctionParameters* parameters() const { return m_parameters.get(); }
 
         FunctionParameters* parameters() const { return m_parameters.get(); }

-        size_t parameterCount() const { return m_parameters->size(); }

 
 

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        void finishParsing(const SourceCode&, ParameterNode*, const Identifier&);
-        void finishParsing(PassRefPtr<FunctionParameters>, const Identifier&);
+        void finishParsing(const SourceCode&, ParameterNode*, const Identifier&, FunctionMode);

         
         

+        void overrideName(const Identifier& ident) { m_ident = ident; }

         const Identifier& ident() { return m_ident; }
         const Identifier& ident() { return m_ident; }

+        void setInferredName(const Identifier& inferredName) { ASSERT(!inferredName.isNull()); m_inferredName = inferredName; }
+        const Identifier& inferredName() { return m_inferredName.isEmpty() ? m_ident : m_inferredName; }
+
+        FunctionMode functionMode() { return m_functionMode; }
+
+        int functionNameStart() const { return m_functionNameStart; }
+        int functionKeywordStart() const { return m_functionKeywordStart; }
+        int parametersStart() const { return m_parametersStart; }
+        unsigned startColumn() const { return m_startColumn; }
+        unsigned endColumn() const { return m_endColumn; }
+
+        void setEndPosition(JSTextPosition);
+
+        const SourceCode& source() const { return m_source; }
+
+        int startStartOffset() const { return m_startStartOffset; }
+        bool isInStrictContext() const { return m_isInStrictContext; }
+        ConstructorKind constructorKind() { return static_cast<ConstructorKind>(m_constructorKind); }
+
+    protected:
+        Identifier m_ident;
+        Identifier m_inferredName;
+        FunctionMode m_functionMode;
+        RefPtr<FunctionParameters> m_parameters;
+        unsigned m_startColumn;
+        unsigned m_endColumn;
+        int m_functionKeywordStart;
+        int m_functionNameStart;
+        int m_parametersStart;
+        SourceCode m_source;
+        int m_startStartOffset;
+        unsigned m_isInStrictContext : 1;
+        unsigned m_constructorKind : 2;
+    };
+
+    class FunctionNode final : public ScopeNode {
+    public:
+        FunctionNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack&, FunctionStack&, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+
+        FunctionParameters* parameters() const { return m_parameters.get(); }
+
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        void finishParsing(PassRefPtr<FunctionParameters>, const Identifier&, FunctionMode);
+        
+        const Identifier& ident() { return m_ident; }
+
+        FunctionMode functionMode() { return m_functionMode; }
+
+        unsigned startColumn() const { return m_startColumn; }
+        unsigned endColumn() const { return m_endColumn; }

 
         static const bool scopeIsFunction = true;
 
     private:
 
         static const bool scopeIsFunction = true;
 
     private:

-        FunctionBodyNode(JSGlobalData*, bool inStrictContext);
-        FunctionBodyNode(JSGlobalData*, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
-

         Identifier m_ident;
         Identifier m_ident;

+        FunctionMode m_functionMode;

         RefPtr<FunctionParameters> m_parameters;
         RefPtr<FunctionParameters> m_parameters;

+        unsigned m_startColumn;
+        unsigned m_endColumn;

     };
 
     class FuncExprNode : public ExpressionNode {
     public:
     };
 
     class FuncExprNode : public ExpressionNode {
     public:

-        FuncExprNode(JSGlobalData*, const Identifier&, FunctionBodyNode* body, const SourceCode& source, ParameterNode* parameter = 0);
+        FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);

 
         FunctionBodyNode* body() { return m_body; }
 
     private:
 
         FunctionBodyNode* body() { return m_body; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
 

-        virtual bool isFuncExprNode() const { return true; } 
+        virtual bool isFuncExprNode() const override { return true; }

 
         FunctionBodyNode* m_body;
     };
 
 
         FunctionBodyNode* m_body;
     };
 

+#if ENABLE(ES6_CLASS_SYNTAX)
+    class ClassExprNode final : public ExpressionNode {
+    public:
+        ClassExprNode(const JSTokenLocation&, const Identifier&, ExpressionNode* constructorExpresssion,
+            ExpressionNode* parentClass, PropertyListNode* instanceMethods, PropertyListNode* staticMethods);
+
+        const Identifier& name() { return m_name; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        const Identifier& m_name;
+        ExpressionNode* m_constructorExpression;
+        ExpressionNode* m_classHeritage;
+        PropertyListNode* m_instanceMethods;
+        PropertyListNode* m_staticMethods;
+    };
+#endif
+
+    class DestructuringPatternNode : public RefCounted<DestructuringPatternNode> {
+        WTF_MAKE_NONCOPYABLE(DestructuringPatternNode);
+        WTF_MAKE_FAST_ALLOCATED;
+
+    public:
+        virtual void collectBoundIdentifiers(Vector<Identifier>&) const = 0;
+        virtual void bindValue(BytecodeGenerator&, RegisterID* source) const = 0;
+        virtual void toString(StringBuilder&) const = 0;
+
+        virtual bool isBindingNode() const { return false; }
+        virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID*, ExpressionNode*) { return 0; }
+        
+        virtual ~DestructuringPatternNode() = 0;
+        
+    protected:
+        DestructuringPatternNode();
+    };
+
+    class ArrayPatternNode : public DestructuringPatternNode, public ThrowableExpressionData {
+    public:
+        enum class BindingType {
+            Elision,
+            Element,
+            RestElement
+        };
+
+        static Ref<ArrayPatternNode> create();
+        void appendIndex(BindingType bindingType, const JSTokenLocation&, DestructuringPatternNode* node, ExpressionNode* defaultValue)
+        {
+            m_targetPatterns.append({ bindingType, node, defaultValue });
+        }
+
+    private:
+        struct Entry {
+            BindingType bindingType;
+            RefPtr<DestructuringPatternNode> pattern;
+            ExpressionNode* defaultValue;
+        };
+        ArrayPatternNode();
+        virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
+        virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
+        virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID* dst, ExpressionNode*) override;
+        virtual void toString(StringBuilder&) const override;
+
+        Vector<Entry> m_targetPatterns;
+    };
+    
+    class ObjectPatternNode : public DestructuringPatternNode {
+    public:
+        static Ref<ObjectPatternNode> create();
+        void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
+        {
+            m_targetPatterns.append(Entry{ identifier, wasString, pattern, defaultValue });
+        }
+        
+    private:
+        ObjectPatternNode();
+        virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
+        virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
+        virtual void toString(StringBuilder&) const override;
+        struct Entry {
+            Identifier propertyName;
+            bool wasString;
+            RefPtr<DestructuringPatternNode> pattern;
+            ExpressionNode* defaultValue;
+        };
+        Vector<Entry> m_targetPatterns;
+    };
+
+    class BindingNode : public DestructuringPatternNode {
+    public:
+        static Ref<BindingNode> create(const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end);
+        const Identifier& boundProperty() const { return m_boundProperty; }
+
+        const JSTextPosition& divotStart() const { return m_divotStart; }
+        const JSTextPosition& divotEnd() const { return m_divotEnd; }
+        
+    private:
+        BindingNode(const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end);
+
+        virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
+        virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
+        virtual void toString(StringBuilder&) const override;
+        
+        virtual bool isBindingNode() const override { return true; }
+
+        JSTextPosition m_divotStart;
+        JSTextPosition m_divotEnd;
+        Identifier m_boundProperty;
+    };
+
+    class DestructuringAssignmentNode : public ExpressionNode, public ParserArenaDeletable {
+    public:
+        DestructuringAssignmentNode(const JSTokenLocation&, PassRefPtr<DestructuringPatternNode>, ExpressionNode*);
+        DestructuringPatternNode* bindings() { return m_bindings.get(); }
+        
+        using ParserArenaDeletable::operator new;
+
+    private:
+        virtual bool isAssignmentLocation() const override { return true; }
+        virtual bool isDestructuringNode() const override { return true; }
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        RefPtr<DestructuringPatternNode> m_bindings;
+        ExpressionNode* m_initializer;
+    };
+

     class FuncDeclNode : public StatementNode {
     public:
     class FuncDeclNode : public StatementNode {
     public:

-        FuncDeclNode(JSGlobalData*, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
+        FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);

 
 

+        virtual bool isFuncDeclNode() const override { return true; }

         FunctionBodyNode* body() { return m_body; }
 
     private:
         FunctionBodyNode* body() { return m_body; }
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         FunctionBodyNode* m_body;
     };
 
 
         FunctionBodyNode* m_body;
     };
 

+#if ENABLE(ES6_CLASS_SYNTAX)
+    class ClassDeclNode final : public StatementNode {
+    public:
+        ClassDeclNode(const JSTokenLocation&, ExpressionNode* classExpression);
+
+    private:
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        ExpressionNode* m_classDeclaration;
+    };
+#endif
+

     class CaseClauseNode : public ParserArenaFreeable {
     public:
     class CaseClauseNode : public ParserArenaFreeable {
     public:

-        CaseClauseNode(JSGlobalData*, ExpressionNode*, SourceElements* = 0);
+        CaseClauseNode(ExpressionNode*, SourceElements* = 0);

 
         ExpressionNode* expr() const { return m_expr; }
 
         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
 
         ExpressionNode* expr() const { return m_expr; }
 
         void emitBytecode(BytecodeGenerator&, RegisterID* destination);

+        void setStartOffset(int offset) { m_startOffset = offset; }

 
     private:
         ExpressionNode* m_expr;
         SourceElements* m_statements;
 
     private:
         ExpressionNode* m_expr;
         SourceElements* m_statements;

+        int m_startOffset;

     };
 
     class ClauseListNode : public ParserArenaFreeable {
     public:
     };
 
     class ClauseListNode : public ParserArenaFreeable {
     public:

-        ClauseListNode(JSGlobalData*, CaseClauseNode*);
-        ClauseListNode(JSGlobalData*, ClauseListNode*, CaseClauseNode*);
+        ClauseListNode(CaseClauseNode*);
+        ClauseListNode(ClauseListNode*, CaseClauseNode*);

 
         CaseClauseNode* getClause() const { return m_clause; }
         ClauseListNode* getNext() const { return m_next; }
 
         CaseClauseNode* getClause() const { return m_clause; }
         ClauseListNode* getNext() const { return m_next; }


@@ -1562,12 +1924,13 @@ namespace JSC {
 
     class CaseBlockNode : public ParserArenaFreeable {
     public:
 
     class CaseBlockNode : public ParserArenaFreeable {
     public:

-        CaseBlockNode(JSGlobalData*, ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);
+        CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2);

 
 

-        RegisterID* emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination);
+        void emitBytecodeForBlock(BytecodeGenerator&, RegisterID* input, RegisterID* destination);

 
     private:
 
     private:

-        SwitchInfo::SwitchType tryOptimizedSwitch(Vector<ExpressionNode*, 8>& literalVector, int32_t& min_num, int32_t& max_num);
+        SwitchInfo::SwitchType tryTableSwitch(Vector<ExpressionNode*, 8>& literalVector, int32_t& min_num, int32_t& max_num);
+        static const size_t s_tableSwitchMinimum = 3;

         ClauseListNode* m_list1;
         CaseClauseNode* m_defaultClause;
         ClauseListNode* m_list2;
         ClauseListNode* m_list1;
         CaseClauseNode* m_defaultClause;
         ClauseListNode* m_list2;


@@ -1575,10 +1938,10 @@ namespace JSC {
 
     class SwitchNode : public StatementNode {
     public:
 
     class SwitchNode : public StatementNode {
     public:

-        SwitchNode(JSGlobalData*, ExpressionNode*, CaseBlockNode*);
+        SwitchNode(const JSTokenLocation&, ExpressionNode*, CaseBlockNode*);

 
     private:
 
     private:

-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;

 
         ExpressionNode* m_expr;
         CaseBlockNode* m_block;
 
         ExpressionNode* m_expr;
         CaseBlockNode* m_block;