Changeset 116372 in webkit for trunk/Source/JavaScriptCore/parser/Parser.h

Timestamp:

May 7, 2012, 4:35:52 PM (13 years ago)

Author:

[email protected]

Message:

2012-05-07 Oliver Hunt <​[email protected]>

Rolling out r110287

RS=Filip Pizlo

r110287 was meant to be refactoring only, but changed behavior
enough to break some websites, including qq.com.

File:

• trunk/Source/JavaScriptCore/parser/Parser.h (modified) (15 diffs)

trunk/Source/JavaScriptCore/parser/Parser.h

@@ -131 +131 @@
 
 struct Scope {
-    Scope(const JSGlobalData* globalData, ScopeFlags scopeFlags)
+    Scope(const JSGlobalData* globalData, bool isFunction, bool strictMode)
         : m_globalData(globalData)
-        , m_scopeFlags(scopeFlags)
+        , m_shadowsArguments(false)
+        , m_usesEval(false)
+        , m_needsFullActivation(false)
+        , m_allowsNewDecls(true)
+        , m_strictMode(strictMode)
+        , m_isFunction(isFunction)
+        , m_isFunctionBoundary(false)
         , m_isValidStrictMode(true)
         , m_loopDepth(0)
         , m_switchDepth(0)
     {
-        ASSERT(!(scopeFlags & ~AllScopeModeFlags));
     }
 
     Scope(const Scope& rhs)
         : m_globalData(rhs.m_globalData)
-        , m_scopeFlags(rhs.m_scopeFlags)
+        , m_shadowsArguments(rhs.m_shadowsArguments)
+        , m_usesEval(rhs.m_usesEval)
+        , m_needsFullActivation(rhs.m_needsFullActivation)
+        , m_allowsNewDecls(rhs.m_allowsNewDecls)
+        , m_strictMode(rhs.m_strictMode)
+        , m_isFunction(rhs.m_isFunction)
+        , m_isFunctionBoundary(rhs.m_isFunctionBoundary)
         , m_isValidStrictMode(rhs.m_isValidStrictMode)
         , m_loopDepth(rhs.m_loopDepth)
@@ -157 +168 @@
         }
     }
-
-    ALWAYS_INLINE ScopeFlags scopeFlags() const { return m_scopeFlags; }
-    ALWAYS_INLINE ScopeFlags modeFlags() const { return m_scopeFlags & AllScopeModeFlags; }
-    ALWAYS_INLINE ScopeFlags usesFlags() const { return m_scopeFlags & AllScopeUsesFlags; }
-    ALWAYS_INLINE void setFlags(ScopeFlags scopeFlags) { m_scopeFlags |= scopeFlags; }
-
-    ALWAYS_INLINE bool usesEval() const { return m_scopeFlags & UsesEvalFlag; }
-    ALWAYS_INLINE bool strictMode() const { return m_scopeFlags & StrictModeFlag; }
-    ALWAYS_INLINE bool shadowsArguments() const { return m_scopeFlags & ShadowsArgumentsFlag; }
-    ALWAYS_INLINE bool isFunction() const { return m_scopeFlags & FunctionModeFlag; }
-    ALWAYS_INLINE bool isBlockScope() const { return m_scopeFlags & BlockScopeFlag; }
-    ALWAYS_INLINE bool isFunctionBoundary() const { return isFunction() && !isBlockScope(); }
-
-    ALWAYS_INLINE bool allowsNewDecls() const { return !isBlockScope(); }
-
-    ALWAYS_INLINE bool isValidStrictMode() const { return m_isValidStrictMode; }
 
     void startSwitch() { m_switchDepth++; }
@@ -207 +202 @@
     }
 
+    void setIsFunction()
+    {
+        m_isFunction = true;
+        m_isFunctionBoundary = true;
+    }
+    bool isFunction() { return m_isFunction; }
+    bool isFunctionBoundary() { return m_isFunctionBoundary; }
+
     bool declareVariable(const Identifier* ident)
     {
@@ -217 +220 @@
     void declareWrite(const Identifier* ident)
     {
-        ASSERT(strictMode());
+        ASSERT(m_strictMode);
         m_writtenVariables.add(ident->impl());
     }
+
+    void preventNewDecls() { m_allowsNewDecls = false; }
+    bool allowsNewDecls() const { return m_allowsNewDecls; }
 
     bool declareParameter(const Identifier* ident)
@@ -227 +233 @@
         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
         if (isArguments)
-            setFlags(ShadowsArgumentsFlag);
+            m_shadowsArguments = true;
         return isValidStrictMode;
     }
 
-    void useVariable(const Identifier* ident)
-    {
+    void useVariable(const Identifier* ident, bool isEval)
+    {
+        m_usesEval |= isEval;
         m_usedVariables.add(ident->ustring().impl());
     }
 
+    void setNeedsFullActivation() { m_needsFullActivation = true; }
+
     bool collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
     {
-        setFlags(nestedScope->usesFlags());
+        if (nestedScope->m_usesEval)
+            m_usesEval = true;
         IdentifierSet::iterator end = nestedScope->m_usedVariables.end();
         for (IdentifierSet::iterator ptr = nestedScope->m_usedVariables.begin(); ptr != end; ++ptr) {
@@ -270 +280 @@
     void getCapturedVariables(IdentifierSet& capturedVariables)
     {
-        if (usesEval()) {
+        if (m_needsFullActivation || m_usesEval) {
             capturedVariables.swap(m_declaredVariables);
             return;
@@ -280 +290 @@
         }
     }
+    void setStrictMode() { m_strictMode = true; }
+    bool strictMode() const { return m_strictMode; }
+    bool isValidStrictMode() const { return m_isValidStrictMode; }
+    bool shadowsArguments() const { return m_shadowsArguments; }
+
     void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<StringImpl> >& vector)
     {
@@ -293 +308 @@
     void saveFunctionInfo(SourceProviderCacheItem* info)
     {
-        ASSERT(isFunction());
-        info->scopeFlags = m_scopeFlags;
+        ASSERT(m_isFunction);
+        info->usesEval = m_usesEval;
+        info->strictMode = m_strictMode;
+        info->needsFullActivation = m_needsFullActivation;
         copyCapturedVariablesToVector(m_writtenVariables, info->writtenVariables);
         copyCapturedVariablesToVector(m_usedVariables, info->usedVariables);
@@ -301 +318 @@
     void restoreFunctionInfo(const SourceProviderCacheItem* info)
     {
-        ASSERT(isFunction());
-        m_scopeFlags |= info->scopeFlags;
+        ASSERT(m_isFunction);
+        m_usesEval = info->usesEval;
+        m_strictMode = info->strictMode;
+        m_needsFullActivation = info->needsFullActivation;
         unsigned size = info->usedVariables.size();
         for (unsigned i = 0; i < size; ++i)
@@ -313 +332 @@
 private:
     const JSGlobalData* m_globalData;
-    ScopeFlags m_scopeFlags;
+    bool m_shadowsArguments : 1;
+    bool m_usesEval : 1;
+    bool m_needsFullActivation : 1;
+    bool m_allowsNewDecls : 1;
+    bool m_strictMode : 1;
+    bool m_isFunction : 1;
+    bool m_isFunctionBoundary : 1;
     bool m_isValidStrictMode : 1;
     int m_loopDepth;
@@ -403 +428 @@
     };
 
-    ALWAYS_INLINE ScopeRef currentScope()
+    ScopeRef currentScope()
     {
         return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
     }
     
-    ScopeRef pushScope(ScopeFlags scopeFlags)
-    {
-        m_scopeStack.append(Scope(m_globalData, scopeFlags));
+    ScopeRef pushScope()
+    {
+        bool isFunction = false;
+        bool isStrict = false;
+        if (!m_scopeStack.isEmpty()) {
+            isStrict = m_scopeStack.last().strictMode();
+            isFunction = m_scopeStack.last().isFunction();
+        }
+        m_scopeStack.append(Scope(m_globalData, isFunction, isStrict));
         return currentScope();
     }
@@ -462 +493 @@
 
     void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*, 
-                          ParserArenaData<DeclarationStacks::FunctionStack>*, ScopeFlags,
+                          ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures,
                           int, int, IdentifierSet&);
 
@@ -793 +824 @@
     }
     
-    ALWAYS_INLINE void startLoop() { currentScope()->startLoop(); }
-    ALWAYS_INLINE void endLoop() { currentScope()->endLoop(); }
-    ALWAYS_INLINE void startSwitch() { currentScope()->startSwitch(); }
-    ALWAYS_INLINE void endSwitch() { currentScope()->endSwitch(); }
-    ALWAYS_INLINE bool strictMode() { return currentScope()->strictMode(); }
-    ALWAYS_INLINE bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
-    ALWAYS_INLINE bool declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
+    void startLoop() { currentScope()->startLoop(); }
+    void endLoop() { currentScope()->endLoop(); }
+    void startSwitch() { currentScope()->startSwitch(); }
+    void endSwitch() { currentScope()->endSwitch(); }
+    void setStrictMode() { currentScope()->setStrictMode(); }
+    bool strictMode() { return currentScope()->strictMode(); }
+    bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
+    bool declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
     bool breakIsValid()
     {
@@ -918 +950 @@
     ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
     IdentifierSet m_capturedVariables;
-    ScopeFlags m_scopeFlags;
+    CodeFeatures m_features;
     int m_numConstants;
     
@@ -979 +1011 @@
                                     m_capturedVariables,
                                     *m_source,
-                                    m_scopeFlags,
+                                    m_features,
                                     m_numConstants);
         result->setLoc(m_source->firstLine(), m_lastLine);