Changeset 116372 in webkit for trunk/Source/JavaScriptCore/parser

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.

Location:

trunk/Source/JavaScriptCore/parser

Files:

• ASTBuilder.h (modified) (14 diffs)
• NodeInfo.h (modified) (2 diffs)
• Nodes.cpp (modified) (6 diffs)
• Nodes.h (modified) (8 diffs)
• Parser.cpp (modified) (17 diffs)
• Parser.h (modified) (15 diffs)
• SourceProviderCacheItem.h (modified) (1 diff)
• SyntaxChecker.h (modified) (1 diff)

trunk/Source/JavaScriptCore/parser/ASTBuilder.h

@@ -78 +78 @@
         , m_sourceCode(sourceCode)
         , m_scope(globalData)
+        , m_evalCount(0)
     {
     }
@@ -119 +120 @@
     ParserArenaData<DeclarationStacks::VarStack>* varDeclarations() { return m_scope.m_varDeclarations; }
     ParserArenaData<DeclarationStacks::FunctionStack>* funcDeclarations() { return m_scope.m_funcDeclarations; }
+    int features() const { return m_scope.m_features; }
     int numConstants() const { return m_scope.m_numConstants; }
 
@@ -151 +153 @@
         return new (m_globalData) VoidNode(lineNumber, expr);
     }
-    ExpressionNode* thisExpr(int lineNumber) { return new (m_globalData) ThisNode(lineNumber); }
-    ExpressionNode* createResolve(int lineNumber, const Identifier* ident, int start) { return new (m_globalData) ResolveNode(lineNumber, *ident, start); }
+    ExpressionNode* thisExpr(int lineNumber)
+    {
+        usesThis();
+        return new (m_globalData) ThisNode(lineNumber);
+    }
+    ExpressionNode* createResolve(int lineNumber, const Identifier* ident, int start)
+    {
+        if (m_globalData->propertyNames->arguments == *ident)
+            usesArguments();
+        return new (m_globalData) ResolveNode(lineNumber, *ident, start);
+    }
     ExpressionNode* createObjectLiteral(int lineNumber) { return new (m_globalData) ObjectLiteralNode(lineNumber); }
     ExpressionNode* createObjectLiteral(int lineNumber, PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(lineNumber, properties); }
@@ -253 +264 @@
     }
 
-    FunctionBodyNode* createFunctionBody(int lineNumber, ScopeFlags scopeFlags)
-    {
-        return FunctionBodyNode::create(m_globalData, lineNumber, scopeFlags);
+    FunctionBodyNode* createFunctionBody(int lineNumber, bool inStrictContext)
+    {
+        return FunctionBodyNode::create(m_globalData, lineNumber, inStrictContext);
     }
     
@@ -302 +313 @@
     {
         FuncDeclNode* decl = new (m_globalData) FuncDeclNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
+        if (*name == m_globalData->propertyNames->arguments)
+            usesArguments();
         m_scope.m_funcDeclarations->data.append(decl->body());
         body->setLoc(bodyStartLine, bodyEndLine);
@@ -414 +427 @@
     {
         TryNode* result = new (m_globalData) TryNode(lineNumber, tryBlock, *ident, catchBlock, finallyBlock);
+        if (catchBlock)
+            usesCatch();
         result->setLoc(startLine, endLine);
         return result;
@@ -449 +464 @@
     StatementNode* createWithStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
     {
+        usesWith();
         WithNode* result = new (m_globalData) WithNode(lineNumber, expr, statement, end, end - start);
         result->setLoc(startLine, endLine);
@@ -491 +507 @@
     void addVar(const Identifier* ident, int attrs)
     {
+        if (m_globalData->propertyNames->arguments == *ident)
+            usesArguments();
         m_scope.m_varDeclarations->data.append(std::make_pair(ident, attrs));
     }
@@ -505 +523 @@
     }
 
+    int evalCount() const { return m_evalCount; }
+
     void appendBinaryExpressionInfo(int& operandStackDepth, ExpressionNode* current, int exprStart, int lhs, int rhs, bool hasAssignments)
     {
@@ -591 +611 @@
             : m_varDeclarations(new (globalData) ParserArenaData<DeclarationStacks::VarStack>)
             , m_funcDeclarations(new (globalData) ParserArenaData<DeclarationStacks::FunctionStack>)
+            , m_features(0)
             , m_numConstants(0)
         {
@@ -596 +617 @@
         ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
         ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
+        int m_features;
         int m_numConstants;
     };
@@ -605 +627 @@
 
     void incConstants() { m_scope.m_numConstants++; }
+    void usesThis() { m_scope.m_features |= ThisFeature; }
+    void usesCatch() { m_scope.m_features |= CatchFeature; }
+    void usesArguments() { m_scope.m_features |= ArgumentsFeature; }
+    void usesWith() { m_scope.m_features |= WithFeature; }
+    void usesEval() 
+    {
+        m_evalCount++;
+        m_scope.m_features |= EvalFeature;
+    }
     ExpressionNode* createNumber(int lineNumber, double d)
     {
@@ -617 +648 @@
     Vector<pair<int, int>, 10> m_binaryOperatorStack;
     Vector<pair<int, int>, 10> m_unaryTokenStack;
+    int m_evalCount;
 };
 
@@ -766 +798 @@
         ResolveNode* resolve = static_cast<ResolveNode*>(func);
         const Identifier& identifier = resolve->identifier();
-        if (identifier == m_globalData->propertyNames->eval)
+        if (identifier == m_globalData->propertyNames->eval) {
+            usesEval();
             return new (m_globalData) EvalFunctionCallNode(lineNumber, args, divot, divot - start, end - divot);
+        }
         return new (m_globalData) FunctionCallResolveNode(lineNumber, identifier, args, divot, divot - start, end - divot);
     }

trunk/Source/JavaScriptCore/parser/NodeInfo.h

@@ -27 +27 @@
     template <typename T> struct NodeInfo {
         T m_node;
-        ScopeFlags m_scopeFlags;
+        CodeFeatures m_features;
         int m_numConstants;
     };
@@ -45 +45 @@
         ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
         ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
-        ScopeFlags m_scopeFlags;
+        CodeFeatures m_features;
         int m_numConstants;
     };

trunk/Source/JavaScriptCore/parser/Nodes.cpp

@@ -76 +76 @@
 // ------------------------------ ScopeNode -----------------------------
 
-ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, ScopeFlags scopeFlags)
+ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
     : StatementNode(lineNumber)
     , ParserArenaRefCounted(globalData)
-    , m_scopeFlags(scopeFlags)
+    , m_features(inStrictContext ? StrictModeFeature : NoFeatures)
     , m_numConstants(0)
     , m_statements(0)
@@ -85 +85 @@
 }
 
-ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, ScopeFlags scopeFlags, int numConstants)
+ScopeNode::ScopeNode(JSGlobalData* globalData, int lineNumber, const SourceCode& source, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, CodeFeatures features, int numConstants)
     : StatementNode(lineNumber)
     , ParserArenaRefCounted(globalData)
-    , m_scopeFlags(scopeFlags)
+    , m_features(features)
     , m_source(source)
     , m_numConstants(numConstants)
@@ -108 +108 @@
 // ------------------------------ ProgramNode -----------------------------
 
-inline ProgramNode::ProgramNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, ScopeFlags scopeFlags, int numConstants)
-    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, scopeFlags, numConstants)
+inline ProgramNode::ProgramNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
 
-PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, ScopeFlags scopeFlags, int numConstants)
+PassRefPtr<ProgramNode> ProgramNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
 {
-    RefPtr<ProgramNode> node = new ProgramNode(globalData, lineNumber, children, varStack, funcStack,  capturedVariables, source, scopeFlags, numConstants);
+    RefPtr<ProgramNode> node = new ProgramNode(globalData, lineNumber, children, varStack, funcStack,  capturedVariables, source, features, numConstants);
 
     ASSERT(node->m_arena.last() == node);
@@ -126 +126 @@
 // ------------------------------ EvalNode -----------------------------
 
-inline EvalNode::EvalNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, ScopeFlags scopeFlags, int numConstants)
-    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, scopeFlags, numConstants)
+inline EvalNode::EvalNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, source, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
 
-PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, ScopeFlags scopeFlags, int numConstants)
+PassRefPtr<EvalNode> EvalNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& source, CodeFeatures features, int numConstants)
 {
-    RefPtr<EvalNode> node = new EvalNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, source, scopeFlags, numConstants);
+    RefPtr<EvalNode> node = new EvalNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, source, features, numConstants);
 
     ASSERT(node->m_arena.last() == node);
@@ -150 +150 @@
 }
 
-inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, ScopeFlags scopeFlags)
-    : ScopeNode(globalData, lineNumber, scopeFlags)
+inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
+    : ScopeNode(globalData, lineNumber, inStrictContext)
 {
 }
 
-inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, ScopeFlags scopeFlags, int numConstants)
-    : ScopeNode(globalData, lineNumber, sourceCode, children, varStack, funcStack, capturedVariables, scopeFlags, numConstants)
+inline FunctionBodyNode::FunctionBodyNode(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
+    : ScopeNode(globalData, lineNumber, sourceCode, children, varStack, funcStack, capturedVariables, features, numConstants)
 {
 }
@@ -173 +173 @@
 }
 
-FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, ScopeFlags scopeFlags)
+FunctionBodyNode* FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, bool inStrictContext)
 {
-    return new FunctionBodyNode(globalData, lineNumber, scopeFlags);
+    return new FunctionBodyNode(globalData, lineNumber, inStrictContext);
 }
 
-PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, ScopeFlags scopeFlags, int numConstants)
+PassRefPtr<FunctionBodyNode> FunctionBodyNode::create(JSGlobalData* globalData, int lineNumber, SourceElements* children, VarStack* varStack, FunctionStack* funcStack, IdentifierSet& capturedVariables, const SourceCode& sourceCode, CodeFeatures features, int numConstants)
 {
-    RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, sourceCode, scopeFlags, numConstants);
+    RefPtr<FunctionBodyNode> node = new FunctionBodyNode(globalData, lineNumber, children, varStack, funcStack, capturedVariables, sourceCode, features, numConstants);
 
     ASSERT(node->m_arena.last() == node);

trunk/Source/JavaScriptCore/parser/Nodes.h

@@ -48 +48 @@
     class ScopeNode;
 
-    typedef unsigned short ScopeFlags;
-
-    const ScopeFlags NoScopeFlags = 0;
-
-    // Some scope flags propagate down the parse tree from parent scopes, like
-    // strict mode. They are modal to an entire set of nested scopes.
-    const ScopeFlags StrictModeFlag = 1 << 0;
-    const ScopeFlags FunctionModeFlag = 1 << 1;
-    const ScopeFlags AllScopeModeFlags = StrictModeFlag | FunctionModeFlag;
-
-    // Some scope flags refer only to a specific scope, and don't propagate down
-    // or up.
-    const ScopeFlags BlockScopeFlag = 1 << 4;
-    const ScopeFlags AllScopeKindFlags = BlockScopeFlag;
-
-    // Other flags reflect uses within nested scopes, and so propagate up
-    // from the leaves.
-    const ScopeFlags UsesEvalFlag = 1 << 8;
-    const ScopeFlags UsesArgumentsFlag = 1 << 9;
-    const ScopeFlags UsesWithFlag = 1 << 10;
-    const ScopeFlags UsesCatchFlag = 1 << 11;
-    const ScopeFlags UsesThisFlag = 1 << 12;
-    const ScopeFlags ShadowsArgumentsFlag = 1 << 13;
-    const ScopeFlags AllScopeUsesFlags = UsesEvalFlag | UsesArgumentsFlag | UsesWithFlag | UsesCatchFlag | UsesThisFlag | ShadowsArgumentsFlag;
+    typedef unsigned CodeFeatures;
+
+    const CodeFeatures NoFeatures = 0;
+    const CodeFeatures EvalFeature = 1 << 0;
+    const CodeFeatures ArgumentsFeature = 1 << 1;
+    const CodeFeatures WithFeature = 1 << 2;
+    const CodeFeatures CatchFeature = 1 << 3;
+    const CodeFeatures ThisFeature = 1 << 4;
+    const CodeFeatures StrictModeFeature = 1 << 5;
+    const CodeFeatures ShadowsArgumentsFeature = 1 << 6;
     
+    const CodeFeatures AllFeatures = EvalFeature | ArgumentsFeature | WithFeature | CatchFeature | ThisFeature | StrictModeFeature | ShadowsArgumentsFeature;
+
     enum Operator {
         OpEqual,
@@ -1396 +1384 @@
         typedef DeclarationStacks::FunctionStack FunctionStack;
 
-        ScopeNode(JSGlobalData*, int, ScopeFlags);
-        ScopeNode(JSGlobalData*, int, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, ScopeFlags, int numConstants);
+        ScopeNode(JSGlobalData*, int, bool inStrictContext);
+        ScopeNode(JSGlobalData*, int, const SourceCode&, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, CodeFeatures, int numConstants);
 
         using ParserArenaRefCounted::operator new;
@@ -1410 +1398 @@
         }
 
+        const SourceCode& source() const { return m_source; }
+        const UString& sourceURL() const { return m_source.provider()->url(); }
+        intptr_t sourceID() const { return m_source.provider()->asID(); }
+
+        void setFeatures(CodeFeatures features) { m_features = features; }
+        CodeFeatures features() { return m_features; }
+
+        bool usesEval() const { return m_features & EvalFeature; }
+        bool usesArguments() const { return (m_features & ArgumentsFeature) && !(m_features & ShadowsArgumentsFeature); }
+        bool isStrictMode() const { return m_features & StrictModeFeature; }
+        void setUsesArguments() { m_features |= ArgumentsFeature; }
+        bool usesThis() const { return m_features & ThisFeature; }
+        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()); }
-
-        void addScopeFlags(ScopeFlags scopeFlags) { m_scopeFlags |= scopeFlags; }
-        ScopeFlags scopeFlags() const { return m_scopeFlags; }
-
-        bool isStrictMode() const { return m_scopeFlags & StrictModeFlag; }
-        bool usesEval() const { return m_scopeFlags & UsesEvalFlag; }
-        bool usesArguments() const { return (m_scopeFlags & UsesArgumentsFlag) && !(m_scopeFlags & ShadowsArgumentsFlag); }
-        void setUsesArguments() { m_scopeFlags |= UsesArgumentsFlag; }
-        bool usesThis() const { return m_scopeFlags & UsesThisFlag; }
-
-        bool needsActivationForMoreThanVariables() const { return m_scopeFlags & (UsesEvalFlag | UsesWithFlag | UsesCatchFlag); }
-        bool needsActivation() const { return hasCapturedVariables() || needsActivationForMoreThanVariables(); }
-
-        const SourceCode& source() const { return m_source; }
-        const UString& sourceURL() const { return m_source.provider()->url(); }
-        intptr_t sourceID() const { return m_source.provider()->asID(); }
 
         VarStack& varStack() { return m_varStack; }
@@ -1449 +1435 @@
 
     private:
-        ScopeFlags m_scopeFlags;
+        CodeFeatures m_features;
         SourceCode m_source;
         VarStack m_varStack;
@@ -1461 +1447 @@
     public:
         static const bool isFunctionNode = false;
-        static PassRefPtr<ProgramNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        static PassRefPtr<ProgramNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         static const bool scopeIsFunction = false;
 
     private:
-        ProgramNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        ProgramNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1474 +1460 @@
     public:
         static const bool isFunctionNode = false;
-        static PassRefPtr<EvalNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        static PassRefPtr<EvalNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         static const bool scopeIsFunction = false;
 
     private:
-        EvalNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        EvalNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         virtual RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0);
@@ -1496 +1482 @@
     public:
         static const bool isFunctionNode = true;
-        static FunctionBodyNode* create(JSGlobalData*, int, ScopeFlags);
-        static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        static FunctionBodyNode* create(JSGlobalData*, int, bool isStrictMode);
+        static PassRefPtr<FunctionBodyNode> create(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         FunctionParameters* parameters() const { return m_parameters.get(); }
@@ -1514 +1500 @@
 
     private:
-        FunctionBodyNode(JSGlobalData*, int, ScopeFlags);
-        FunctionBodyNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, ScopeFlags, int numConstants);
+        FunctionBodyNode(JSGlobalData*, int, bool inStrictContext);
+        FunctionBodyNode(JSGlobalData*, int, SourceElements*, VarStack*, FunctionStack*, IdentifierSet&, const SourceCode&, CodeFeatures, int numConstants);
 
         Identifier m_ident;

trunk/Source/JavaScriptCore/parser/Parser.cpp

@@ -63 +63 @@
 
     m_functionCache = source.provider()->cache();
-    ScopeFlags scopeFlags = NoScopeFlags;
+    ScopeRef scope = pushScope();
+    if (parserMode == JSParseFunctionCode)
+        scope->setIsFunction();
     if (strictness == JSParseStrict)
-        scopeFlags |= StrictModeFlag;
-    if (parserMode == JSParseFunctionCode)
-        scopeFlags |= FunctionModeFlag;
-    ScopeRef scope = pushScope(scopeFlags);
+        scope->setStrictMode();
     if (parameters) {
         for (unsigned i = 0; i < parameters->size(); i++)
@@ -98 +97 @@
     IdentifierSet capturedVariables;
     scope->getCapturedVariables(capturedVariables);
-    ScopeFlags scopeFlags = scope->modeFlags() | scope->usesFlags();
+    CodeFeatures features = context.features();
+    if (scope->strictMode())
+        features |= StrictModeFeature;
+    if (scope->shadowsArguments())
+        features |= ShadowsArgumentsFeature;
     unsigned functionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
     if (functionCacheSize != oldFunctionCacheSize)
         m_lexer->sourceProvider()->notifyCacheSizeChanged(functionCacheSize - oldFunctionCacheSize);
 
-    didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), scopeFlags,
+    didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,
                      m_lastLine, context.numConstants(), capturedVariables);
 
@@ -111 +114 @@
 template <typename LexerType>
 void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack, 
-                              ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, ScopeFlags scopeFlags, int lastLine, int numConstants, IdentifierSet& capturedVars)
+                              ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int lastLine, int numConstants, IdentifierSet& capturedVars)
 {
     m_sourceElements = sourceElements;
@@ -117 +120 @@
     m_funcDeclarations = funcStack;
     m_capturedVariables.swap(capturedVars);
-    m_scopeFlags = scopeFlags;
+    m_features = features;
     m_lastLine = lastLine;
     m_numConstants = numConstants;
@@ -145 +148 @@
                 // "use strict" must be the exact literal without escape sequences or line continuation.
                 if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_globalData->propertyNames->useStrictIdentifier == *directive) {
-                    currentScope()->setFlags(StrictModeFlag);
+                    setStrictMode();
                     hasSetStrict = true;
                     failIfFalse(isValidStrictMode());
@@ -253 +256 @@
         bool hasInitializer = match(EQUAL);
         failIfFalseIfStrictWithNameAndMessage(declareVariable(name), "Cannot declare a variable named", name->impl(), "in strict mode.");
-        if (m_globalData->propertyNames->arguments == *name)
-            currentScope()->setFlags(UsesArgumentsFlag);
         context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
         if (hasInitializer) {
@@ -289 +290 @@
         bool hasInitializer = match(EQUAL);
         declareVariable(name);
-        if (m_globalData->propertyNames->arguments == *name)
-            currentScope()->setFlags(UsesArgumentsFlag);
         context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
         TreeExpression initializer = 0;
@@ -513 +512 @@
     ASSERT(match(WITH));
     failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
-    currentScope()->setFlags(UsesWithFlag);
+    currentScope()->setNeedsFullActivation();
     int startLine = tokenLine();
     next();
@@ -528 +527 @@
     failIfFalse(statement);
     
-    currentScope()->setFlags(UsesWithFlag);
     return context.createWithStatement(m_lexer->lastLineNumber(), expr, statement, start, end, startLine, endLine);
 }
@@ -617 +615 @@
     
     if (match(CATCH)) {
-        currentScope()->setFlags(UsesCatchFlag);
+        currentScope()->setNeedsFullActivation();
         next();
         consumeOrFail(OPENPAREN);
@@ -623 +621 @@
         ident = m_token.m_data.ident;
         next();
-        AutoPopScopeRef catchScope(this, pushScope(currentScope()->modeFlags()));
+        AutoPopScopeRef catchScope(this, pushScope());
         failIfFalseIfStrictWithNameAndMessage(declareVariable(ident), "Cannot declare a variable named", ident->impl(), "in strict mode");
-        currentScope()->setFlags(BlockScopeFlag | UsesCatchFlag);
+        catchScope->preventNewDecls();
         consumeOrFail(CLOSEPAREN);
         matchOrFail(OPENBRACE);
@@ -762 +760 @@
 {
     if (match(CLOSEBRACE))
-        return context.createFunctionBody(m_lexer->lastLineNumber(), currentScope()->modeFlags());
+        return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());
     DepthManager statementDepth(&m_statementDepth);
     m_statementDepth = 0;
@@ -773 +771 @@
 template <FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, int& openBracePos, int& closeBracePos, int& bodyStartLine)
 {
-    AutoPopScopeRef functionScope(this, pushScope(currentScope()->modeFlags() | FunctionModeFlag));
+    AutoPopScopeRef functionScope(this, pushScope());
+    functionScope->setIsFunction();
     if (match(IDENT)) {
         name = m_token.m_data.ident;
@@ -795 +794 @@
     if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
         // If we're in a strict context, the cached function info must say it was strict too.
-        ASSERT(!strictMode() || (cachedInfo->scopeFlags & StrictModeFlag));
-        body = context.createFunctionBody(m_lexer->lastLineNumber(), cachedInfo->scopeFlags);
+        ASSERT(!strictMode() || cachedInfo->strictMode);
+        body = context.createFunctionBody(m_lexer->lastLineNumber(), cachedInfo->strictMode);
         
         functionScope->restoreFunctionInfo(cachedInfo);
@@ -856 +855 @@
     failIfFalse(name);
     failIfFalseIfStrict(declareVariable(name));
-    if (*name == m_globalData->propertyNames->arguments)
-        currentScope()->setFlags(UsesArgumentsFlag);
     return context.createFuncDeclStatement(m_lexer->lastLineNumber(), name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
 }
@@ -1417 +1414 @@
     case THISTOKEN: {
         next();
-        currentScope()->setFlags(UsesThisFlag);
         return context.thisExpr(m_lexer->lastLineNumber());
     }
@@ -1424 +1420 @@
         const Identifier* ident = m_token.m_data.ident;
         next();
-        if (m_globalData->propertyNames->eval == *ident)
-            currentScope()->setFlags(UsesEvalFlag);
-        else if (m_globalData->propertyNames->arguments == *ident)
-            currentScope()->setFlags(UsesArgumentsFlag);
-        currentScope()->useVariable(ident);
+        currentScope()->useVariable(ident, m_globalData->propertyNames->eval == *ident);
         m_lastIdentifier = ident;
         return context.createResolve(m_lexer->lastLineNumber(), ident, start);

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);

trunk/Source/JavaScriptCore/parser/SourceProviderCacheItem.h

@@ -62 +62 @@
     int closeBraceLine;
     int closeBracePos;
-    unsigned short scopeFlags;
+    bool usesEval;
+    bool strictMode;
+    bool needsFullActivation;
     Vector<RefPtr<StringImpl> > usedVariables;
     Vector<RefPtr<StringImpl> > writtenVariables;

trunk/Source/JavaScriptCore/parser/SyntaxChecker.h

@@ -221 +221 @@
     void addVar(const Identifier*, bool) { }
     int combineCommaNodes(int, int, int) { return 1; }
+    int evalCount() const { return 0; }
     void appendBinaryExpressionInfo(int& operandStackDepth, int expr, int, int, int, bool)
     {