webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 204 insertions, 805 deletions

diff --git a/Source/JavaScriptCore/parser/Parser.h b/Source/JavaScriptCore/parser/Parser.h
index 02a726a56..b698ef936 100644
--- a/Source/JavaScriptCore/parser/Parser.h
+++ b/Source/JavaScriptCore/parser/Parser.h
@@ -31,14 +31,13 @@
 #include "Nodes.h"
 #include "ParserArena.h"
 #include "ParserError.h"
-#include "ParserFunctionInfo.h"
 #include "ParserTokens.h"
 #include "SourceProvider.h"
 #include "SourceProviderCache.h"
 #include "SourceProviderCacheItem.h"
-#include "VariableEnvironment.h"
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
+#include <wtf/OwnPtr.h>
 #include <wtf/RefPtr.h>
 namespace JSC {
 struct Scope;
@@ -53,7 +52,7 @@ template <> struct VectorTraits<JSC::Scope> : SimpleClassVectorTraits {
 namespace JSC {
 
 class ExecState;
-class FunctionMetadataNode;
+class FunctionBodyNode;
 class FunctionParameters;
 class Identifier;
 class VM;
@@ -67,116 +66,67 @@ class SourceCode;
 #define TreeSourceElements typename TreeBuilder::SourceElements
 #define TreeClause typename TreeBuilder::Clause
 #define TreeClauseList typename TreeBuilder::ClauseList
+#define TreeConstDeclList typename TreeBuilder::ConstDeclList
 #define TreeArguments typename TreeBuilder::Arguments
 #define TreeArgumentsList typename TreeBuilder::ArgumentsList
 #define TreeFunctionBody typename TreeBuilder::FunctionBody
-#define TreeClassExpression typename TreeBuilder::ClassExpression
 #define TreeProperty typename TreeBuilder::Property
 #define TreePropertyList typename TreeBuilder::PropertyList
-#define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
+#define TreeDeconstructionPattern typename TreeBuilder::DeconstructionPattern
 
 COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
 
 enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
-enum FunctionBodyType { ArrowFunctionBodyExpression, ArrowFunctionBodyBlock, StandardFunctionBodyBlock };
 enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
-
-enum class DestructuringKind {
-    DestructureToVariables,
-    DestructureToLet,
-    DestructureToConst,
-    DestructureToCatchParameters,
-    DestructureToParameters,
-    DestructureToExpressions
-};
-
-enum class DeclarationType { 
-    VarDeclaration, 
-    LetDeclaration,
-    ConstDeclaration
-};
-
-enum class DeclarationImportType {
-    Imported,
-    ImportedNamespace,
-    NotImported
+enum FunctionParseMode { FunctionMode, GetterMode, SetterMode };
+enum DeconstructionKind {
+    DeconstructToVariables,
+    DeconstructToParameters,
+    DeconstructToExpressions
 };
 
-enum DeclarationResult {
-    Valid = 0,
-    InvalidStrictMode = 1 << 0,
-    InvalidDuplicateDeclaration = 1 << 1
-};
-
-typedef uint8_t DeclarationResultMask;
-
-
 template <typename T> inline bool isEvalNode() { return false; }
 template <> inline bool isEvalNode<EvalNode>() { return true; }
 
-struct ScopeLabelInfo {
-    UniquedStringImpl* uid;
-    bool isLoop;
-};
-
-ALWAYS_INLINE static bool isArguments(const VM* vm, const Identifier* ident)
-{
-    return vm->propertyNames->arguments == *ident;
-}
-ALWAYS_INLINE static bool isEval(const VM* vm, const Identifier* ident)
-{
-    return vm->propertyNames->eval == *ident;
-}
-ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM* vm, const Identifier* ident)
-{
-    return isEval(vm, ident) || isArguments(vm, ident);
-}
-ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)
-{
-    return token.m_type == IDENT || token.m_type & KeywordTokenFlag;
-}
-
-class ModuleScopeData : public RefCounted<ModuleScopeData> {
-public:
-    static Ref<ModuleScopeData> create() { return adoptRef(*new ModuleScopeData); }
-
-    const IdentifierSet& exportedBindings() const { return m_exportedBindings; }
-
-    bool exportName(const Identifier& exportedName)
+struct DepthManager {
+    DepthManager(int* depth)
+        : m_originalDepth(*depth)
+        , m_depth(depth)
     {
-        return m_exportedNames.add(exportedName.impl()).isNewEntry;
     }
 
-    void exportBinding(const Identifier& localName)
+    ~DepthManager()
     {
-        m_exportedBindings.add(localName.impl());
+        *m_depth = m_originalDepth;
     }
 
 private:
-    IdentifierSet m_exportedNames { };
-    IdentifierSet m_exportedBindings { };
+    int m_originalDepth;
+    int* m_depth;
+};
+
+struct ScopeLabelInfo {
+    ScopeLabelInfo(StringImpl* ident, bool isLoop)
+        : m_ident(ident)
+        , m_isLoop(isLoop)
+    {
+    }
+
+    StringImpl* m_ident;
+    bool m_isLoop;
 };
 
 struct Scope {
-    Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode)
+    Scope(const VM* vm, bool isFunction, bool strictMode)
         : m_vm(vm)
         , m_shadowsArguments(false)
         , m_usesEval(false)
         , m_needsFullActivation(false)
-        , m_hasDirectSuper(false)
-        , m_needsSuperBinding(false)
-        , m_allowsVarDeclarations(true)
-        , m_allowsLexicalDeclarations(true)
+        , m_allowsNewDecls(true)
         , m_strictMode(strictMode)
         , m_isFunction(isFunction)
-        , m_isGenerator(isGenerator)
-        , m_isArrowFunction(false)
-        , m_isLexicalScope(false)
         , m_isFunctionBoundary(false)
         , m_isValidStrictMode(true)
-        , m_hasArguments(false)
-        , m_constructorKind(static_cast<unsigned>(ConstructorKind::None))
-        , m_expectedSuperBinding(static_cast<unsigned>(SuperBinding::NotNeeded))
         , m_loopDepth(0)
         , m_switchDepth(0)
     {
@@ -187,31 +137,21 @@ struct Scope {
         , m_shadowsArguments(rhs.m_shadowsArguments)
         , m_usesEval(rhs.m_usesEval)
         , m_needsFullActivation(rhs.m_needsFullActivation)
-        , m_hasDirectSuper(rhs.m_hasDirectSuper)
-        , m_needsSuperBinding(rhs.m_needsSuperBinding)
-        , m_allowsVarDeclarations(rhs.m_allowsVarDeclarations)
-        , m_allowsLexicalDeclarations(rhs.m_allowsLexicalDeclarations)
+        , m_allowsNewDecls(rhs.m_allowsNewDecls)
         , m_strictMode(rhs.m_strictMode)
         , m_isFunction(rhs.m_isFunction)
-        , m_isGenerator(rhs.m_isGenerator)
-        , m_isArrowFunction(rhs.m_isArrowFunction)
-        , m_isLexicalScope(rhs.m_isLexicalScope)
         , m_isFunctionBoundary(rhs.m_isFunctionBoundary)
         , m_isValidStrictMode(rhs.m_isValidStrictMode)
-        , m_hasArguments(rhs.m_hasArguments)
-        , m_constructorKind(rhs.m_constructorKind)
-        , m_expectedSuperBinding(rhs.m_expectedSuperBinding)
         , m_loopDepth(rhs.m_loopDepth)
         , m_switchDepth(rhs.m_switchDepth)
-        , m_moduleScopeData(rhs.m_moduleScopeData)
     {
         if (rhs.m_labels) {
-            m_labels = std::make_unique<LabelStack>();
+            m_labels = adoptPtr(new LabelStack);
 
             typedef LabelStack::const_iterator iterator;
             iterator end = rhs.m_labels->end();
             for (iterator it = rhs.m_labels->begin(); it != end; ++it)
-                m_labels->append(ScopeLabelInfo { it->uid, it->isLoop });
+                m_labels->append(ScopeLabelInfo(it->m_ident, it->m_isLoop));
         }
     }
 
@@ -226,8 +166,8 @@ struct Scope {
     void pushLabel(const Identifier* label, bool isLoop)
     {
         if (!m_labels)
-            m_labels = std::make_unique<LabelStack>();
-        m_labels->append(ScopeLabelInfo { label->impl(), isLoop });
+            m_labels = adoptPtr(new LabelStack);
+        m_labels->append(ScopeLabelInfo(label->impl(), isLoop));
     }
 
     void popLabel()
@@ -242,179 +182,41 @@ struct Scope {
         if (!m_labels)
             return 0;
         for (int i = m_labels->size(); i > 0; i--) {
-            if (m_labels->at(i - 1).uid == label->impl())
+            if (m_labels->at(i - 1).m_ident == label->impl())
                 return &m_labels->at(i - 1);
         }
         return 0;
     }
 
-    void setSourceParseMode(SourceParseMode mode)
-    {
-        switch (mode) {
-        case SourceParseMode::GeneratorBodyMode:
-            setIsGenerator();
-            break;
-
-        case SourceParseMode::GeneratorWrapperFunctionMode:
-            setIsGeneratorFunction();
-            break;
-
-        case SourceParseMode::NormalFunctionMode:
-        case SourceParseMode::GetterMode:
-        case SourceParseMode::SetterMode:
-        case SourceParseMode::MethodMode:
-            setIsFunction();
-            break;
-
-        case SourceParseMode::ArrowFunctionMode:
-            setIsArrowFunction();
-            break;
-
-        case SourceParseMode::ProgramMode:
-            break;
-
-        case SourceParseMode::ModuleAnalyzeMode:
-        case SourceParseMode::ModuleEvaluateMode:
-            setIsModule();
-            break;
-        }
-    }
-
-    bool isFunction() const { return m_isFunction; }
-    bool isFunctionBoundary() const { return m_isFunctionBoundary; }
-    bool isGenerator() const { return m_isGenerator; }
-
-    bool hasArguments() const { return m_hasArguments; }
-
-    void setIsLexicalScope() 
-    { 
-        m_isLexicalScope = true;
-        m_allowsLexicalDeclarations = true;
-    }
-    bool isLexicalScope() { return m_isLexicalScope; }
-
-    const IdentifierSet& closedVariableCandidates() const { return m_closedVariableCandidates; }
-    VariableEnvironment& declaredVariables() { return m_declaredVariables; }
-    VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }
-    VariableEnvironment& finalizeLexicalEnvironment() 
-    { 
-        if (m_usesEval || m_needsFullActivation)
-            m_lexicalVariables.markAllVariablesAsCaptured();
-        else
-            computeLexicallyCapturedVariablesAndPurgeCandidates();
-
-        return m_lexicalVariables;
-    }
-
-    ModuleScopeData& moduleScopeData() const
-    {
-        ASSERT(m_moduleScopeData);
-        return *m_moduleScopeData;
-    }
-
-    void computeLexicallyCapturedVariablesAndPurgeCandidates()
-    {
-        // Because variables may be defined at any time in the range of a lexical scope, we must
-        // track lexical variables that might be captured. Then, when we're preparing to pop the top
-        // lexical scope off the stack, we should find which variables are truly captured, and which
-        // variable still may be captured in a parent scope.
-        if (m_lexicalVariables.size() && m_closedVariableCandidates.size()) {
-            auto end = m_closedVariableCandidates.end();
-            for (auto iter = m_closedVariableCandidates.begin(); iter != end; ++iter)
-                m_lexicalVariables.markVariableAsCapturedIfDefined(iter->get());
-        }
-
-        // We can now purge values from the captured candidates because they're captured in this scope.
-        {
-            for (auto entry : m_lexicalVariables) {
-                if (entry.value.isCaptured())
-                    m_closedVariableCandidates.remove(entry.key);
-            }
-        }
-    }
-
-    DeclarationResultMask declareCallee(const Identifier* ident)
+    void setIsFunction()
     {
-        auto addResult = m_declaredVariables.add(ident->impl());
-        // We want to track if callee is captured, but we don't want to act like it's a 'var'
-        // because that would cause the BytecodeGenerator to emit bad code.
-        addResult.iterator->value.clearIsVar();
-
-        DeclarationResultMask result = DeclarationResult::Valid;
-        if (isEvalOrArgumentsIdentifier(m_vm, ident))
-            result |= DeclarationResult::InvalidStrictMode;
-        return result;
+        m_isFunction = true;
+        m_isFunctionBoundary = true;
     }
+    bool isFunction() { return m_isFunction; }
+    bool isFunctionBoundary() { return m_isFunctionBoundary; }
 
-    DeclarationResultMask declareVariable(const Identifier* ident)
+    void declareCallee(const Identifier* ident)
     {
-        ASSERT(m_allowsVarDeclarations);
-        DeclarationResultMask result = DeclarationResult::Valid;
-        bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
-        m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
-        auto addResult = m_declaredVariables.add(ident->impl());
-        addResult.iterator->value.setIsVar();
-        if (!isValidStrictMode)
-            result |= DeclarationResult::InvalidStrictMode;
-        if (m_lexicalVariables.contains(ident->impl()))
-            result |= DeclarationResult::InvalidDuplicateDeclaration;
-        return result;
+        m_declaredVariables.add(ident->string().impl());
     }
 
-    DeclarationResultMask declareLexicalVariable(const Identifier* ident, bool isConstant, DeclarationImportType importType = DeclarationImportType::NotImported)
+    bool declareVariable(const Identifier* ident)
     {
-        ASSERT(m_allowsLexicalDeclarations);
-        DeclarationResultMask result = DeclarationResult::Valid;
-        bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
+        bool isValidStrictMode = m_vm->propertyNames->eval != *ident && m_vm->propertyNames->arguments != *ident;
         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
-        auto addResult = m_lexicalVariables.add(ident->impl());
-        if (isConstant)
-            addResult.iterator->value.setIsConst();
-        else
-            addResult.iterator->value.setIsLet();
-
-        if (importType == DeclarationImportType::Imported)
-            addResult.iterator->value.setIsImported();
-        else if (importType == DeclarationImportType::ImportedNamespace) {
-            addResult.iterator->value.setIsImported();
-            addResult.iterator->value.setIsImportedNamespace();
-        }
-
-        if (!addResult.isNewEntry)
-            result |= DeclarationResult::InvalidDuplicateDeclaration;
-        if (!isValidStrictMode)
-            result |= DeclarationResult::InvalidStrictMode;
-
-        return result;
+        m_declaredVariables.add(ident->string().impl());
+        return isValidStrictMode;
     }
 
     bool hasDeclaredVariable(const Identifier& ident)
     {
-        return hasDeclaredVariable(ident.impl());
-    }
-
-    bool hasDeclaredVariable(const RefPtr<UniquedStringImpl>& ident)
-    {
-        auto iter = m_declaredVariables.find(ident.get());
-        if (iter == m_declaredVariables.end())
-            return false;
-        VariableEnvironmentEntry entry = iter->value;
-        return entry.isVar(); // The callee isn't a "var".
-    }
-
-    bool hasLexicallyDeclaredVariable(const RefPtr<UniquedStringImpl>& ident) const
-    {
-        return m_lexicalVariables.contains(ident.get());
+        return m_declaredVariables.contains(ident.impl());
     }
     
-    ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)
+    bool hasDeclaredParameter(const Identifier& ident)
     {
-        return hasDeclaredParameter(ident.impl());
-    }
-
-    bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)
-    {
-        return m_declaredParameters.contains(ident) || hasDeclaredVariable(ident);
+        return m_declaredParameters.contains(ident.impl()) || m_declaredVariables.contains(ident.impl());
     }
     
     void declareWrite(const Identifier* ident)
@@ -423,123 +225,89 @@ struct Scope {
         m_writtenVariables.add(ident->impl());
     }
 
-    void preventAllVariableDeclarations()
-    {
-        m_allowsVarDeclarations = false; 
-        m_allowsLexicalDeclarations = false;
-    }
-    void preventVarDeclarations() { m_allowsVarDeclarations = false; }
-    bool allowsVarDeclarations() const { return m_allowsVarDeclarations; }
-    bool allowsLexicalDeclarations() const { return m_allowsLexicalDeclarations; }
+    void preventNewDecls() { m_allowsNewDecls = false; }
+    bool allowsNewDecls() const { return m_allowsNewDecls; }
 
-    DeclarationResultMask declareParameter(const Identifier* ident)
+    bool declareParameter(const Identifier* ident)
     {
-        ASSERT(m_allowsVarDeclarations);
-        DeclarationResultMask result = DeclarationResult::Valid;
-        bool isArgumentsIdent = isArguments(m_vm, ident);
-        auto addResult = m_declaredVariables.add(ident->impl());
-        addResult.iterator->value.clearIsVar();
-        bool isValidStrictMode = addResult.isNewEntry && m_vm->propertyNames->eval != *ident && !isArgumentsIdent;
+        bool isArguments = m_vm->propertyNames->arguments == *ident;
+        bool isValidStrictMode = m_declaredVariables.add(ident->string().impl()).isNewEntry && m_vm->propertyNames->eval != *ident && !isArguments;
         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
-        m_declaredParameters.add(ident->impl());
-        if (!isValidStrictMode)
-            result |= DeclarationResult::InvalidStrictMode;
-        if (isArgumentsIdent)
-            m_shadowsArguments = true;
-        if (!addResult.isNewEntry)
-            result |= DeclarationResult::InvalidDuplicateDeclaration;
+        m_declaredParameters.add(ident->string().impl());
 
-        return result;
+        if (isArguments)
+            m_shadowsArguments = true;
+        return isValidStrictMode;
     }
     
-    void getUsedVariables(IdentifierSet& usedVariables)
+    enum BindingResult {
+        BindingFailed,
+        StrictBindingFailed,
+        BindingSucceeded
+    };
+    BindingResult declareBoundParameter(const Identifier* ident)
     {
-        usedVariables.swap(m_usedVariables);
+        bool isArguments = m_vm->propertyNames->arguments == *ident;
+        bool newEntry = m_declaredVariables.add(ident->string().impl()).isNewEntry;
+        bool isValidStrictMode = newEntry && m_vm->propertyNames->eval != *ident && !isArguments;
+        m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
+    
+        if (isArguments)
+            m_shadowsArguments = true;
+        if (!newEntry)
+            return BindingFailed;
+        return isValidStrictMode ? BindingSucceeded : StrictBindingFailed;
     }
 
+
     void useVariable(const Identifier* ident, bool isEval)
     {
         m_usesEval |= isEval;
-        m_usedVariables.add(ident->impl());
+        m_usedVariables.add(ident->string().impl());
     }
 
     void setNeedsFullActivation() { m_needsFullActivation = true; }
-    bool needsFullActivation() const { return m_needsFullActivation; }
-    bool isArrowFunction() { return m_isArrowFunction; }
-
-    bool hasDirectSuper() { return m_hasDirectSuper; }
-    void setHasDirectSuper() { m_hasDirectSuper = true; }
-
-    bool needsSuperBinding() { return m_needsSuperBinding; }
-    void setNeedsSuperBinding() { m_needsSuperBinding = true; }
-    
-    void setExpectedSuperBinding(SuperBinding superBinding) { m_expectedSuperBinding = static_cast<unsigned>(superBinding); }
-    SuperBinding expectedSuperBinding() const { return static_cast<SuperBinding>(m_expectedSuperBinding); }
-    void setConstructorKind(ConstructorKind constructorKind) { m_constructorKind = static_cast<unsigned>(constructorKind); }
-    ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
 
-    void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
+    bool collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
     {
         if (nestedScope->m_usesEval)
             m_usesEval = true;
-
-        {
-            for (const RefPtr<UniquedStringImpl>& impl : nestedScope->m_usedVariables) {
-                if (nestedScope->m_declaredVariables.contains(impl) || nestedScope->m_lexicalVariables.contains(impl))
-                    continue;
-
-                // "arguments" reference should be resolved at function boudary.
-                if (nestedScope->isFunctionBoundary() && nestedScope->hasArguments() && impl == m_vm->propertyNames->arguments.impl() && !nestedScope->isArrowFunction())
-                    continue;
-
-                m_usedVariables.add(impl);
-                // We don't want a declared variable that is used in an inner scope to be thought of as captured if
-                // that inner scope is both a lexical scope and not a function. Only inner functions and "catch" 
-                // statements can cause variables to be captured.
-                if (shouldTrackClosedVariables && (nestedScope->m_isFunctionBoundary || !nestedScope->m_isLexicalScope))
-                    m_closedVariableCandidates.add(impl);
-            }
-        }
-        // Propagate closed variable candidates downwards within the same function.
-        // Cross function captures will be realized via m_usedVariables propagation.
-        if (shouldTrackClosedVariables && !nestedScope->m_isFunctionBoundary && nestedScope->m_closedVariableCandidates.size()) {
-            IdentifierSet::iterator end = nestedScope->m_closedVariableCandidates.end();
-            IdentifierSet::iterator begin = nestedScope->m_closedVariableCandidates.begin();
-            m_closedVariableCandidates.add(begin, end);
+        IdentifierSet::iterator end = nestedScope->m_usedVariables.end();
+        for (IdentifierSet::iterator ptr = nestedScope->m_usedVariables.begin(); ptr != end; ++ptr) {
+            if (nestedScope->m_declaredVariables.contains(*ptr))
+                continue;
+            m_usedVariables.add(*ptr);
+            if (shouldTrackClosedVariables)
+                m_closedVariables.add(*ptr);
         }
-
         if (nestedScope->m_writtenVariables.size()) {
             IdentifierSet::iterator end = nestedScope->m_writtenVariables.end();
             for (IdentifierSet::iterator ptr = nestedScope->m_writtenVariables.begin(); ptr != end; ++ptr) {
-                if (nestedScope->m_declaredVariables.contains(*ptr) || nestedScope->m_lexicalVariables.contains(*ptr))
+                if (nestedScope->m_declaredVariables.contains(*ptr))
                     continue;
                 m_writtenVariables.add(*ptr);
             }
         }
+
+        return true;
     }
-    
-    void getCapturedVars(IdentifierSet& capturedVariables, bool& modifiedParameter, bool& modifiedArguments)
+
+    void getCapturedVariables(IdentifierSet& capturedVariables, bool& modifiedParameter)
     {
         if (m_needsFullActivation || m_usesEval) {
             modifiedParameter = true;
-            for (auto& entry : m_declaredVariables)
-                capturedVariables.add(entry.key);
+            capturedVariables.swap(m_declaredVariables);
             return;
         }
-        for (IdentifierSet::iterator ptr = m_closedVariableCandidates.begin(); ptr != m_closedVariableCandidates.end(); ++ptr) {
-            // We refer to m_declaredVariables here directly instead of a hasDeclaredVariable because we want to mark the callee as captured.
-            if (!m_declaredVariables.contains(*ptr)) 
+        for (IdentifierSet::iterator ptr = m_closedVariables.begin(); ptr != m_closedVariables.end(); ++ptr) {
+            if (!m_declaredVariables.contains(*ptr))
                 continue;
             capturedVariables.add(*ptr);
         }
         modifiedParameter = false;
-        if (shadowsArguments())
-            modifiedArguments = true;
         if (m_declaredParameters.size()) {
             IdentifierSet::iterator end = m_writtenVariables.end();
             for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
-                if (*ptr == m_vm->propertyNames->arguments.impl())
-                    modifiedArguments = true;
                 if (!m_declaredParameters.contains(*ptr))
                     continue;
                 modifiedParameter = true;
@@ -552,11 +320,11 @@ struct Scope {
     bool isValidStrictMode() const { return m_isValidStrictMode; }
     bool shadowsArguments() const { return m_shadowsArguments; }
 
-    void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<UniquedStringImpl>>& vector)
+    void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<StringImpl>>& vector)
     {
         IdentifierSet::iterator end = capturedVariables.end();
         for (IdentifierSet::iterator it = capturedVariables.begin(); it != end; ++it) {
-            if (m_declaredVariables.contains(*it) || m_lexicalVariables.contains(*it))
+            if (m_declaredVariables.contains(*it))
                 continue;
             vector.append(*it);
         }
@@ -585,69 +353,25 @@ struct Scope {
     }
 
 private:
-    void setIsFunction()
-    {
-        m_isFunction = true;
-        m_isFunctionBoundary = true;
-        m_hasArguments = true;
-        setIsLexicalScope();
-        m_isGenerator = false;
-    }
-
-    void setIsGeneratorFunction()
-    {
-        setIsFunction();
-        m_isGenerator = true;
-    }
-
-    void setIsGenerator()
-    {
-        setIsFunction();
-        m_isGenerator = true;
-        m_hasArguments = false;
-    }
-    
-    void setIsArrowFunction()
-    {
-        setIsFunction();
-        m_isArrowFunction = true;
-    }
-
-    void setIsModule()
-    {
-        m_moduleScopeData = ModuleScopeData::create();
-    }
-
     const VM* m_vm;
     bool m_shadowsArguments : 1;
     bool m_usesEval : 1;
     bool m_needsFullActivation : 1;
-    bool m_hasDirectSuper : 1;
-    bool m_needsSuperBinding : 1;
-    bool m_allowsVarDeclarations : 1;
-    bool m_allowsLexicalDeclarations : 1;
+    bool m_allowsNewDecls : 1;
     bool m_strictMode : 1;
     bool m_isFunction : 1;
-    bool m_isGenerator : 1;
-    bool m_isArrowFunction : 1;
-    bool m_isLexicalScope : 1;
     bool m_isFunctionBoundary : 1;
     bool m_isValidStrictMode : 1;
-    bool m_hasArguments : 1;
-    unsigned m_constructorKind : 2;
-    unsigned m_expectedSuperBinding : 2;
     int m_loopDepth;
     int m_switchDepth;
 
     typedef Vector<ScopeLabelInfo, 2> LabelStack;
-    std::unique_ptr<LabelStack> m_labels;
+    OwnPtr<LabelStack> m_labels;
     IdentifierSet m_declaredParameters;
-    VariableEnvironment m_declaredVariables;
-    VariableEnvironment m_lexicalVariables;
+    IdentifierSet m_declaredVariables;
     IdentifierSet m_usedVariables;
-    IdentifierSet m_closedVariableCandidates;
+    IdentifierSet m_closedVariables;
     IdentifierSet m_writtenVariables;
-    RefPtr<ModuleScopeData> m_moduleScopeData { };
 };
 
 typedef Vector<Scope, 10> ScopeStack;
@@ -677,27 +401,19 @@ private:
     unsigned m_index;
 };
 
-enum class ArgumentType {
-    Normal,
-    Spread
-};
-
 template <typename LexerType>
 class Parser {
     WTF_MAKE_NONCOPYABLE(Parser);
     WTF_MAKE_FAST_ALLOCATED;
 
 public:
-    Parser(
-        VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding,
-        ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded);
+    Parser(VM*, const SourceCode&, FunctionParameters*, const Identifier&, JSParserStrictness, JSParserMode);
     ~Parser();
 
     template <class ParsedNode>
-    std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode);
+    PassRefPtr<ParsedNode> parse(ParserError&);
 
     JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
-    JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }
 
 private:
     struct AllowInOverride {
@@ -737,251 +453,70 @@ private:
         Parser* m_parser;
     };
 
-    struct AutoCleanupLexicalScope {
-        // We can allocate this object on the stack without actually knowing beforehand if we're 
-        // going to create a new lexical scope. If we decide to create a new lexical scope, we
-        // can pass the scope into this obejct and it will take care of the cleanup for us if the parse fails.
-        // This is helpful if we may fail from syntax errors after creating a lexical scope conditionally.
-        AutoCleanupLexicalScope()
-            : m_scope(nullptr, UINT_MAX)
-            , m_parser(nullptr)
-        {
-        }
-
-        ~AutoCleanupLexicalScope()
-        {
-            // This should only ever be called if we fail from a syntax error. Otherwise
-            // it's the intention that a user of this class pops this scope manually on a 
-            // successful parse. 
-            if (isValid())
-                m_parser->popScope(*this, false);
-        }
-
-        void setIsValid(ScopeRef& scope, Parser* parser)
-        {
-            RELEASE_ASSERT(scope->isLexicalScope());
-            m_scope = scope;
-            m_parser = parser;
-        }
-
-        bool isValid() const { return !!m_parser; }
-
-        void setPopped()
-        {
-            m_parser = nullptr;
-        }
-
-        ScopeRef& scope() { return m_scope; }
-
-    private:
-        ScopeRef m_scope;
-        Parser* m_parser;
-    };
-
-    enum ExpressionErrorClass {
-        ErrorIndicatesNothing,
-        ErrorIndicatesPattern
-    };
-
-    struct ExpressionErrorClassifier {
-        ExpressionErrorClassifier(Parser* parser)
-            : m_class(ErrorIndicatesNothing)
-            , m_previous(parser->m_expressionErrorClassifier)
-            , m_parser(parser)
-        {
-            m_parser->m_expressionErrorClassifier = this;
-        }
-
-        ~ExpressionErrorClassifier()
-        {
-            m_parser->m_expressionErrorClassifier = m_previous;
-        }
-
-        void classifyExpressionError(ExpressionErrorClass classification)
-        {
-            if (m_class != ErrorIndicatesNothing)
-                return;
-            m_class = classification;
-        }
-
-        void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
-        {
-            if (m_class != oldClassification)
-                return;
-            m_class = classification;
-        }
-
-        void propagateExpressionErrorClass()
-        {
-            if (m_previous && m_class != ErrorIndicatesNothing)
-                m_previous->m_class = m_class;
-        }
-
-        bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }
-
-    private:
-        ExpressionErrorClass m_class;
-        ExpressionErrorClassifier* m_previous;
-        Parser* m_parser;
-    };
-
-    ALWAYS_INLINE void classifyExpressionError(ExpressionErrorClass classification)
-    {
-        if (m_expressionErrorClassifier)
-            m_expressionErrorClassifier->classifyExpressionError(classification);
-    }
-
-    ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
-    {
-        if (m_expressionErrorClassifier)
-            m_expressionErrorClassifier->reclassifyExpressionError(oldClassification, classification);
-    }
-
-    ALWAYS_INLINE DestructuringKind destructuringKindFromDeclarationType(DeclarationType type)
-    {
-        switch (type) {
-        case DeclarationType::VarDeclaration:
-            return DestructuringKind::DestructureToVariables;
-        case DeclarationType::LetDeclaration:
-            return DestructuringKind::DestructureToLet;
-        case DeclarationType::ConstDeclaration:
-            return DestructuringKind::DestructureToConst;
-        }
-
-        RELEASE_ASSERT_NOT_REACHED();
-        return DestructuringKind::DestructureToVariables;
-    }
-
-    ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)
-    {
-        switch (type) {
-        case DeclarationType::ConstDeclaration:
-            return AssignmentContext::ConstDeclarationStatement;
-        default:
-            return AssignmentContext::DeclarationStatement;
-        }
-    }
-
-    ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }
-
     ScopeRef currentScope()
     {
         return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
     }
-
-    ScopeRef currentVariableScope()
-    {
-        unsigned i = m_scopeStack.size() - 1;
-        ASSERT(i < m_scopeStack.size());
-        while (!m_scopeStack[i].allowsVarDeclarations()) {
-            i--;
-            ASSERT(i < m_scopeStack.size());
-        }
-        return ScopeRef(&m_scopeStack, i);
-    }
-
-    ScopeRef currentFunctionScope()
-    {
-        unsigned i = m_scopeStack.size() - 1;
-        ASSERT(i < m_scopeStack.size());
-        while (i && !m_scopeStack[i].isFunctionBoundary()) {
-            i--;
-            ASSERT(i < m_scopeStack.size());
-        }
-        // When reaching the top level scope (it can be non function scope), we return it.
-        return ScopeRef(&m_scopeStack, i);
-    }
-
-    ScopeRef closestParentNonArrowFunctionNonLexicalScope()
-    {
-        unsigned i = m_scopeStack.size() - 1;
-        ASSERT(i < m_scopeStack.size() && m_scopeStack.size());
-        while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isArrowFunction()))
-            i--;
-        // When reaching the top level scope (it can be non function scope), we return it.
-        return ScopeRef(&m_scopeStack, i);
-    }
     
     ScopeRef pushScope()
     {
         bool isFunction = false;
         bool isStrict = false;
-        bool isGenerator = false;
         if (!m_scopeStack.isEmpty()) {
             isStrict = m_scopeStack.last().strictMode();
             isFunction = m_scopeStack.last().isFunction();
-            isGenerator = m_scopeStack.last().isGenerator();
         }
-        m_scopeStack.append(Scope(m_vm, isFunction, isGenerator, isStrict));
+        m_scopeStack.append(Scope(m_vm, isFunction, isStrict));
         return currentScope();
     }
     
-    void popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
+    bool popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
     {
         ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);
         ASSERT(m_scopeStack.size() > 1);
-        m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
-        if (!m_scopeStack.last().isFunctionBoundary() && m_scopeStack.last().needsFullActivation())
-            m_scopeStack[m_scopeStack.size() - 2].setNeedsFullActivation();
+        bool result = m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
         m_scopeStack.removeLast();
+        return result;
     }
     
-    ALWAYS_INLINE void popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
+    bool popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
     {
-        popScopeInternal(scope, shouldTrackClosedVariables);
+        return popScopeInternal(scope, shouldTrackClosedVariables);
     }
     
-    ALWAYS_INLINE void popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
+    bool popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
     {
         scope.setPopped();
-        popScopeInternal(scope, shouldTrackClosedVariables);
-    }
-
-    ALWAYS_INLINE void popScope(AutoCleanupLexicalScope& cleanupScope, bool shouldTrackClosedVariables)
-    {
-        RELEASE_ASSERT(cleanupScope.isValid());
-        ScopeRef& scope = cleanupScope.scope();
-        cleanupScope.setPopped();
-        popScopeInternal(scope, shouldTrackClosedVariables);
+        return popScopeInternal(scope, shouldTrackClosedVariables);
     }
     
-    DeclarationResultMask declareVariable(const Identifier* ident, DeclarationType type = DeclarationType::VarDeclaration, DeclarationImportType importType = DeclarationImportType::NotImported)
+    bool declareVariable(const Identifier* ident)
     {
-        if (type == DeclarationType::VarDeclaration)
-            return currentVariableScope()->declareVariable(ident);
-
         unsigned i = m_scopeStack.size() - 1;
         ASSERT(i < m_scopeStack.size());
-        ASSERT(type == DeclarationType::LetDeclaration || type == DeclarationType::ConstDeclaration);
-
-        // Lexical variables declared at a top level scope that shadow arguments or vars are not allowed.
-        if (m_statementDepth == 1 && (hasDeclaredParameter(*ident) || hasDeclaredVariable(*ident)))
-            return DeclarationResult::InvalidDuplicateDeclaration;
-
-        while (!m_scopeStack[i].allowsLexicalDeclarations()) {
+        while (!m_scopeStack[i].allowsNewDecls()) {
             i--;
             ASSERT(i < m_scopeStack.size());
         }
-
-        return m_scopeStack[i].declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
+        return m_scopeStack[i].declareVariable(ident);
     }
     
     NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)
     {
         unsigned i = m_scopeStack.size() - 1;
         ASSERT(i < m_scopeStack.size());
-        while (!m_scopeStack[i].allowsVarDeclarations()) {
+        while (!m_scopeStack[i].allowsNewDecls()) {
             i--;
             ASSERT(i < m_scopeStack.size());
         }
         return m_scopeStack[i].hasDeclaredVariable(ident);
     }
-
+    
     NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)
     {
         unsigned i = m_scopeStack.size() - 1;
         ASSERT(i < m_scopeStack.size());
-        while (!m_scopeStack[i].allowsVarDeclarations()) {
+        while (!m_scopeStack[i].allowsNewDecls()) {
             i--;
             ASSERT(i < m_scopeStack.size());
         }
@@ -993,13 +528,7 @@ private:
         if (!m_syntaxAlreadyValidated || strictMode())
             m_scopeStack.last().declareWrite(ident);
     }
-
-    bool exportName(const Identifier& ident)
-    {
-        ASSERT(currentScope().index() == 0);
-        return currentScope()->moduleScopeData().exportName(ident);
-    }
-
+    
     ScopeStack m_scopeStack;
     
     const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
@@ -1008,13 +537,14 @@ private:
     }
 
     Parser();
-    String parseInner(const Identifier&, SourceParseMode);
+    String parseInner();
 
-    void didFinishParsing(SourceElements*, DeclarationStacks::FunctionStack&, VariableEnvironment&, CodeFeatures, int);
+    void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*, 
+        ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures, int, IdentifierSet&);
 
     // Used to determine type of error to report.
-    bool isFunctionMetadataNode(ScopeNode*) { return false; }
-    bool isFunctionMetadataNode(FunctionMetadataNode*) { return true; }
+    bool isFunctionBodyNode(ScopeNode*) { return false; }
+    bool isFunctionBodyNode(FunctionBodyNode*) { return true; }
 
     ALWAYS_INLINE void next(unsigned lexerFlags = 0)
     {
@@ -1024,8 +554,6 @@ private:
         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
         m_lexer->setLastLineNumber(lastLine);
         m_token.m_type = m_lexer->lex(&m_token, lexerFlags, strictMode());
-        if (UNLIKELY(m_token.m_type == CONSTTOKEN && m_vm->shouldRewriteConstAsVar()))
-            m_token.m_type = VAR;
     }
 
     ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
@@ -1052,7 +580,7 @@ private:
     }
 
     void printUnexpectedTokenText(WTF::PrintStream&);
-    ALWAYS_INLINE StringView getToken() {
+    ALWAYS_INLINE String getToken() {
         SourceProvider* sourceProvider = m_source->provider();
         return sourceProvider->getRange(tokenStart(), tokenEndPosition().offset);
     }
@@ -1062,21 +590,11 @@ private:
         return m_token.m_type == expected;
     }
     
-    ALWAYS_INLINE bool matchContextualKeyword(const Identifier& identifier)
+    ALWAYS_INLINE bool isofToken()
     {
-        return m_token.m_type == IDENT && *m_token.m_data.ident == identifier;
-    }
-
-    ALWAYS_INLINE bool matchIdentifierOrKeyword()
-    {
-        return isIdentifierOrKeyword(m_token);
+        return m_token.m_type == IDENT && *m_token.m_data.ident == m_vm->propertyNames->of;
     }
     
-    ALWAYS_INLINE bool isEndOfArrowFunction()
-    {
-        return match(SEMICOLON) || match(COMMA) || match(CLOSEPAREN) || match(CLOSEBRACE) || match(CLOSEBRACKET) || match(EOFTOK) || m_lexer->prevTerminator();
-    }
-
     ALWAYS_INLINE unsigned tokenStart()
     {
         return m_token.m_location.startOffset;
@@ -1112,9 +630,9 @@ private:
         return m_token.m_location;
     }
 
-    void setErrorMessage(const String& message)
+    void setErrorMessage(String msg)
     {
-        m_errorMessage = message;
+        m_errorMessage = msg;
     }
     
     NEVER_INLINE void logError(bool);
@@ -1126,9 +644,9 @@ private:
     template <typename A, typename B, typename C, typename D, typename E, typename F> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&);
     template <typename A, typename B, typename C, typename D, typename E, typename F, typename G> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&, const G&);
     
-    NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMessage, const String& name, const char* afterMessage)
+    NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMsg, String name, const char* afterMsg)
     {
-        m_errorMessage = makeString(beforeMessage, " '", name, "' ", afterMessage);
+        m_errorMessage = makeString(beforeMsg, " '", name, "' ", afterMsg);
     }
     
     NEVER_INLINE void updateErrorMessage(const char* msg)
@@ -1145,9 +663,8 @@ private:
     void setStrictMode() { currentScope()->setStrictMode(); }
     bool strictMode() { return currentScope()->strictMode(); }
     bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
-    DeclarationResultMask declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
-    bool declareRestOrNormalParameter(const Identifier&, const Identifier**);
-
+    bool declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
+    Scope::BindingResult declareBoundParameter(const Identifier* ident) { return currentScope()->declareBoundParameter(ident); }
     bool breakIsValid()
     {
         ScopeRef current = currentScope();
@@ -1169,7 +686,7 @@ private:
         return true;
     }
     void pushLabel(const Identifier* label, bool isLoop) { currentScope()->pushLabel(label, isLoop); }
-    void popLabel(ScopeRef scope) { scope->popLabel(); }
+    void popLabel() { currentScope()->popLabel(); }
     ScopeLabelInfo* getLabel(const Identifier* label)
     {
         ScopeRef current = currentScope();
@@ -1181,38 +698,12 @@ private:
         }
         return result;
     }
-
-    // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
-    ALWAYS_INLINE bool isLETMaskedAsIDENT()
-    {
-        return match(LET) && !strictMode();
-    }
-
-    // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
-    ALWAYS_INLINE bool isYIELDMaskedAsIDENT(bool inGenerator)
-    {
-        return match(YIELD) && !strictMode() && !inGenerator;
-    }
-
-    // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
-    ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
-    {
-        return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
-    }
-
-    ALWAYS_INLINE bool matchSpecIdentifier()
-    {
-        return matchSpecIdentifier(currentScope()->isGenerator());
-    }
-
+    
     template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode);
-    template <class TreeBuilder> TreeSourceElements parseGeneratorFunctionSourceElements(TreeBuilder&, SourceElementsMode);
-    template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
     template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
-    enum class ExportType { Exported, NotExported };
-    template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
-    template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
-    template <class TreeBuilder> TreeStatement parseVariableDeclaration(TreeBuilder&, DeclarationType, ExportType = ExportType::NotExported);
+    template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&);
+    template <class TreeBuilder> TreeStatement parseVarDeclaration(TreeBuilder&);
+    template <class TreeBuilder> TreeStatement parseConstDeclaration(TreeBuilder&);
     template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
     template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
     template <class TreeBuilder> TreeStatement parseForStatement(TreeBuilder&);
@@ -1231,10 +722,7 @@ private:
     template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
     template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
     template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&, ExpressionErrorClassifier&);
     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseAssignmentExpressionOrPropagateErrorClass(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseYieldExpression(TreeBuilder&);
     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
@@ -1243,48 +731,18 @@ private:
     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
     template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseFunctionExpression(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
-    template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArgument(TreeBuilder&, ArgumentType&);
+    enum SpreadMode { AllowSpread, DontAllowSpread };
+    template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&, SpreadMode);
     template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
-    template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator);
-    template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);
-    template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, SuperBinding, FunctionBodyType, unsigned, SourceParseMode);
-    template <class TreeBuilder> ALWAYS_INLINE bool parseFormalParameters(TreeBuilder&, TreeFormalParameterList, unsigned&);
-    enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
-    template <class TreeBuilder> TreeExpression parseVariableDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext, DeclarationType, ExportType, bool& forLoopConstDoesNotHaveInitializer);
-    template <class TreeBuilder> TreeSourceElements parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder&);
-    template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier&, JSToken, AssignmentContext, const Identifier** duplicateIdentifier);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createAssignmentElement(TreeBuilder&, TreeExpression&, const JSTextPosition&, const JSTextPosition&);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier** duplicateIdentifier = nullptr, bool* hasDestructuringPattern = nullptr, AssignmentContext = AssignmentContext::DeclarationStatement, int depth = 0);
-    template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&, AssignmentContext);
-    template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
-    template <class TreeBuilder> TreeSourceElements parseModuleSourceElements(TreeBuilder&, SourceParseMode);
-    enum class ImportSpecifierType { NamespaceImport, NamedImport, DefaultImport };
-    template <class TreeBuilder> typename TreeBuilder::ImportSpecifier parseImportClauseItem(TreeBuilder&, ImportSpecifierType);
-    template <class TreeBuilder> typename TreeBuilder::ModuleName parseModuleName(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseImportDeclaration(TreeBuilder&);
-    template <class TreeBuilder> typename TreeBuilder::ExportSpecifier parseExportSpecifier(TreeBuilder& context, Vector<const Identifier*>& maybeLocalNames, bool& hasKeywordForLocalBindings);
-    template <class TreeBuilder> TreeStatement parseExportDeclaration(TreeBuilder&);
-
-    enum class FunctionDefinitionType { Expression, Declaration, Method };
-    template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, SourceParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionDefinitionType);
-    
-    ALWAYS_INLINE bool isArrowFunctionParameters();
-    
-    template <class TreeBuilder> NEVER_INLINE int parseFunctionParameters(TreeBuilder&, SourceParseMode, ParserFunctionInfo<TreeBuilder>&);
-    template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::FormalParameterList createGeneratorParameters(TreeBuilder&);
-
-    template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements, ParserClassInfo<TreeBuilder>&);
-
-    template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateString parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode, bool& elementIsTail);
-    template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateLiteral parseTemplateLiteral(TreeBuilder&, typename LexerType::RawStringsBuildMode);
-
-    template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
-
+    template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&);
+    template <class TreeBuilder> ALWAYS_INLINE TreeFormalParameterList parseFormalParameters(TreeBuilder&);
+    template <class TreeBuilder> TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd);
+    template <class TreeBuilder> NEVER_INLINE TreeConstDeclList parseConstDeclarationList(TreeBuilder&);
+
+    template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern createBindingPattern(TreeBuilder&, DeconstructionKind, const Identifier&, int depth);
+    template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern parseDeconstructionPattern(TreeBuilder&, DeconstructionKind, int depth = 0);
+    template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern tryParseDeconstructionPatternExpression(TreeBuilder&);
+    template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, FunctionParseMode, bool nameIsInContainingScope, const Identifier*&, TreeFormalParameterList&, TreeFunctionBody&, unsigned& openBraceOffset, unsigned& closeBraceOffset, int& bodyStartLine, unsigned& bodyStartColumn);
     ALWAYS_INLINE int isBinaryOperator(JSTokenType);
     bool allowAutomaticSemicolon();
     
@@ -1297,11 +755,6 @@ private:
         return allowAutomaticSemicolon();
     }
     
-    void setEndOfStatement()
-    {
-        m_lexer->setTokenPosition(&m_token);
-    }
-
     bool canRecurse()
     {
         return m_vm->isSafeToRecurse();
@@ -1317,114 +770,81 @@ private:
         return !m_errorMessage.isNull();
     }
 
-    enum class FunctionParsePhase { Parameters, Body };
-    struct ParserState {
-        int assignmentCount { 0 };
-        int nonLHSCount { 0 };
-        int nonTrivialExpressionCount { 0 };
-        FunctionParsePhase functionParsePhase { FunctionParsePhase::Body };
-        const Identifier* lastIdentifier { nullptr };
-        const Identifier* lastFunctionName { nullptr };
-    };
-
-    // If you're using this directly, you probably should be using
-    // createSavePoint() instead.
-    ALWAYS_INLINE ParserState internalSaveParserState()
-    {
-        return m_parserState;
-    }
-
-    ALWAYS_INLINE void restoreParserState(const ParserState& state)
-    {
-        m_parserState = state;
-    }
-
-    struct LexerState {
+    struct SavePoint {
         int startOffset;
         unsigned oldLineStartOffset;
         unsigned oldLastLineNumber;
         unsigned oldLineNumber;
     };
-
-    // If you're using this directly, you probably should be using
-    // createSavePoint() instead.
-    // i.e, if you parse any kind of AssignmentExpression between
-    // saving/restoring, you should definitely not be using this directly.
-    ALWAYS_INLINE LexerState internalSaveLexerState()
+    
+    ALWAYS_INLINE SavePoint createSavePoint()
     {
-        LexerState result;
+        ASSERT(!hasError());
+        SavePoint result;
         result.startOffset = m_token.m_location.startOffset;
         result.oldLineStartOffset = m_token.m_location.lineStartOffset;
         result.oldLastLineNumber = m_lexer->lastLineNumber();
         result.oldLineNumber = m_lexer->lineNumber();
         return result;
     }
-
-    ALWAYS_INLINE void restoreLexerState(const LexerState& lexerState)
+    
+    ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
     {
-        m_lexer->setOffset(lexerState.startOffset, lexerState.oldLineStartOffset);
+        m_errorMessage = String();
+        m_lexer->setOffset(savePoint.startOffset, savePoint.oldLineStartOffset);
         next();
-        m_lexer->setLastLineNumber(lexerState.oldLastLineNumber);
-        m_lexer->setLineNumber(lexerState.oldLineNumber);
+        m_lexer->setLastLineNumber(savePoint.oldLastLineNumber);
+        m_lexer->setLineNumber(savePoint.oldLineNumber);
     }
 
-    struct SavePoint {
-        ParserState parserState;
-        LexerState lexerState;
+    struct ParserState {
+        int assignmentCount;
+        int nonLHSCount;
+        int nonTrivialExpressionCount;
     };
-    
-    ALWAYS_INLINE SavePoint createSavePointForError()
+
+    ALWAYS_INLINE ParserState saveState()
     {
-        SavePoint result;
-        result.parserState = internalSaveParserState();
-        result.lexerState = internalSaveLexerState();
+        ParserState result;
+        result.assignmentCount = m_assignmentCount;
+        result.nonLHSCount = m_nonLHSCount;
+        result.nonTrivialExpressionCount = m_nonTrivialExpressionCount;
         return result;
     }
     
-    ALWAYS_INLINE SavePoint createSavePoint()
+    ALWAYS_INLINE void restoreState(const ParserState& state)
     {
-        ASSERT(!hasError());
-        return createSavePointForError();
-    }
-
-    ALWAYS_INLINE void restoreSavePointWithError(const SavePoint& savePoint, const String& message)
-    {
-        m_errorMessage = message;
-        restoreLexerState(savePoint.lexerState);
-        restoreParserState(savePoint.parserState);
-    }
-
-    ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
-    {
-        restoreSavePointWithError(savePoint, String());
+        m_assignmentCount = state.assignmentCount;
+        m_nonLHSCount = state.nonLHSCount;
+        m_nonTrivialExpressionCount = state.nonTrivialExpressionCount;
+        
     }
+    
 
     VM* m_vm;
     const SourceCode* m_source;
-    ParserArena m_parserArena;
-    std::unique_ptr<LexerType> m_lexer;
-    FunctionParameters* m_parameters { nullptr };
-
-    ParserState m_parserState;
+    ParserArena* m_arena;
+    OwnPtr<LexerType> m_lexer;
     
     bool m_hasStackOverflow;
     String m_errorMessage;
     JSToken m_token;
     bool m_allowsIn;
     JSTextPosition m_lastTokenEndPosition;
+    int m_assignmentCount;
+    int m_nonLHSCount;
     bool m_syntaxAlreadyValidated;
     int m_statementDepth;
+    int m_nonTrivialExpressionCount;
+    const Identifier* m_lastIdentifier;
+    const Identifier* m_lastFunctionName;
     RefPtr<SourceProviderCache> m_functionCache;
     SourceElements* m_sourceElements;
-    bool m_parsingBuiltin;
-    SuperBinding m_superBinding;
-    ConstructorKind m_defaultConstructorKind;
-    ThisTDZMode m_thisTDZMode;
-    VariableEnvironment m_varDeclarations;
-    DeclarationStacks::FunctionStack m_funcDeclarations;
+    ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
+    ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
+    IdentifierSet m_capturedVariables;
     CodeFeatures m_features;
     int m_numConstants;
-    ExpressionErrorClassifier* m_expressionErrorClassifier;
     
     struct DepthManager {
         DepthManager(int* depth)
@@ -1447,13 +867,13 @@ private:
 
 template <typename LexerType>
 template <class ParsedNode>
-std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode)
+PassRefPtr<ParsedNode> Parser<LexerType>::parse(ParserError& error)
 {
     int errLine;
     String errMsg;
 
     if (ParsedNode::scopeIsFunction)
-        m_lexer->setIsReparsingFunction();
+        m_lexer->setIsReparsing();
 
     m_sourceElements = 0;
 
@@ -1464,7 +884,7 @@ std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I
     ASSERT(m_source->startColumn() > 0);
     unsigned startColumn = m_source->startColumn() - 1;
 
-    String parseError = parseInner(calleeName, parseMode);
+    String parseError = parseInner();
 
     int lineNumber = m_lexer->lineNumber();
     bool lexError = m_lexer->sawError();
@@ -1478,33 +898,26 @@ std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I
         m_sourceElements = 0;
     }
 
-    std::unique_ptr<ParsedNode> result;
+    RefPtr<ParsedNode> result;
     if (m_sourceElements) {
         JSTokenLocation endLocation;
         endLocation.line = m_lexer->lineNumber();
         endLocation.lineStartOffset = m_lexer->currentLineStartOffset();
         endLocation.startOffset = m_lexer->currentOffset();
         unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;
-        result = std::make_unique<ParsedNode>(m_parserArena,
+        result = ParsedNode::create(m_vm,
                                     startLocation,
                                     endLocation,
                                     startColumn,
                                     endColumn,
                                     m_sourceElements,
-                                    m_varDeclarations,
-                                    m_funcDeclarations,
-                                    currentScope()->finalizeLexicalEnvironment(),
-                                    m_parameters,
+                                    m_varDeclarations ? &m_varDeclarations->data : 0,
+                                    m_funcDeclarations ? &m_funcDeclarations->data : 0,
+                                    m_capturedVariables,
                                     *m_source,
                                     m_features,
                                     m_numConstants);
         result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
-        result->setEndOffset(m_lexer->currentOffset());
-
-        if (!isFunctionParseMode(parseMode)) {
-            m_source->provider()->setSourceURLDirective(m_lexer->sourceURL());
-            m_source->provider()->setSourceMappingURLDirective(m_lexer->sourceMappingURL());
-        }
     } else {
         // We can never see a syntax error when reparsing a function, since we should have
         // reported the error when parsing the containing program or eval code. So if we're
@@ -1512,19 +925,14 @@ std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I
         // we ran out of stack while parsing. If we see an error while parsing eval or program
         // code we assume that it was a syntax error since running out of stack is much less
         // likely, and we are currently unable to distinguish between the two cases.
-        if (isFunctionMetadataNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)
+        if (isFunctionBodyNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)
             error = ParserError(ParserError::StackOverflow, ParserError::SyntaxErrorNone, m_token);
         else {
             ParserError::SyntaxErrorType errorType = ParserError::SyntaxErrorIrrecoverable;
             if (m_token.m_type == EOFTOK)
                 errorType = ParserError::SyntaxErrorRecoverable;
-            else if (m_token.m_type & UnterminatedErrorTokenFlag) {
-                // Treat multiline capable unterminated literals as recoverable.
-                if (m_token.m_type == UNTERMINATED_MULTILINE_COMMENT_ERRORTOK || m_token.m_type == UNTERMINATED_TEMPLATE_LITERAL_ERRORTOK)
-                    errorType = ParserError::SyntaxErrorRecoverable;
-                else
-                    errorType = ParserError::SyntaxErrorUnterminatedLiteral;
-            }
+            else if (m_token.m_type & UnterminatedErrorTokenFlag)
+                errorType = ParserError::SyntaxErrorUnterminatedLiteral;
             
             if (isEvalNode<ParsedNode>())
                 error = ParserError(ParserError::EvalError, errorType, m_token, errMsg, errLine);
@@ -1533,38 +941,29 @@ std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const I
         }
     }
 
-    return result;
+    m_arena->reset();
+
+    return result.release();
 }
 
 template <class ParsedNode>
-std::unique_ptr<ParsedNode> parse(
-    VM* vm, const SourceCode& source,
-    const Identifier& name, JSParserBuiltinMode builtinMode,
-    JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding,
-    ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
-    ConstructorKind defaultConstructorKind = ConstructorKind::None,
-    ThisTDZMode thisTDZMode = ThisTDZMode::CheckIfNeeded)
+PassRefPtr<ParsedNode> parse(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode, ParserError& error, JSTextPosition* positionBeforeLastNewline = 0)
 {
     SamplingRegion samplingRegion("Parsing");
 
     ASSERT(!source.provider()->source().isNull());
     if (source.provider()->source().is8Bit()) {
-        Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode);
-        std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
+        Parser<Lexer<LChar>> parser(vm, source, parameters, name, strictness, parserMode);
+        RefPtr<ParsedNode> result = parser.parse<ParsedNode>(error);
         if (positionBeforeLastNewline)
             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
-        if (builtinMode == JSParserBuiltinMode::Builtin) {
-            if (!result)
-                WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
-        }
-        return result;
+        return result.release();
     }
-    ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
-    Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode);
-    std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
+    Parser<Lexer<UChar>> parser(vm, source, parameters, name, strictness, parserMode);
+    RefPtr<ParsedNode> result = parser.parse<ParsedNode>(error);
     if (positionBeforeLastNewline)
         *positionBeforeLastNewline = parser.positionBeforeLastNewline();
-    return result;
+    return result.release();
 }
 
 } // namespace