Changeset 110287 in webkit for trunk/Source/JavaScriptCore/parser/Parser.cpp

Timestamp:

Mar 9, 2012, 4:06:48 AM (13 years ago)

Author:

[email protected]

Message:

Refactor code feature analysis in the parser
​https://bugs.webkit.org/show_bug.cgi?id=79112

Reviewed by Geoffrey Garen.

This commit refactors the parser to more uniformly propagate flag
bits down and up the parse process, as the parser descends and
returns into nested blocks. Some flags get passed town to
subscopes, some apply to specific scopes only, and some get
unioned up after parsing subscopes.

The goal is to eventually be very precise with scoping
information, once we have block scopes: one block scope might use
`eval', which would require the emission of a symbol table within
that block and containing blocks, whereas another block in the
same function might not, allowing us to not emit a symbol table.

• parser/Nodes.h:

(JSC::ScopeFlags): Rename from CodeFeatures.
(JSC::ScopeNode::addScopeFlags):
(JSC::ScopeNode::scopeFlags): New accessors for m_scopeFlags.
(JSC::ScopeNode::isStrictMode):
(JSC::ScopeNode::usesEval):
(JSC::ScopeNode::usesArguments):
(JSC::ScopeNode::setUsesArguments):
(JSC::ScopeNode::usesThis):
(JSC::ScopeNode::needsActivationForMoreThanVariables):
(JSC::ScopeNode::needsActivation): Refactor these accessors to
operate on the m_scopeFlags member.
(JSC::ScopeNode::source):
(JSC::ScopeNode::sourceURL):
(JSC::ScopeNode::sourceID): Shuffle these definitions around; no
semantic change.
(JSC::ScopeNode::ScopeNode)
(JSC::ProgramNode::ProgramNode)
(JSC::EvalNode::EvalNode)
(JSC::FunctionBodyNode::FunctionBodyNode): Have these constructors
take a ScopeFlags as an argument, instead of a bool inStrictContext.

• parser/Nodes.cpp:

(JSC::ScopeNode::ScopeNode):
(JSC::ProgramNode::ProgramNode):
(JSC::ProgramNode::create):
(JSC::EvalNode::EvalNode):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::FunctionBodyNode):
(JSC::FunctionBodyNode::create): Adapt constructors to change.

• parser/ASTBuilder.h:

(JSC::ASTBuilder::ASTBuilder):
(JSC::ASTBuilder::thisExpr):
(JSC::ASTBuilder::createResolve):
(JSC::ASTBuilder::createFunctionBody):
(JSC::ASTBuilder::createFuncDeclStatement):
(JSC::ASTBuilder::createTryStatement):
(JSC::ASTBuilder::createWithStatement):
(JSC::ASTBuilder::addVar):
(JSC::ASTBuilder::Scope::Scope):
(Scope):
(ASTBuilder):
(JSC::ASTBuilder::makeFunctionCallNode): Don't track scope
features here. Instead rely on the base Parser mechanism to track
features.

• parser/NodeInfo.h (NodeInfo, NodeDeclarationInfo): "ScopeFlags".

• parser/Parser.h:

(JSC::Scope::Scope): Manage scope through flags, not
bit-booleans. This lets us uniformly propagate them up and down.
(JSC::Scope::declareWrite):
(JSC::Scope::declareParameter):
(JSC::Scope::useVariable):
(JSC::Scope::collectFreeVariables):
(JSC::Scope::getCapturedVariables):
(JSC::Scope::saveFunctionInfo):
(JSC::Scope::restoreFunctionInfo):
(JSC::Parser::pushScope): Adapt to use scope flags and their
accessors instead of bit-booleans.

• parser/Parser.cpp:

(JSC::::Parser):
(JSC::::parseInner):
(JSC::::didFinishParsing):
(JSC::::parseSourceElements):
(JSC::::parseVarDeclarationList):
(JSC::::parseConstDeclarationList):
(JSC::::parseWithStatement):
(JSC::::parseTryStatement):
(JSC::::parseFunctionBody):
(JSC::::parseFunctionInfo):
(JSC::::parseFunctionDeclaration):
(JSC::::parsePrimaryExpression): Hoist some of the flag handling
out of the "context" (ASTBuilder or SyntaxChecker) and to here.
Does not seem to have a performance impact.

• parser/SourceProviderCacheItem.h (SourceProviderCacheItem):

Cache the scopeflags.

• parser/SyntaxChecker.h: Remove evalCount() decl.

• runtime/Executable.cpp:

(JSC::EvalExecutable::compileInternal):
(JSC::ProgramExecutable::compileInternal):
(JSC::FunctionExecutable::produceCodeBlockFor):

• runtime/Executable.h:

(JSC::ScriptExecutable::ScriptExecutable):
(JSC::ScriptExecutable::usesEval):
(JSC::ScriptExecutable::usesArguments):
(JSC::ScriptExecutable::needsActivation):
(JSC::ScriptExecutable::isStrictMode):
(JSC::ScriptExecutable::recordParse):
(ScriptExecutable): ScopeFlags, not features.

File:

• trunk/Source/JavaScriptCore/parser/Parser.cpp (modified) (17 diffs)

trunk/Source/JavaScriptCore/parser/Parser.cpp

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