webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 234 insertions, 680 deletions

diff --git a/Source/JavaScriptCore/parser/Nodes.h b/Source/JavaScriptCore/parser/Nodes.h
index 53519db6d..d779a178d 100644
--- a/Source/JavaScriptCore/parser/Nodes.h
+++ b/Source/JavaScriptCore/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) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013, 2015 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 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>
@@ -34,22 +34,19 @@
 #include "ResultType.h"
 #include "SourceCode.h"
 #include "SymbolTable.h"
-#include "VariableEnvironment.h"
 #include <wtf/MathExtras.h>
 
 namespace JSC {
 
     class ArgumentListNode;
     class BytecodeGenerator;
-    class FunctionMetadataNode;
-    class FunctionParameters;
+    class FunctionBodyNode;
     class Label;
     class PropertyListNode;
     class ReadModifyResolveNode;
     class RegisterID;
     class JSScope;
     class ScopeNode;
-    class ModuleAnalyzer;
 
     enum Operator {
         OpEqual,
@@ -79,8 +76,12 @@ namespace JSC {
     };
     inline FallThroughMode invert(FallThroughMode fallThroughMode) { return static_cast<FallThroughMode>(!fallThroughMode); }
 
+    typedef HashSet<RefPtr<StringImpl>, IdentifierRepHash> IdentifierSet;
+
     namespace DeclarationStacks {
-        typedef Vector<FunctionMetadataNode*> FunctionStack;
+        enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
+        typedef Vector<std::pair<Identifier, unsigned>> VarStack;
+        typedef Vector<FunctionBodyNode*> FunctionStack;
     }
 
     struct SwitchInfo {
@@ -89,17 +90,11 @@ namespace JSC {
         SwitchType switchType;
     };
 
-    enum class AssignmentContext { 
-        DeclarationStatement, 
-        ConstDeclarationStatement, 
-        AssignmentExpression 
-    };
-
     class ParserArenaFreeable {
     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, ParserArena&);
+        void* operator new(size_t, VM*);
     };
 
     class ParserArenaDeletable {
@@ -108,20 +103,24 @@ namespace JSC {
 
         // ParserArenaDeletable objects are deleted when the arena is deleted.
         // Clients must not call delete directly on such objects.
-        void* operator new(size_t, ParserArena&);
+        void* operator new(size_t, VM*);
     };
 
-    class ParserArenaRoot {
-        WTF_MAKE_FAST_ALLOCATED;
+    template <typename T>
+    struct ParserArenaData : ParserArenaDeletable {
+        T data;
+    };
+
+    class ParserArenaRefCounted : public RefCounted<ParserArenaRefCounted> {
+        WTF_FASTMALLOC_OPERATORS;
     protected:
-        ParserArenaRoot(ParserArena&);
+        ParserArenaRefCounted(VM*);
 
     public:
-        ParserArena& parserArena() { return m_arena; }
-        virtual ~ParserArenaRoot() { }
-
-    protected:
-        ParserArena m_arena;
+        virtual ~ParserArenaRefCounted()
+        {
+            ASSERT(deletionHasBegun());
+        }
     };
 
     class Node : public ParserArenaFreeable {
@@ -131,17 +130,13 @@ namespace JSC {
     public:
         virtual ~Node() { }
 
-        int firstLine() const { return m_position.line; }
+        int lineNo() 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:
         JSTextPosition m_position;
-        int m_endOffset;
     };
 
     class ExpressionNode : public Node {
@@ -153,27 +148,21 @@ namespace JSC {
 
         virtual bool isNumber() const { return false; }
         virtual bool isString() const { return false; }
-        virtual bool isObjectLiteral() const { return false; }
-        virtual bool isArrayLiteral() 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 isAssignmentLocation() const { return isLocation(); }
         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 isDeconstructionNode() const { return false; }
         virtual bool isFuncExprNode() const { return false; }
-        virtual bool isArrowFuncExprNode() 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 isBoolean() const { return false; }
         virtual bool isSpreadExpression() const { return false; }
-        virtual bool isSuperNode() const { return false; }
-        virtual bool isBytecodeIntrinsicNode() const { return false; }
 
         virtual void emitBytecodeInConditionContext(BytecodeGenerator&, Label*, Label*, FallThroughMode);
 
@@ -193,39 +182,20 @@ namespace JSC {
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* destination = 0) = 0;
 
         void setLoc(unsigned firstLine, unsigned lastLine, int startOffset, int lineStartOffset);
+        unsigned firstLine() const { return lineNo(); }
         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 isBreak() const { return false; }
         virtual bool isContinue() const { return false; }
         virtual bool isBlock() const { return false; }
-        virtual bool isFuncDeclNode() const { return false; }
-        virtual bool isModuleDeclarationNode() const { return false; }
 
     protected:
-        StatementNode* m_next;
         int m_lastLine;
     };
 
-    class VariableEnvironmentNode : public ParserArenaDeletable {
-    public:
-        VariableEnvironmentNode()
-        {
-        }
-
-        VariableEnvironmentNode(VariableEnvironment& lexicalDeclaredVariables);
-
-        VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }
-
-    protected:
-        VariableEnvironment m_lexicalVariables;
-    };
-
     class ConstantNode : public ExpressionNode {
     public:
         ConstantNode(const JSTokenLocation&, ResultType);
@@ -261,32 +231,16 @@ namespace JSC {
     class NumberNode : public ConstantNode {
     public:
         NumberNode(const JSTokenLocation&, double value);
-        double value() const { return m_value; }
-        virtual bool isIntegerNode() const = 0;
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override final;
+        double value() { return m_value; }
+        void setValue(double value) { m_value = value; }
 
     private:
-        virtual bool isNumber() const override final { return true; }
+        virtual bool isNumber() const override { return true; }
         virtual JSValue jsValue(BytecodeGenerator&) const override { return jsNumber(m_value); }
 
         double m_value;
     };
 
-    class DoubleNode : public NumberNode {
-    public:
-        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&);
@@ -298,7 +252,7 @@ namespace JSC {
 
         const Identifier& m_value;
     };
-
+    
     class ThrowableExpressionData {
     public:
         ThrowableExpressionData()
@@ -451,74 +405,6 @@ namespace JSC {
         uint16_t m_subexpressionLineStartOffset;
     };
 
-    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;
-    };
-
     class RegExpNode : public ExpressionNode, public ThrowableExpressionData {
     public:
         RegExpNode(const JSTokenLocation&, const Identifier& pattern, const Identifier& flags);
@@ -532,26 +418,7 @@ namespace JSC {
 
     class ThisNode : public ExpressionNode {
     public:
-        ThisNode(const JSTokenLocation&, ThisTDZMode);
-
-    private:
-        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 NewTargetNode final : public ExpressionNode {
-    public:
-        NewTargetNode(const JSTokenLocation&);
+        ThisNode(const JSTokenLocation&);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -595,9 +462,7 @@ namespace JSC {
         ArrayNode(const JSTokenLocation&, ElementNode*);
         ArrayNode(const JSTokenLocation&, int elision, ElementNode*);
 
-        virtual bool isArrayLiteral() const override { return true; }
-
-        ArgumentListNode* toArgumentList(ParserArena&, int, int) const;
+        ArgumentListNode* toArgumentList(VM*, int, int) const;
 
         ElementNode* elements() const { ASSERT(isSimpleArray()); return m_element; }
     private:
@@ -612,27 +477,23 @@ namespace JSC {
 
     class PropertyNode : public ParserArenaFreeable {
     public:
-        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, SuperBinding);
+        enum Type { Constant = 1, Getter = 2, Setter = 4 };
 
+        PropertyNode(VM*, const Identifier&, ExpressionNode*, Type);
+        PropertyNode(VM*, double, ExpressionNode*, Type);
+        PropertyNode(VM*, ExpressionNode* propertyName, ExpressionNode*, Type);
+        
         ExpressionNode* expressionName() const { return m_expression; }
         const Identifier* name() const { return m_name; }
 
-        Type type() const { return static_cast<Type>(m_type); }
-        bool needsSuperBinding() const { return m_needsSuperBinding; }
-        PutType putType() const { return static_cast<PutType>(m_putType); }
+        Type type() const { return m_type; }
 
     private:
         friend class PropertyListNode;
         const Identifier* m_name;
         ExpressionNode* m_expression;
         ExpressionNode* m_assign;
-        unsigned m_type : 5;
-        unsigned m_needsSuperBinding : 1;
-        unsigned m_putType : 1;
+        Type m_type;
     };
 
     class PropertyListNode : public ExpressionNode {
@@ -640,10 +501,9 @@ namespace JSC {
         PropertyListNode(const JSTokenLocation&, PropertyNode*);
         PropertyListNode(const JSTokenLocation&, PropertyNode*, PropertyListNode*);
 
-    private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        void emitPutConstantProperty(BytecodeGenerator&, RegisterID*, PropertyNode&);
 
+    private:
         PropertyNode* m_node;
         PropertyListNode* m_next;
     };
@@ -652,7 +512,6 @@ namespace JSC {
     public:
         ObjectLiteralNode(const JSTokenLocation&);
         ObjectLiteralNode(const JSTokenLocation&, PropertyListNode*);
-        virtual bool isObjectLiteral() const override { return true; }
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -776,7 +635,7 @@ namespace JSC {
     
     class FunctionCallBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
     public:
-        FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, bool subscriptHasAssignments, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
+        FunctionCallBracketNode(const JSTokenLocation&, ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -784,7 +643,6 @@ namespace JSC {
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ArgumentsNode* m_args;
-        bool m_subscriptHasAssignments;
     };
 
     class FunctionCallDotNode : public ExpressionNode, public ThrowableSubExpressionData {
@@ -800,37 +658,6 @@ namespace JSC {
         ArgumentsNode* m_args;
     };
 
-    class BytecodeIntrinsicNode : public ExpressionNode, public ThrowableExpressionData {
-    public:
-        enum class Type {
-            Constant,
-            Function
-        };
-
-        typedef RegisterID* (BytecodeIntrinsicNode::* EmitterType)(BytecodeGenerator&, RegisterID*);
-
-        BytecodeIntrinsicNode(Type, const JSTokenLocation&, EmitterType, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
-
-        virtual bool isBytecodeIntrinsicNode() const override { return true; }
-
-        Type type() const { return m_type; }
-        EmitterType emitter() const { return m_emitter; }
-        const Identifier& identifier() const { return m_ident; }
-
-#define JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS(name) RegisterID* emit_intrinsic_##name(BytecodeGenerator&, RegisterID*);
-        JSC_COMMON_BYTECODE_INTRINSIC_FUNCTIONS_EACH_NAME(JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS)
-        JSC_COMMON_BYTECODE_INTRINSIC_CONSTANTS_EACH_NAME(JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS)
-#undef JSC_DECLARE_BYTECODE_INTRINSIC_FUNCTIONS
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        Type m_type;
-        EmitterType m_emitter;
-        const Identifier& m_ident;
-        ArgumentsNode* m_args;
-    };
-
     class CallFunctionCallDotNode : public FunctionCallDotNode {
     public:
         CallFunctionCallDotNode(const JSTokenLocation&, ExpressionNode* base, const Identifier&, ArgumentsNode*, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
@@ -1193,14 +1020,13 @@ namespace JSC {
 
     class AssignResolveNode : public ExpressionNode, public ThrowableExpressionData {
     public:
-        AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right, AssignmentContext);
+        AssignResolveNode(const JSTokenLocation&, const Identifier&, ExpressionNode* right);
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
         const Identifier& m_ident;
         ExpressionNode* m_right;
-        AssignmentContext m_assignmentContext;
     };
 
     class ReadModifyBracketNode : public ExpressionNode, public ThrowableSubExpressionData {
@@ -1213,7 +1039,7 @@ namespace JSC {
         ExpressionNode* m_base;
         ExpressionNode* m_subscript;
         ExpressionNode* m_right;
-        unsigned m_operator : 30;
+        Operator m_operator : 30;
         bool m_subscriptHasAssignments : 1;
         bool m_rightHasAssignments : 1;
     };
@@ -1255,7 +1081,7 @@ namespace JSC {
         ExpressionNode* m_base;
         const Identifier& m_ident;
         ExpressionNode* m_right;
-        unsigned m_operator : 31;
+        Operator m_operator : 31;
         bool m_rightHasAssignments : 1;
     };
 
@@ -1267,22 +1093,54 @@ namespace JSC {
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
     };
     
-    class CommaNode final : public ExpressionNode {
+    typedef Vector<ExpressionNode*, 8> ExpressionVector;
+
+    class CommaNode : public ExpressionNode, public ParserArenaDeletable {
     public:
-        CommaNode(const JSTokenLocation&, ExpressionNode*);
+        CommaNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2);
+
+        using ParserArenaDeletable::operator new;
 
-        void setNext(CommaNode* next) { m_next = next; }
-        CommaNode* next() { return m_next; }
+        void append(ExpressionNode* expr) { ASSERT(expr); m_expressions.append(expr); }
 
     private:
         virtual bool isCommaNode() const override { return true; }
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
-        ExpressionNode* m_expr;
-        CommaNode* m_next;
+        ExpressionVector m_expressions;
     };
     
-    class SourceElements final : public ParserArenaFreeable {
+    class ConstDeclNode : public ExpressionNode {
+    public:
+        ConstDeclNode(const JSTokenLocation&, const Identifier&, ExpressionNode*);
+
+        bool hasInitializer() const { return m_init; }
+        const Identifier& ident() { return m_ident; }
+
+    private:
+        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+        virtual RegisterID* emitCodeSingle(BytecodeGenerator&);
+
+        const Identifier& m_ident;
+
+    public:
+        ConstDeclNode* m_next;
+
+    private:
+        ExpressionNode* m_init;
+    };
+
+    class ConstStatementNode : public StatementNode {
+    public:
+        ConstStatementNode(const JSTokenLocation&, ConstDeclNode* next);
+
+    private:
+        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
+        ConstDeclNode* m_next;
+    };
+
+    class SourceElements : public ParserArenaDeletable {
     public:
         SourceElements();
 
@@ -1292,18 +1150,14 @@ namespace JSC {
         StatementNode* lastStatement() const;
 
         void emitBytecode(BytecodeGenerator&, RegisterID* destination);
-        void analyzeModule(ModuleAnalyzer&);
 
     private:
-        StatementNode* m_head;
-        StatementNode* m_tail;
+        Vector<StatementNode*> m_statements;
     };
 
-    class BlockNode : public StatementNode, public VariableEnvironmentNode {
+    class BlockNode : public StatementNode {
     public:
-        using ParserArenaDeletable::operator new;
-
-        BlockNode(const JSTokenLocation&, SourceElements*, VariableEnvironment&);
+        BlockNode(const JSTokenLocation&, SourceElements* = 0);
 
         StatementNode* singleStatement() const;
         StatementNode* lastStatement() const;
@@ -1348,35 +1202,15 @@ namespace JSC {
         ExpressionNode* m_expr;
     };
 
-    class DeclarationStatement : public StatementNode {
+    class VarStatementNode : public StatementNode {
     public:
-        DeclarationStatement(const JSTokenLocation&, ExpressionNode*);
+        VarStatementNode(const JSTokenLocation&, ExpressionNode*);
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
         ExpressionNode* m_expr;
     };
 
-    class EmptyVarExpression : public ExpressionNode {
-    public:
-        EmptyVarExpression(const JSTokenLocation&, const Identifier&);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        const Identifier& m_ident;
-    };
-
-    class EmptyLetExpression : public ExpressionNode {
-    public:
-        EmptyLetExpression(const JSTokenLocation&, const Identifier&);
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        const Identifier& m_ident;
-    };
-
     class IfElseNode : public StatementNode {
     public:
         IfElseNode(const JSTokenLocation&, ExpressionNode* condition, StatementNode* ifBlock, StatementNode* elseBlock);
@@ -1413,11 +1247,9 @@ namespace JSC {
         StatementNode* m_statement;
     };
 
-    class ForNode : public StatementNode, public VariableEnvironmentNode {
+    class ForNode : public StatementNode {
     public:
-        using ParserArenaDeletable::operator new;
-
-        ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*, VariableEnvironment&);
+        ForNode(const JSTokenLocation&, ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode*);
 
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -1428,13 +1260,12 @@ namespace JSC {
         StatementNode* m_statement;
     };
     
-    class DestructuringPatternNode;
+    class DeconstructionPatternNode;
     
-    class EnumerationNode : public StatementNode, public ThrowableExpressionData, public VariableEnvironmentNode {
+    class EnumerationNode : public StatementNode, public ThrowableExpressionData {
     public:
-        using ParserArenaDeletable::operator new;
-
-        EnumerationNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*, VariableEnvironment&);
+        EnumerationNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+        EnumerationNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, ExpressionNode*, StatementNode*);
         
     protected:
         ExpressionNode* m_lexpr;
@@ -1444,19 +1275,17 @@ namespace JSC {
     
     class ForInNode : public EnumerationNode {
     public:
-        ForInNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*, VariableEnvironment&);
+        ForInNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+        ForInNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, 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*, VariableEnvironment&);
+        ForOfNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*, StatementNode*);
+        ForOfNode(VM*, const JSTokenLocation&, DeconstructionPatternNode*, ExpressionNode*, StatementNode*);
         
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -1464,6 +1293,7 @@ namespace JSC {
 
     class ContinueNode : public StatementNode, public ThrowableExpressionData {
     public:
+        ContinueNode(VM*, const JSTokenLocation&);
         ContinueNode(const JSTokenLocation&, const Identifier&);
         Label* trivialTarget(BytecodeGenerator&);
         
@@ -1476,6 +1306,7 @@ namespace JSC {
 
     class BreakNode : public StatementNode, public ThrowableExpressionData {
     public:
+        BreakNode(VM*, const JSTokenLocation&);
         BreakNode(const JSTokenLocation&, const Identifier&);
         Label* trivialTarget(BytecodeGenerator&);
         
@@ -1534,29 +1365,50 @@ namespace JSC {
         ExpressionNode* m_expr;
     };
 
-    class TryNode : public StatementNode, public VariableEnvironmentNode {
+    class TryNode : public StatementNode {
     public:
-        using ParserArenaDeletable::operator new;
-
-        TryNode(const JSTokenLocation&, StatementNode* tryBlock, DestructuringPatternNode* catchPattern, StatementNode* catchBlock, VariableEnvironment& catchEnvironment, StatementNode* finallyBlock);
+        TryNode(const JSTokenLocation&, StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock);
 
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
         StatementNode* m_tryBlock;
-        DestructuringPatternNode* m_catchPattern;
+        const Identifier& m_exceptionIdent;
         StatementNode* m_catchBlock;
         StatementNode* m_finallyBlock;
     };
 
-    class ScopeNode : public StatementNode, public ParserArenaRoot, public VariableEnvironmentNode {
+    class ParameterNode : public ParserArenaDeletable {
+    public:
+        ParameterNode(PassRefPtr<DeconstructionPatternNode>);
+        ParameterNode(ParameterNode*, PassRefPtr<DeconstructionPatternNode>);
+
+        DeconstructionPatternNode* pattern() const { return m_pattern.get(); }
+        ParameterNode* nextParam() const { return m_next; }
+
+    private:
+        RefPtr<DeconstructionPatternNode> m_pattern;
+        ParameterNode* m_next;
+    };
+
+    class ScopeNode : public StatementNode, public ParserArenaRefCounted {
     public:
+        typedef DeclarationStacks::VarStack VarStack;
         typedef DeclarationStacks::FunctionStack FunctionStack;
 
-        ScopeNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, bool inStrictContext);
-        ScopeNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, const SourceCode&, SourceElements*, VariableEnvironment&, FunctionStack&, VariableEnvironment&, CodeFeatures, int numConstants);
+        ScopeNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, bool inStrictContext);
+        ScopeNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
+
+        using ParserArenaRefCounted::operator new;
 
-        using ParserArenaRoot::operator new;
+        void destroyData()
+        {
+            m_arena.reset();
+            m_varStack.clear();
+            m_functionStack.clear();
+            m_statements = 0;
+            m_capturedVariables.clear();
+        }
 
         const SourceCode& source() const { return m_source; }
         const String& sourceURL() const { return m_source.provider()->url(); }
@@ -1571,18 +1423,17 @@ namespace JSC {
 
         bool usesEval() const { return m_features & EvalFeature; }
         bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }
-        bool usesArrowFunction() const { return m_features & ArrowFunctionFeature; }
         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 needsActivation() const { return (hasCapturedVariables()) || (m_features & (EvalFeature | WithFeature)); }
-        bool hasCapturedVariables() const { return m_varDeclarations.hasCapturedVariables(); }
-        bool captures(UniquedStringImpl* uid) { return m_varDeclarations.captures(uid); }
-        bool captures(const Identifier& ident) { return captures(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(); }
+        bool captures(const Identifier& ident) { return m_capturedVariables.contains(ident.impl()); }
 
-        VariableEnvironment& varDeclarations() { return m_varDeclarations; }
+        VarStack& varStack() { return m_varStack; }
         FunctionStack& functionStack() { return m_functionStack; }
 
         int neededConstants()
@@ -1595,10 +1446,11 @@ namespace JSC {
         StatementNode* singleStatement() const;
 
         void emitStatementsBytecode(BytecodeGenerator&, RegisterID* destination);
-        
-        void analyzeModule(ModuleAnalyzer&);
 
     protected:
+        void setSource(const SourceCode& source) { m_source = source; }
+        ParserArena m_arena;
+
         int m_startLineNumber;
         unsigned m_startStartOffset;
         unsigned m_startLineStartOffset;
@@ -1606,15 +1458,17 @@ namespace JSC {
     private:
         CodeFeatures m_features;
         SourceCode m_source;
-        VariableEnvironment m_varDeclarations;
+        VarStack m_varStack;
         FunctionStack m_functionStack;
         int m_numConstants;
         SourceElements* m_statements;
+        IdentifierSet m_capturedVariables;
     };
 
     class ProgramNode : public ScopeNode {
     public:
-        ProgramNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VariableEnvironment&, FunctionStack&, VariableEnvironment&, FunctionParameters*, const SourceCode&, CodeFeatures, int numConstants);
+        static const bool isFunctionNode = false;
+        static PassRefPtr<ProgramNode> create(VM*, 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; }
@@ -1622,14 +1476,18 @@ namespace JSC {
         static const bool scopeIsFunction = false;
 
     private:
+        ProgramNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
+
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
+
         unsigned m_startColumn;
         unsigned m_endColumn;
     };
 
     class EvalNode : public ScopeNode {
     public:
-        EvalNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VariableEnvironment&, FunctionStack&, VariableEnvironment&, FunctionParameters*, const SourceCode&, CodeFeatures, int numConstants);
+        static const bool isFunctionNode = false;
+        static PassRefPtr<EvalNode> create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned, unsigned endColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         ALWAYS_INLINE unsigned startColumn() const { return 0; }
         unsigned endColumn() const { return m_endColumn; }
@@ -1637,424 +1495,163 @@ namespace JSC {
         static const bool scopeIsFunction = false;
 
     private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        unsigned m_endColumn;
-    };
-
-    class ModuleProgramNode : public ScopeNode {
-    public:
-        ModuleProgramNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VariableEnvironment&, FunctionStack&, VariableEnvironment&, FunctionParameters*, const SourceCode&, CodeFeatures, int numConstants);
+        EvalNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, 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;
-
-    private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        unsigned m_startColumn;
-        unsigned m_endColumn;
-    };
-
-    class ModuleNameNode : public Node {
-    public:
-        ModuleNameNode(const JSTokenLocation&, const Identifier& moduleName);
 
-        const Identifier& moduleName() { return m_moduleName; }
-
-    private:
-        const Identifier& m_moduleName;
-    };
-
-    class ImportSpecifierNode : public Node {
-    public:
-        ImportSpecifierNode(const JSTokenLocation&, const Identifier& importedName, const Identifier& localName);
-
-        const Identifier& importedName() { return m_importedName; }
-        const Identifier& localName() { return m_localName; }
-
-    private:
-        const Identifier& m_importedName;
-        const Identifier& m_localName;
-    };
-
-    class ImportSpecifierListNode : public ParserArenaDeletable {
-    public:
-        typedef Vector<ImportSpecifierNode*, 3> Specifiers;
-
-        const Specifiers& specifiers() const { return m_specifiers; }
-        void append(ImportSpecifierNode* specifier)
-        {
-            m_specifiers.append(specifier);
-        }
-
-    private:
-        Specifiers m_specifiers;
-    };
-
-    class ModuleDeclarationNode : public StatementNode {
-    public:
-        virtual void analyzeModule(ModuleAnalyzer&) = 0;
-        virtual bool isModuleDeclarationNode() const { return true; }
-
-    protected:
-        ModuleDeclarationNode(const JSTokenLocation&);
-    };
-
-    class ImportDeclarationNode : public ModuleDeclarationNode {
-    public:
-        ImportDeclarationNode(const JSTokenLocation&, ImportSpecifierListNode*, ModuleNameNode*);
-
-        ImportSpecifierListNode* specifierList() const { return m_specifierList; }
-        ModuleNameNode* moduleName() const { return m_moduleName; }
-
-    private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        virtual void analyzeModule(ModuleAnalyzer&) override;
-
-        ImportSpecifierListNode* m_specifierList;
-        ModuleNameNode* m_moduleName;
-    };
-
-    class ExportAllDeclarationNode : public ModuleDeclarationNode {
-    public:
-        ExportAllDeclarationNode(const JSTokenLocation&, ModuleNameNode*);
-
-        ModuleNameNode* moduleName() const { return m_moduleName; }
-
-    private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        virtual void analyzeModule(ModuleAnalyzer&) override;
-
-        ModuleNameNode* m_moduleName;
-    };
-
-    class ExportDefaultDeclarationNode : public ModuleDeclarationNode {
-    public:
-        ExportDefaultDeclarationNode(const JSTokenLocation&, StatementNode*, const Identifier& localName);
-
-        const StatementNode& declaration() const { return *m_declaration; }
-        const Identifier& localName() const { return m_localName; }
-
-    private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        virtual void analyzeModule(ModuleAnalyzer&) override;
-        StatementNode* m_declaration;
-        const Identifier& m_localName;
-    };
-
-    class ExportLocalDeclarationNode : public ModuleDeclarationNode {
-    public:
-        ExportLocalDeclarationNode(const JSTokenLocation&, StatementNode*);
-
-        const StatementNode& declaration() const { return *m_declaration; }
-
-    private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        virtual void analyzeModule(ModuleAnalyzer&) override;
-        StatementNode* m_declaration;
+        unsigned m_endColumn;
     };
 
-    class ExportSpecifierNode : public Node {
+    class FunctionParameters : public RefCounted<FunctionParameters> {
+        WTF_MAKE_FAST_ALLOCATED;
+        WTF_MAKE_NONCOPYABLE(FunctionParameters);
     public:
-        ExportSpecifierNode(const JSTokenLocation&, const Identifier& localName, const Identifier& exportedName);
+        static PassRefPtr<FunctionParameters> create(ParameterNode*);
+        ~FunctionParameters();
 
-        const Identifier& exportedName() { return m_exportedName; }
-        const Identifier& localName() { return m_localName; }
+        unsigned size() const { return m_size; }
+        DeconstructionPatternNode* at(unsigned index) { ASSERT(index < m_size); return patterns()[index]; }
 
     private:
-        const Identifier& m_localName;
-        const Identifier& m_exportedName;
-    };
-
-    class ExportSpecifierListNode : public ParserArenaDeletable {
-    public:
-        typedef Vector<ExportSpecifierNode*, 3> Specifiers;
+        FunctionParameters(ParameterNode*, unsigned size);
 
-        const Specifiers& specifiers() const { return m_specifiers; }
-        void append(ExportSpecifierNode* specifier)
-        {
-            m_specifiers.append(specifier);
-        }
+        DeconstructionPatternNode** patterns() { return &m_storage; }
 
-    private:
-        Specifiers m_specifiers;
+        unsigned m_size;
+        DeconstructionPatternNode* m_storage;
     };
 
-    class ExportNamedDeclarationNode : public ModuleDeclarationNode {
+    class FunctionBodyNode : public ScopeNode {
     public:
-        ExportNamedDeclarationNode(const JSTokenLocation&, ExportSpecifierListNode*, ModuleNameNode*);
+        static const bool isFunctionNode = true;
+        static FunctionBodyNode* create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, bool isStrictMode);
+        static PassRefPtr<FunctionBodyNode> create(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
-        ExportSpecifierListNode* specifierList() const { return m_specifierList; }
-        ModuleNameNode* moduleName() const { return m_moduleName; }
+        FunctionParameters* parameters() const { return m_parameters.get(); }
+        size_t parameterCount() const { return m_parameters->size(); }
 
-    private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-        virtual void analyzeModule(ModuleAnalyzer&) override;
-        ExportSpecifierListNode* m_specifierList;
-        ModuleNameNode* m_moduleName { nullptr };
-    };
-
-    class FunctionParameters : public ParserArenaDeletable {
-    public:
-        FunctionParameters();
-        ALWAYS_INLINE unsigned size() const { return m_patterns.size(); }
-        ALWAYS_INLINE std::pair<DestructuringPatternNode*, ExpressionNode*> at(unsigned index) { return m_patterns[index]; }
-        bool hasDefaultParameterValues() const { return m_hasDefaultParameterValues; }
-        ALWAYS_INLINE void append(DestructuringPatternNode* pattern, ExpressionNode* defaultValue) 
-        { 
-            ASSERT(pattern); 
-            m_patterns.append(std::make_pair(pattern, defaultValue));
-            if (defaultValue)
-                m_hasDefaultParameterValues = true;
-        }
-
-    private:
-
-        Vector<std::pair<DestructuringPatternNode*, ExpressionNode*>, 3> m_patterns;
-        bool m_hasDefaultParameterValues { false };
-    };
-
-    class FunctionMetadataNode final : public Node, public ParserArenaDeletable {
-    public:
-        using ParserArenaDeletable::operator new;
 
-        FunctionMetadataNode(
-            ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, 
-            unsigned startColumn, unsigned endColumn, int functionKeywordStart, 
-            int functionNameStart, int parametersStart, bool isInStrictContext, 
-            ConstructorKind, SuperBinding, unsigned, SourceParseMode, bool isArrowFunctionBodyExpression);
-
-        void finishParsing(const SourceCode&, const Identifier&, FunctionMode);
+        void finishParsing(const SourceCode&, ParameterNode*, const Identifier&, FunctionNameIsInScopeToggle);
+        void finishParsing(PassRefPtr<FunctionParameters>, const Identifier&, FunctionNameIsInScopeToggle);
         
-        void overrideName(const Identifier& ident) { m_ident = 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; }
+        bool functionNameIsInScope() { return m_functionNameIsInScopeToggle == FunctionNameIsInScope; }
+        FunctionNameIsInScopeToggle functionNameIsInScopeToggle() { return m_functionNameIsInScopeToggle; }
 
+        void setFunctionNameStart(int functionNameStart) { m_functionNameStart = functionNameStart; }
         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; }
-        unsigned parameterCount() const { return m_parameterCount; }
-        SourceParseMode parseMode() const { return m_parseMode; }
 
         void setEndPosition(JSTextPosition);
 
-        const SourceCode& source() const { return m_source; }
-
-        int startStartOffset() const { return m_startStartOffset; }
-        bool isInStrictContext() const { return m_isInStrictContext; }
-        SuperBinding superBinding() { return static_cast<SuperBinding>(m_superBinding); }
-        ConstructorKind constructorKind() { return static_cast<ConstructorKind>(m_constructorKind); }
-        bool isArrowFunctionBodyExpression() const { return m_isArrowFunctionBodyExpression; }
+        static const bool scopeIsFunction = true;
 
-        void setLoc(unsigned firstLine, unsigned lastLine, int startOffset, int lineStartOffset)
-        {
-            m_lastLine = lastLine;
-            m_position = JSTextPosition(firstLine, startOffset, lineStartOffset);
-            ASSERT(m_position.offset >= m_position.lineStartOffset);
-        }
-        unsigned lastLine() const { return m_lastLine; }
+    private:
+        FunctionBodyNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, bool inStrictContext);
+        FunctionBodyNode(VM*, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
-    protected:
         Identifier m_ident;
         Identifier m_inferredName;
-        FunctionMode m_functionMode;
-        unsigned m_startColumn;
-        unsigned m_endColumn;
-        int m_functionKeywordStart;
+        FunctionNameIsInScopeToggle m_functionNameIsInScopeToggle;
+        RefPtr<FunctionParameters> m_parameters;
         int m_functionNameStart;
-        int m_parametersStart;
-        SourceCode m_source;
-        int m_startStartOffset;
-        unsigned m_parameterCount;
-        int m_lastLine;
-        SourceParseMode m_parseMode;
-        unsigned m_isInStrictContext : 1;
-        unsigned m_superBinding : 1;
-        unsigned m_constructorKind : 2;
-        unsigned m_isArrowFunctionBodyExpression : 1;
-    };
-
-    class FunctionNode final : public ScopeNode {
-    public:
-        FunctionNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, SourceElements*, VariableEnvironment&, FunctionStack&, VariableEnvironment&, FunctionParameters*, const SourceCode&, CodeFeatures, int numConstants);
-
-        FunctionParameters* parameters() const { return m_parameters; }
-
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        void finishParsing(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:
-        Identifier m_ident;
-        FunctionMode m_functionMode;
-        FunctionParameters* m_parameters;
         unsigned m_startColumn;
         unsigned m_endColumn;
     };
 
-    class BaseFuncExprNode : public ExpressionNode {
+    class FuncExprNode : public ExpressionNode {
     public:
-        BaseFuncExprNode(const JSTokenLocation&, const Identifier&, FunctionMetadataNode*, const SourceCode&);
-
-        FunctionMetadataNode* metadata() { return m_metadata; }
-
-    protected:
-        FunctionMetadataNode* m_metadata;
-    };
-
+        FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
 
-    class FuncExprNode : public BaseFuncExprNode {
-    public:
-        FuncExprNode(const JSTokenLocation&, const Identifier&, FunctionMetadataNode*, const SourceCode&);
+        FunctionBodyNode* body() { return m_body; }
 
     private:
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
         virtual bool isFuncExprNode() const override { return true; }
-    };
-
-    class ArrowFuncExprNode : public BaseFuncExprNode {
-    public:
-        ArrowFuncExprNode(const JSTokenLocation&, const Identifier&, FunctionMetadataNode*, const SourceCode&);
 
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        virtual bool isArrowFuncExprNode() const override { return true; }
-    };
-
-    class YieldExprNode final : public ExpressionNode, public ThrowableExpressionData {
-    public:
-        YieldExprNode(const JSTokenLocation&, ExpressionNode* argument, bool delegate);
-
-        ExpressionNode* argument() const { return m_argument; }
-        bool delegate() const { return m_delegate; }
-
-    private:
-        virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        ExpressionNode* m_argument;
-        bool m_delegate;
+        FunctionBodyNode* m_body;
     };
 
-    class ClassExprNode final : public ExpressionNode, public VariableEnvironmentNode {
-    public:
-        using ParserArenaDeletable::operator new;
-
-        ClassExprNode(const JSTokenLocation&, const Identifier&, VariableEnvironment& classEnvironment, 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;
-    };
+    class DeconstructionPatternNode : public RefCounted<DeconstructionPatternNode> {
+        WTF_MAKE_NONCOPYABLE(DeconstructionPatternNode);
+        WTF_MAKE_FAST_ALLOCATED;
 
-    class DestructuringPatternNode : public ParserArenaFreeable {
     public:
-        virtual ~DestructuringPatternNode() { }
         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 bool isRestParameter() const { return false; }
         virtual RegisterID* emitDirectBinding(BytecodeGenerator&, RegisterID*, ExpressionNode*) { return 0; }
         
+        virtual ~DeconstructionPatternNode() = 0;
+        
     protected:
-        DestructuringPatternNode();
+        DeconstructionPatternNode(VM*);
     };
 
-    class ArrayPatternNode : public DestructuringPatternNode, public ThrowableExpressionData, public ParserArenaDeletable {
+    class ArrayPatternNode : public DeconstructionPatternNode {
     public:
-        using ParserArenaDeletable::operator new;
-
-        ArrayPatternNode();
-        enum class BindingType {
-            Elision,
-            Element,
-            RestElement
-        };
-
-        void appendIndex(BindingType bindingType, const JSTokenLocation&, DestructuringPatternNode* node, ExpressionNode* defaultValue)
+        static PassRefPtr<ArrayPatternNode> create(VM*);
+        void appendIndex(const JSTokenLocation&, DeconstructionPatternNode* node)
         {
-            m_targetPatterns.append({ bindingType, node, defaultValue });
+            m_targetPatterns.append(node);
         }
 
     private:
-        struct Entry {
-            BindingType bindingType;
-            DestructuringPatternNode* pattern;
-            ExpressionNode* defaultValue;
-        };
+        ArrayPatternNode(VM*);
         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;
+        Vector<RefPtr<DeconstructionPatternNode>> m_targetPatterns;
     };
     
-    class ObjectPatternNode : public DestructuringPatternNode, public ParserArenaDeletable {
+    class ObjectPatternNode : public DeconstructionPatternNode {
     public:
-        using ParserArenaDeletable::operator new;
-        
-        ObjectPatternNode();
-        void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
-        {
-            m_targetPatterns.append(Entry{ identifier, nullptr, wasString, pattern, defaultValue });
-        }
-
-        void appendEntry(const JSTokenLocation&, ExpressionNode* propertyExpression, DestructuringPatternNode* pattern, ExpressionNode* defaultValue)
+        static PassRefPtr<ObjectPatternNode> create(VM*);
+        void appendEntry(const JSTokenLocation&, const Identifier& identifier, bool wasString, DeconstructionPatternNode* pattern)
         {
-            m_targetPatterns.append(Entry{ Identifier(), propertyExpression, false, pattern, defaultValue });
+            m_targetPatterns.append(Entry(identifier, wasString, pattern));
         }
-
+        
     private:
+        ObjectPatternNode(VM*);
         virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
         virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
         virtual void toString(StringBuilder&) const override;
         struct Entry {
-            const Identifier& propertyName;
-            ExpressionNode* propertyExpression;
+            Entry(const Identifier& propertyName, bool wasString, DeconstructionPatternNode* pattern)
+                : propertyName(propertyName)
+                , wasString(wasString)
+                , pattern(pattern)
+            {
+            }
+            Identifier propertyName;
             bool wasString;
-            DestructuringPatternNode* pattern;
-            ExpressionNode* defaultValue;
+            RefPtr<DeconstructionPatternNode> pattern;
         };
         Vector<Entry> m_targetPatterns;
     };
 
-    class BindingNode : public DestructuringPatternNode {
+    class BindingNode : public DeconstructionPatternNode {
     public:
-        BindingNode(const Identifier& boundProperty, const JSTextPosition& start, const JSTextPosition& end, AssignmentContext);
+        static PassRefPtr<BindingNode> create(VM*, 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(VM*, 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;
@@ -2063,84 +1660,35 @@ namespace JSC {
 
         JSTextPosition m_divotStart;
         JSTextPosition m_divotEnd;
-        const Identifier& m_boundProperty;
-        AssignmentContext m_bindingContext;
-    };
-
-    class RestParameterNode : public DestructuringPatternNode {
-    public:
-        RestParameterNode(const Identifier& boundProperty, unsigned numParametersToSkip, const JSTextPosition& start, const JSTextPosition& end);
-
-        bool isRestParameter() const override { return true; }
-
-        void emit(BytecodeGenerator&);
-
-        const Identifier& name() const { return m_name; }
-
-    private:
-        virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
-        virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
-        virtual void toString(StringBuilder&) const override;
-
-        const Identifier& m_name;
-        unsigned m_numParametersToSkip;
-        JSTextPosition m_divotStart; // "f" in "...foo"
-        JSTextPosition m_divotEnd;
+        Identifier m_boundProperty;
     };
 
-    class AssignmentElementNode : public DestructuringPatternNode {
+    class DeconstructingAssignmentNode : public ExpressionNode, public ParserArenaDeletable {
     public:
-        AssignmentElementNode(ExpressionNode* assignmentTarget, const JSTextPosition& start, const JSTextPosition& end);
-        const ExpressionNode* assignmentTarget() { return m_assignmentTarget; }
-
-        const JSTextPosition& divotStart() const { return m_divotStart; }
-        const JSTextPosition& divotEnd() const { return m_divotEnd; }
-
-    private:
-        virtual void collectBoundIdentifiers(Vector<Identifier>&) const override;
-        virtual void bindValue(BytecodeGenerator&, RegisterID*) const override;
-        virtual void toString(StringBuilder&) const override;
-
-        JSTextPosition m_divotStart;
-        JSTextPosition m_divotEnd;
-        ExpressionNode* m_assignmentTarget;
-    };
-
-    class DestructuringAssignmentNode : public ExpressionNode {
-    public:
-        DestructuringAssignmentNode(const JSTokenLocation&, DestructuringPatternNode*, ExpressionNode*);
-        DestructuringPatternNode* bindings() { return m_bindings; }
+        DeconstructingAssignmentNode(const JSTokenLocation&, PassRefPtr<DeconstructionPatternNode>, ExpressionNode*);
+        DeconstructionPatternNode* 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 bool isLocation() const override { return true; }
+        virtual bool isDeconstructionNode() const override { return true; }
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
-        DestructuringPatternNode* m_bindings;
+        RefPtr<DeconstructionPatternNode> m_bindings;
         ExpressionNode* m_initializer;
     };
 
     class FuncDeclNode : public StatementNode {
     public:
-        FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionMetadataNode*, const SourceCode&);
+        FuncDeclNode(const JSTokenLocation&, const Identifier&, FunctionBodyNode*, const SourceCode&, ParameterNode* = 0);
 
-        virtual bool isFuncDeclNode() const override { return true; }
-        FunctionMetadataNode* metadata() { return m_metadata; }
+        FunctionBodyNode* body() { return m_body; }
 
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
 
-        FunctionMetadataNode* m_metadata;
-    };
-
-    class ClassDeclNode final : public StatementNode {
-    public:
-        ClassDeclNode(const JSTokenLocation&, ExpressionNode* classExpression);
-
-    private:
-        virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
-
-        ExpressionNode* m_classDeclaration;
+        FunctionBodyNode* m_body;
     };
 
     class CaseClauseNode : public ParserArenaFreeable {
@@ -2150,12 +1698,10 @@ namespace JSC {
         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;
-        int m_startOffset;
     };
 
     class ClauseListNode : public ParserArenaFreeable {
@@ -2185,11 +1731,9 @@ namespace JSC {
         ClauseListNode* m_list2;
     };
 
-    class SwitchNode : public StatementNode, public VariableEnvironmentNode {
+    class SwitchNode : public StatementNode {
     public:
-        using ParserArenaDeletable::operator new;
-
-        SwitchNode(const JSTokenLocation&, ExpressionNode*, CaseBlockNode*, VariableEnvironment&);
+        SwitchNode(const JSTokenLocation&, ExpressionNode*, CaseBlockNode*);
 
     private:
         virtual void emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
@@ -2213,6 +1757,16 @@ namespace JSC {
         ArgumentListNode* tail;
     };
 
+    struct ConstDeclList {
+        ConstDeclNode* head;
+        ConstDeclNode* tail;
+    };
+
+    struct ParameterList {
+        ParameterNode* head;
+        ParameterNode* tail;
+    };
+
     struct ClauseList {
         ClauseListNode* head;
         ClauseListNode* tail;