1 files changed, 31 insertions, 134 deletions

diff --git a/Source/JavaScriptCore/runtime/JSScope.h b/Source/JavaScriptCore/runtime/JSScope.h
index 3f62a45ac..71545746d 100644
--- a/Source/JavaScriptCore/runtime/JSScope.h
+++ b/Source/JavaScriptCore/runtime/JSScope.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012, 2013 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2012-2016 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -23,149 +23,58 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef JSScope_h
-#define JSScope_h
+#pragma once
 
+#include "GetPutInfo.h"
 #include "JSObject.h"
 
 namespace JSC {
 
 class ScopeChainIterator;
-class VariableWatchpointSet;
-
-enum ResolveMode {
-    ThrowIfNotFound,
-    DoNotThrowIfNotFound
-};
-
-enum ResolveType {
-    // Lexical scope guaranteed a certain type of variable access.
-    GlobalProperty,
-    GlobalVar,
-    ClosureVar,
-
-    // Ditto, but at least one intervening scope used non-strict eval, which
-    // can inject an intercepting var delcaration at runtime.
-    GlobalPropertyWithVarInjectionChecks,
-    GlobalVarWithVarInjectionChecks,
-    ClosureVarWithVarInjectionChecks,
-
-    // Lexical scope didn't prove anything -- probably because of a 'with' scope.
-    Dynamic
-};
-
-inline ResolveType makeType(ResolveType type, bool needsVarInjectionChecks)
-{
-    if (!needsVarInjectionChecks)
-        return type;
-
-    switch (type) {
-    case GlobalProperty:
-        return GlobalPropertyWithVarInjectionChecks;
-    case GlobalVar:
-        return GlobalVarWithVarInjectionChecks;
-    case ClosureVar:
-        return ClosureVarWithVarInjectionChecks;
-    case GlobalPropertyWithVarInjectionChecks:
-    case GlobalVarWithVarInjectionChecks:
-    case ClosureVarWithVarInjectionChecks:
-    case Dynamic:
-        return type;
-    }
-
-    RELEASE_ASSERT_NOT_REACHED();
-    return type;
-}
-
-inline bool needsVarInjectionChecks(ResolveType type)
-{
-    switch (type) {
-    case GlobalProperty:
-    case GlobalVar:
-    case ClosureVar:
-        return false;
-    case GlobalPropertyWithVarInjectionChecks:
-    case GlobalVarWithVarInjectionChecks:
-    case ClosureVarWithVarInjectionChecks:
-    case Dynamic:
-        return true;
-    default:
-        RELEASE_ASSERT_NOT_REACHED();
-        return true;
-    }
-}
-
-struct ResolveOp {
-    ResolveOp(ResolveType type, size_t depth, Structure* structure, JSActivation* activation, VariableWatchpointSet* watchpointSet, uintptr_t operand)
-        : type(type)
-        , depth(depth)
-        , structure(structure)
-        , activation(activation)
-        , watchpointSet(watchpointSet)
-        , operand(operand)
-    {
-    }
-
-    ResolveType type;
-    size_t depth;
-    Structure* structure;
-    JSActivation* activation;
-    VariableWatchpointSet* watchpointSet;
-    uintptr_t operand;
-};
-
-class ResolveModeAndType {
-    typedef unsigned Operand;
-public:
-    static const size_t shift = sizeof(Operand) * 8 / 2;
-    static const unsigned mask = (1 << shift) - 1;
-
-    ResolveModeAndType(ResolveMode resolveMode, ResolveType resolveType)
-        : m_operand((resolveMode << shift) | resolveType)
-    {
-    }
-
-    explicit ResolveModeAndType(unsigned operand)
-        : m_operand(operand)
-    {
-    }
-
-    ResolveMode mode() { return static_cast<ResolveMode>(m_operand >> shift); }
-    ResolveType type() { return static_cast<ResolveType>(m_operand & mask); }
-    unsigned operand() { return m_operand; }
-
-private:
-    Operand m_operand;
-};
-
-enum GetOrPut { Get, Put };
+class SymbolTable;
+class VariableEnvironment;
+class WatchpointSet;
 
 class JSScope : public JSNonFinalObject {
 public:
     typedef JSNonFinalObject Base;
+    static const unsigned StructureFlags = Base::StructureFlags;
 
     friend class LLIntOffsetsExtractor;
     static size_t offsetOfNext();
 
-    JS_EXPORT_PRIVATE static JSObject* objectAtScope(JSScope*);
+    static JSObject* objectAtScope(JSScope*);
+
+    static JSObject* resolve(ExecState*, JSScope*, const Identifier&);
+    static ResolveOp abstractResolve(ExecState*, size_t depthOffset, JSScope*, const Identifier&, GetOrPut, ResolveType, InitializationMode);
 
-    static JSValue resolve(ExecState*, JSScope*, const Identifier&);
-    static ResolveOp abstractResolve(ExecState*, JSScope*, const Identifier&, GetOrPut, ResolveType);
+    static bool hasConstantScope(ResolveType);
+    static JSScope* constantScopeForCodeBlock(ResolveType, CodeBlock*);
+
+    static void collectClosureVariablesUnderTDZ(JSScope*, VariableEnvironment& result);
 
     static void visitChildren(JSCell*, SlotVisitor&);
 
+    bool isVarScope();
+    bool isLexicalScope();
+    bool isModuleScope();
+    bool isCatchScope();
+    bool isFunctionNameScopeObject();
+
+    bool isNestedLexicalScope();
+
     ScopeChainIterator begin();
     ScopeChainIterator end();
     JSScope* next();
-    int depth();
 
     JSGlobalObject* globalObject();
-    VM* vm();
+    JSGlobalObject* globalObject(VM&);
     JSObject* globalThis();
 
+    SymbolTable* symbolTable(VM&);
+
 protected:
     JSScope(VM&, Structure*, JSScope* next);
-    static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
 
 private:
     WriteBarrier<JSScope> m_next;
@@ -186,6 +95,7 @@ public:
 
     JSObject* get() const { return JSScope::objectAtScope(m_node); }
     JSObject* operator->() const { return JSScope::objectAtScope(m_node); }
+    JSScope* scope() const { return m_node; }
 
     ScopeChainIterator& operator++() { m_node = m_node->next(); return *this; }
 
@@ -218,9 +128,9 @@ inline JSGlobalObject* JSScope::globalObject()
     return structure()->globalObject();
 }
 
-inline VM* JSScope::vm()
+inline JSGlobalObject* JSScope::globalObject(VM& vm)
 { 
-    return MarkedBlock::blockFor(this)->vm();
+    return structure(vm)->globalObject();
 }
 
 inline Register& Register::operator=(JSScope* scope)
@@ -231,23 +141,12 @@ inline Register& Register::operator=(JSScope* scope)
 
 inline JSScope* Register::scope() const
 {
-    return jsCast<JSScope*>(jsValue());
-}
-
-inline VM& ExecState::vm() const
-{
-    ASSERT(scope()->vm());
-    return *scope()->vm();
+    return jsCast<JSScope*>(unboxedCell());
 }
 
 inline JSGlobalObject* ExecState::lexicalGlobalObject() const
 {
-    return scope()->globalObject();
-}
-
-inline JSObject* ExecState::globalThisValue() const
-{
-    return scope()->globalThis();
+    return jsCallee()->globalObject();
 }
 
 inline size_t JSScope::offsetOfNext()
@@ -256,5 +155,3 @@ inline size_t JSScope::offsetOfNext()
 }
 
 } // namespace JSC
-
-#endif // JSScope_h