Changeset 69516 in webkit for trunk/JavaScriptCore/parser/JSParser.cpp

Timestamp:

Oct 11, 2010, 12:12:29 PM (15 years ago)

Author:

[email protected]

Message:

2010-10-01 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

[ES5] Implement strict mode
​https://bugs.webkit.org/show_bug.cgi?id=10701

Initial strict mode implementation. This is the simplest
implementation that could possibly work and adds (hopefully)
all of the restrictions required by strict mode. There are
a number of inefficiencies, especially in the handling of
arguments and eval as smart implementations would make this
patch more complicated.

The SyntaxChecker AST builder has become somewhat more complex
as strict mode does require more parse tree information to
validate the syntax.

Summary of major changes to the parser:

• We track when we enter strict mode (this may come as a surprise)
• Strict mode actually requires a degree of AST knowledge to validate so the SyntaxChecker now produces values that can be used to distinguish "node" types.
• We now track variables that are written to. We do this to statically identify writes to global properties that don't exist and abort at that point. This should actually make it possible to optimise some other cases in the future but for now it's purely for validity checking. Currently writes are only tracked in strict mode code.
• Labels are now tracked as it is now a syntax error to jump to a label that does not exist (or to use break, continue, or return in a context where they would be invalid).

Runtime changes:

• In order to get correct hanlding of the Arguments object all strict mode functions that reference arguments create and tearoff the arguments object on entry. This is not strictly necessary but was the least work necessary to get the correct behaviour.
• PutPropertySlot now tracks whether it is being used for a strict mode write, and if so Object::put will throw when a write can't be completed.
• StrictEvalActivation was added as an "activation" object for strict mode eval (so that strict eval does not introduce new variables into the containing scope).

• CMakeLists.txt:
• GNUmakefile.am:
• JavaScriptCore.exp:
• JavaScriptCore.pro:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): (JSC::CodeBlock::CodeBlock): (JSC::CodeBlock::reparseForExceptionInfoIfNecessary):
• bytecode/CodeBlock.h: (JSC::CodeBlock::isStrictMode):
• bytecode/EvalCodeCache.h: (JSC::EvalCodeCache::get):
• bytecode/Opcode.h:
• bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::BytecodeGenerator): (JSC::BytecodeGenerator::createArgumentsIfNecessary): (JSC::BytecodeGenerator::emitReturn):
• bytecompiler/BytecodeGenerator.h: (JSC::BytecodeGenerator::isStrictMode): (JSC::BytecodeGenerator::makeFunction):
• debugger/Debugger.cpp: (JSC::evaluateInGlobalCallFrame):
• debugger/DebuggerCallFrame.cpp: (JSC::DebuggerCallFrame::evaluate):
• interpreter/Interpreter.cpp: (JSC::Interpreter::callEval): (JSC::Interpreter::unwindCallFrame): (JSC::Interpreter::execute): (JSC::Interpreter::privateExecute):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases):
• jit/JIT.h:
• jit/JITOpcodes.cpp: (JSC::JIT::emit_op_get_pnames): (JSC::JIT::emit_op_convert_this_strict): (JSC::JIT::emitSlow_op_convert_this_strict):
• jit/JITOpcodes32_64.cpp: (JSC::JIT::emit_op_get_pnames):
• jit/JITStubs.cpp: (JSC::DEFINE_STUB_FUNCTION):
• jit/JITStubs.h:
• parser/ASTBuilder.h: (JSC::ASTBuilder::createFunctionBody): (JSC::ASTBuilder::isResolve):
• parser/JSParser.cpp: (JSC::JSParser::next): (JSC::JSParser::startLoop): (JSC::JSParser::endLoop): (JSC::JSParser::startSwitch): (JSC::JSParser::endSwitch): (JSC::JSParser::setStrictMode): (JSC::JSParser::strictMode): (JSC::JSParser::isValidStrictMode): (JSC::JSParser::declareParameter): (JSC::JSParser::breakIsValid): (JSC::JSParser::pushLabel): (JSC::JSParser::popLabel): (JSC::JSParser::hasLabel): (JSC::JSParser::DepthManager::DepthManager): (JSC::JSParser::DepthManager::~DepthManager): (JSC::JSParser::Scope::Scope): (JSC::JSParser::Scope::startSwitch): (JSC::JSParser::Scope::endSwitch): (JSC::JSParser::Scope::startLoop): (JSC::JSParser::Scope::endLoop): (JSC::JSParser::Scope::inLoop): (JSC::JSParser::Scope::breakIsValid): (JSC::JSParser::Scope::pushLabel): (JSC::JSParser::Scope::popLabel): (JSC::JSParser::Scope::hasLabel): (JSC::JSParser::Scope::isFunction): (JSC::JSParser::Scope::declareVariable): (JSC::JSParser::Scope::declareWrite): (JSC::JSParser::Scope::deleteProperty): (JSC::JSParser::Scope::declareParameter): (JSC::JSParser::Scope::setNeedsFullActivation): (JSC::JSParser::Scope::collectFreeVariables): (JSC::JSParser::Scope::getUncapturedWrittenVariables): (JSC::JSParser::Scope::getDeletedVariables): (JSC::JSParser::Scope::setStrictMode): (JSC::JSParser::Scope::strictMode): (JSC::JSParser::Scope::isValidStrictMode): (JSC::JSParser::pushScope): (JSC::JSParser::popScope): (JSC::JSParser::declareVariable): (JSC::JSParser::declareWrite): (JSC::JSParser::deleteProperty): (JSC::jsParse): (JSC::JSParser::JSParser): (JSC::JSParser::parseProgram): (JSC::JSParser::parseSourceElements): (JSC::JSParser::parseDoWhileStatement): (JSC::JSParser::parseWhileStatement): (JSC::JSParser::parseVarDeclarationList): (JSC::JSParser::parseConstDeclarationList): (JSC::JSParser::parseForStatement): (JSC::JSParser::parseBreakStatement): (JSC::JSParser::parseContinueStatement): (JSC::JSParser::parseReturnStatement): (JSC::JSParser::parseWithStatement): (JSC::JSParser::parseSwitchStatement): (JSC::JSParser::parseSwitchClauses): (JSC::JSParser::parseSwitchDefaultClause): (JSC::JSParser::parseTryStatement): (JSC::JSParser::parseBlockStatement): (JSC::JSParser::parseStatement): (JSC::JSParser::parseFormalParameters): (JSC::JSParser::parseFunctionBody): (JSC::JSParser::parseFunctionInfo): (JSC::JSParser::parseFunctionDeclaration): (JSC::JSParser::parseExpressionOrLabelStatement): (JSC::JSParser::parseIfStatement): (JSC::JSParser::parseExpression): (JSC::JSParser::parseAssignmentExpression): (JSC::JSParser::parseConditionalExpression): (JSC::JSParser::parseBinaryExpression): (JSC::JSParser::parseStrictObjectLiteral): (JSC::JSParser::parsePrimaryExpression): (JSC::JSParser::parseMemberExpression): (JSC::JSParser::parseUnaryExpression):
• parser/JSParser.h:
• parser/Lexer.cpp: (JSC::Lexer::parseString): (JSC::Lexer::lex):
• parser/Lexer.h: (JSC::Lexer::isReparsing):
• parser/Nodes.cpp: (JSC::ScopeNode::ScopeNode): (JSC::FunctionBodyNode::FunctionBodyNode): (JSC::FunctionBodyNode::create):
• parser/Nodes.h: (JSC::ScopeNode::isStrictMode):
• parser/Parser.cpp: (JSC::Parser::parse):
• parser/Parser.h: (JSC::Parser::parse):
• parser/SyntaxChecker.h: (JSC::SyntaxChecker::SyntaxChecker): (JSC::SyntaxChecker::makeFunctionCallNode): (JSC::SyntaxChecker::appendToComma): (JSC::SyntaxChecker::createCommaExpr): (JSC::SyntaxChecker::makeAssignNode): (JSC::SyntaxChecker::makePrefixNode): (JSC::SyntaxChecker::makePostfixNode): (JSC::SyntaxChecker::makeTypeOfNode): (JSC::SyntaxChecker::makeDeleteNode): (JSC::SyntaxChecker::makeNegateNode): (JSC::SyntaxChecker::makeBitwiseNotNode): (JSC::SyntaxChecker::createLogicalNot): (JSC::SyntaxChecker::createUnaryPlus): (JSC::SyntaxChecker::createVoid): (JSC::SyntaxChecker::thisExpr): (JSC::SyntaxChecker::createResolve): (JSC::SyntaxChecker::createObjectLiteral): (JSC::SyntaxChecker::createArray): (JSC::SyntaxChecker::createNumberExpr): (JSC::SyntaxChecker::createString): (JSC::SyntaxChecker::createBoolean): (JSC::SyntaxChecker::createNull): (JSC::SyntaxChecker::createBracketAccess): (JSC::SyntaxChecker::createDotAccess): (JSC::SyntaxChecker::createRegex): (JSC::SyntaxChecker::createNewExpr): (JSC::SyntaxChecker::createConditionalExpr): (JSC::SyntaxChecker::createAssignResolve): (JSC::SyntaxChecker::createFunctionExpr): (JSC::SyntaxChecker::createFunctionBody): (JSC::SyntaxChecker::appendBinaryExpressionInfo): (JSC::SyntaxChecker::operatorStackPop):
• runtime/Arguments.cpp: (JSC::Arguments::createStrictModeCallerIfNecessary): (JSC::Arguments::createStrictModeCalleeIfNecessary): (JSC::Arguments::getOwnPropertySlot): (JSC::Arguments::getOwnPropertyDescriptor): (JSC::Arguments::put): (JSC::Arguments::deleteProperty):
• runtime/Arguments.h: (JSC::Arguments::Arguments):
• runtime/CommonIdentifiers.cpp: (JSC::CommonIdentifiers::CommonIdentifiers):
• runtime/CommonIdentifiers.h:
• runtime/Error.cpp: (JSC::StrictModeTypeErrorFunction::StrictModeTypeErrorFunction): (JSC::StrictModeTypeErrorFunction::constructThrowTypeError): (JSC::StrictModeTypeErrorFunction::getConstructData): (JSC::StrictModeTypeErrorFunction::callThrowTypeError): (JSC::StrictModeTypeErrorFunction::getCallData): (JSC::createTypeErrorFunction):
• runtime/Error.h:
• runtime/Executable.cpp: (JSC::EvalExecutable::EvalExecutable): (JSC::ProgramExecutable::ProgramExecutable): (JSC::FunctionExecutable::FunctionExecutable): (JSC::EvalExecutable::compileInternal): (JSC::ProgramExecutable::checkSyntax): (JSC::ProgramExecutable::compileInternal): (JSC::FunctionExecutable::compileForCallInternal): (JSC::FunctionExecutable::compileForConstructInternal): (JSC::FunctionExecutable::reparseExceptionInfo): (JSC::EvalExecutable::reparseExceptionInfo): (JSC::FunctionExecutable::fromGlobalCode): (JSC::ProgramExecutable::reparseExceptionInfo):
• runtime/Executable.h: (JSC::ScriptExecutable::ScriptExecutable): (JSC::ScriptExecutable::isStrictMode): (JSC::EvalExecutable::create): (JSC::FunctionExecutable::create):
• runtime/JSActivation.cpp: (JSC::JSActivation::toStrictThisObject):
• runtime/JSActivation.h:
• runtime/JSFunction.cpp: (JSC::createDescriptorForThrowingProperty): (JSC::JSFunction::getOwnPropertySlot): (JSC::JSFunction::getOwnPropertyDescriptor): (JSC::JSFunction::put):
• runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData):
• runtime/JSGlobalData.h:
• runtime/JSGlobalObject.cpp: (JSC::JSGlobalObject::reset):
• runtime/JSGlobalObject.h: (JSC::JSGlobalObject::internalFunctionStructure):
• runtime/JSGlobalObjectFunctions.cpp: (JSC::globalFuncEval):
• runtime/JSObject.cpp: (JSC::JSObject::put): (JSC::JSObject::toStrictThisObject): (JSC::throwTypeError):
• runtime/JSObject.h: (JSC::JSObject::isStrictModeFunction): (JSC::JSObject::putDirectInternal): (JSC::JSObject::putDirect): (JSC::JSValue::putDirect): (JSC::JSValue::toStrictThisObject):
• runtime/JSStaticScopeObject.cpp: (JSC::JSStaticScopeObject::toStrictThisObject):
• runtime/JSStaticScopeObject.h:
• runtime/JSValue.h:
• runtime/JSZombie.h: (JSC::JSZombie::toStrictThisObject):
• runtime/PutPropertySlot.h: (JSC::PutPropertySlot::PutPropertySlot): (JSC::PutPropertySlot::isStrictMode):
• runtime/StrictEvalActivation.cpp: Added. (JSC::StrictEvalActivation::StrictEvalActivation): (JSC::StrictEvalActivation::deleteProperty): (JSC::StrictEvalActivation::toThisObject): (JSC::StrictEvalActivation::toStrictThisObject):
• runtime/StrictEvalActivation.h: Added.

2010-10-01 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

[ES5] Implement strict mode
​https://bugs.webkit.org/show_bug.cgi?id=10701

Tests for the many different behaviours we get in strict mode.

• fast/js/basic-strict-mode-expected.txt: Added.
• fast/js/basic-strict-mode.html: Added.
• fast/js/script-tests/basic-strict-mode.js: Added. (testThis): (testGlobalAccess):

2010-10-01 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

[ES5] Implement strict mode
​https://bugs.webkit.org/show_bug.cgi?id=10701

Test: fast/js/basic-strict-mode.html

Override toStrictThisObject on the domwindow so that
it correctly provides the shell object when used as this
in a strict mode function.

• bindings/js/JSDOMWindowBase.cpp: (WebCore::JSDOMWindowBase::toStrictThisObject):
• bindings/js/JSDOMWindowBase.h:

File:

• trunk/JavaScriptCore/parser/JSParser.cpp (modified) (64 diffs)

trunk/JavaScriptCore/parser/JSParser.cpp

@@ -30 +30 @@
 using namespace JSC;
 
+#include "CodeBlock.h"
 #include "JSGlobalData.h"
 #include "NodeInfo.h"
@@ -43 +44 @@
 #define failIfFalse(cond) do { if (!(cond)) fail(); } while (0)
 #define failIfTrue(cond) do { if ((cond)) fail(); } while (0)
+#define failIfTrueIfStrict(cond) do { if ((cond) && strictMode()) fail(); } while (0)
+#define failIfFalseIfStrict(cond) do { if ((!(cond)) && strictMode()) fail(); } while (0)
 #define consumeOrFail(tokenType) do { if (!consume(tokenType)) fail(); } while (0)
 #define matchOrFail(tokenType) do { if (!match(tokenType)) fail(); } while (0)
@@ -68 +71 @@
 class JSParser {
 public:
-    JSParser(Lexer*, JSGlobalData*, FunctionParameters*, SourceProvider*);
-    bool parseProgram();
+    JSParser(Lexer*, JSGlobalData*, FunctionParameters*, bool isStrictContext, bool isFunction, SourceProvider*);
+    bool parseProgram(JSGlobalObject*);
 private:
     struct AllowInOverride {
@@ -91 +94 @@
         m_lastTokenEnd = m_token.m_info.endOffset;
         m_lexer->setLastLineNumber(m_lastLine);
-        m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexType);
+        m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_info, lexType, strictMode());
         m_tokenCount++;
     }
@@ -122 +125 @@
         return m_token.m_info.endOffset;
     }
-
-    template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&);
-    template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&);
+    
+    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() { return currentScope()->breakIsValid(); }
+    void pushLabel(const Identifier* label) { currentScope()->pushLabel(label); }
+    void popLabel() { currentScope()->popLabel(); }
+    bool hasLabel(const Identifier* label) { return currentScope()->hasLabel(label); }
+
+    enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
+    template <SourceElementsMode mode, class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&);
+    template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive);
     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&);
     template <class TreeBuilder> TreeStatement parseVarDeclaration(TreeBuilder&);
@@ -200 +217 @@
     int m_nonLHSCount;
     bool m_syntaxAlreadyValidated;
+    int m_statementDepth;
+    int m_nonTrivialExpressionCount;
+    const Identifier* m_lastIdentifier;
+
+    struct DepthManager {
+        DepthManager(int* depth)
+            : m_originalDepth(*depth)
+            , m_depth(depth)
+        {
+        }
+        
+        ~DepthManager()
+        {
+            *m_depth = m_originalDepth;
+        }
+        
+    private:
+        int m_originalDepth;
+        int* m_depth;
+    };
 
     struct Scope {
-        Scope()
-            : m_usesEval(false)
+        Scope(JSGlobalData* globalData, bool isFunction, bool strictMode)
+            : m_globalData(globalData)
+            , m_usesEval(false)
             , m_needsFullActivation(false)
             , m_allowsNewDecls(true)
+            , m_strictMode(strictMode)
+            , m_isFunction(isFunction)
+            , m_isValidStrictMode(true)
+            , m_loopDepth(0)
+            , m_switchDepth(0)
+            , m_labels(0)
         {
         }
         
-        void declareVariable(const Identifier* ident)
+        void startSwitch() { m_switchDepth++; }
+        void endSwitch() { m_switchDepth--; }
+        void startLoop() { m_loopDepth++; }
+        void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }
+        bool inLoop() { return !!m_loopDepth; }
+        bool breakIsValid() { return m_loopDepth || m_switchDepth; }
+
+        void pushLabel(const Identifier* label)
         {
+            if (!m_labels)
+                m_labels = new LabelStack;
+            m_labels->append(label->impl());
+        }
+
+        void popLabel()
+        {
+            ASSERT(m_labels);
+            ASSERT(m_labels->size());
+            m_labels->removeLast();
+        }
+
+        bool hasLabel(const Identifier* label)
+        {
+            if (!m_labels)
+                return false;
+            for (int i = m_labels->size(); i > 0; i--) {
+                if (m_labels->at(i - 1) == label->impl())
+                    return true;
+            }
+            return false;
+        }
+
+        void setIsFunction() { m_isFunction = true; }
+        bool isFunction() { return m_isFunction; }
+        
+        bool declareVariable(const Identifier* ident)
+        {
+            bool isValidStrictMode = m_globalData->propertyNames->eval != *ident && m_globalData->propertyNames->arguments != *ident;
+            m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
             m_declaredVariables.add(ident->ustring().impl());
+            return isValidStrictMode;
+        }
+        
+        void declareWrite(const Identifier* ident)
+        {
+            ASSERT(m_strictMode);
+            m_writtenVariables.add(ident->impl());
+        }
+        
+        bool deleteProperty(const Identifier* ident)
+        {
+            if (m_declaredVariables.contains(ident->impl()))
+                return false;
+            m_deletedVariables.add(ident->impl());
+            return true;
         }
         
@@ -217 +313 @@
         bool allowsNewDecls() const { return m_allowsNewDecls; }
 
+        bool declareParameter(const Identifier* ident)
+        {
+            bool isValidStrictMode = m_declaredVariables.add(ident->ustring().impl()).second && m_globalData->propertyNames->eval != *ident && m_globalData->propertyNames->arguments != *ident;
+            m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
+            return isValidStrictMode;
+        }
+        
         void useVariable(const Identifier* ident, bool isEval)
         {
@@ -223 +326 @@
         }
         
-        void needsFullActivation() { m_needsFullActivation = true; }
+        void setNeedsFullActivation() { m_needsFullActivation = true; }
         
-        void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
+        bool collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
         {
             if (nestedScope->m_usesEval)
@@ -237 +340 @@
                     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))
+                        continue;
+                    m_writtenVariables.add(*ptr);
+                }
+            }
+            if (nestedScope->m_deletedVariables.size()) {
+                IdentifierSet::iterator end = nestedScope->m_deletedVariables.end();
+                for (IdentifierSet::iterator ptr = nestedScope->m_deletedVariables.begin(); ptr != end; ++ptr) {
+                    if (nestedScope->m_declaredVariables.contains(*ptr))
+                        return false;
+                    if (m_declaredVariables.contains(*ptr))
+                        return false;
+                    m_deletedVariables.add(*ptr);
+                }
+            }
+            return true;
+        }
+
+        void getUncapturedWrittenVariables(IdentifierSet& writtenVariables)
+        {
+            IdentifierSet::iterator end = m_writtenVariables.end();
+            for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
+                if (!m_declaredVariables.contains(*ptr))
+                    writtenVariables.add(*ptr);
+            }
+        }
+
+        bool getDeletedVariables(IdentifierSet& deletedVariables)
+        {
+            IdentifierSet::iterator end = m_deletedVariables.end();
+            for (IdentifierSet::iterator ptr = m_deletedVariables.begin(); ptr != end; ++ptr) {
+                if (m_declaredVariables.contains(*ptr))
+                    return false;
+            }
+            deletedVariables.swap(m_deletedVariables);
+            return true;
         }
 
@@ -251 +393 @@
             }
         }
+        void setStrictMode() { m_strictMode = true; }
+        bool strictMode() const { return m_strictMode; }
+        bool isValidStrictMode() const { return m_isValidStrictMode; }
+
     private:
-        bool m_usesEval;
-        bool m_needsFullActivation;
-        bool m_allowsNewDecls;
+        JSGlobalData* m_globalData;
+        bool m_usesEval : 1;
+        bool m_needsFullActivation : 1;
+        bool m_allowsNewDecls : 1;
+        bool m_strictMode : 1;
+        bool m_isFunction : 1;
+        bool m_isValidStrictMode : 1;
+        int m_loopDepth;
+        int m_switchDepth;
+        typedef Vector<StringImpl*, 2> LabelStack;
+        LabelStack* m_labels;
         IdentifierSet m_declaredVariables;
         IdentifierSet m_usedVariables;
         IdentifierSet m_closedVariables;
+        IdentifierSet m_writtenVariables;
+        IdentifierSet m_deletedVariables;
     };
     
@@ -282 +438 @@
     ScopeRef pushScope()
     {
-        m_scopeStack.append(Scope());
+        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();
     }
 
-    void popScope(ScopeRef scope, bool shouldTrackClosedVariables)
+    bool popScope(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);
+        bool result = m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
         m_scopeStack.removeLast();
+        return result;
     }
     
-    void declareVariable(const Identifier* ident)
+    bool declareVariable(const Identifier* ident)
     {
         unsigned i = m_scopeStack.size() - 1;
@@ -302 +465 @@
             ASSERT(i < m_scopeStack.size());
         }
-        m_scopeStack[i].declareVariable(ident);
-    }
-
+        return m_scopeStack[i].declareVariable(ident);
+    }
+    
+    void declareWrite(const Identifier* ident)
+    {
+        if (!m_syntaxAlreadyValidated)
+            m_scopeStack.last().declareWrite(ident);
+    }
+
+    bool deleteProperty(const Identifier* ident)
+    {
+        if (!m_syntaxAlreadyValidated)
+            return m_scopeStack.last().deleteProperty(ident);
+        return true;
+    }
+    
     ScopeStack m_scopeStack;
 };
 
-int jsParse(JSGlobalData* globalData, FunctionParameters* parameters, const SourceCode* source)
-{
-    JSParser parser(globalData->lexer, globalData, parameters, source->provider());
-    return parser.parseProgram();
-}
-
-JSParser::JSParser(Lexer* lexer, JSGlobalData* globalData, FunctionParameters* parameters, SourceProvider* provider)
+int jsParse(JSGlobalObject* lexicalGlobalObject, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode parserMode, const SourceCode* source)
+{
+    JSParser parser(lexicalGlobalObject->globalData()->lexer, lexicalGlobalObject->globalData(), parameters, strictness == JSParseStrict, parserMode == JSParseFunctionCode, source->provider());
+    return parser.parseProgram(lexicalGlobalObject);
+}
+
+JSParser::JSParser(Lexer* lexer, JSGlobalData* globalData, FunctionParameters* parameters, bool inStrictContext, bool isFunction, SourceProvider* provider)
     : m_lexer(lexer)
     , m_endAddress(0)
@@ -326 +502 @@
     , m_nonLHSCount(0)
     , m_syntaxAlreadyValidated(provider->isValid())
+    , m_statementDepth(0)
+    , m_nonTrivialExpressionCount(0)
+    , m_lastIdentifier(0)
 {
     m_endAddress = wtfThreadData().approximatedStackStart() - kMaxParserStackUsage;
-    next();
-    m_lexer->setLastLineNumber(tokenLine());
     ScopeRef scope = pushScope();
+    if (isFunction)
+        scope->setIsFunction();
+    if (inStrictContext)
+        scope->setStrictMode();
     if (parameters) {
         for (unsigned i = 0; i < parameters->size(); i++)
-            scope->declareVariable(&parameters->at(i));
-    }
-}
-
-bool JSParser::parseProgram()
+            scope->declareParameter(&parameters->at(i));
+    }
+    next();
+    m_lexer->setLastLineNumber(tokenLine());
+}
+
+bool JSParser::parseProgram(JSGlobalObject* lexicalGlobalObject)
 {
     ASTBuilder context(m_globalData, m_lexer);
+    if (m_lexer->isReparsing())
+        m_statementDepth--;
     ScopeRef scope = currentScope();
-    SourceElements* sourceElements = parseSourceElements<ASTBuilder>(context);
+    SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);
     if (!sourceElements || !consume(EOFTOK))
         return true;
+    if (!m_syntaxAlreadyValidated) {
+        IdentifierSet writtenVariables;
+        scope->getUncapturedWrittenVariables(writtenVariables);
+        IdentifierSet::const_iterator end = writtenVariables.end();
+        for (IdentifierSet::const_iterator ptr = writtenVariables.begin(); ptr != end; ++ptr) {
+            PropertySlot slot(lexicalGlobalObject);
+            if (!lexicalGlobalObject->getPropertySlot(lexicalGlobalObject->globalExec(), Identifier(m_globalData, *ptr), slot))
+                return true;
+        }
+        IdentifierSet deletedVariables;
+        if (!scope->getDeletedVariables(deletedVariables))
+            return true;
+        end = deletedVariables.end();
+        SymbolTable& globalEnvRecord = lexicalGlobalObject->symbolTable();
+        for (IdentifierSet::const_iterator ptr = deletedVariables.begin(); ptr != end; ++ptr) {
+            if (!globalEnvRecord.get(*ptr).isNull())
+                return true;
+        }
+    }
     IdentifierSet capturedVariables;
     scope->getCapturedVariables(capturedVariables);
-    m_globalData->parser->didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), context.features(),
-                                          m_lastLine, context.numConstants(), capturedVariables);
+    m_globalData->parser->didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), context.features() | (scope->strictMode() ? StrictModeFeature : 0),
+                                           m_lastLine, context.numConstants(), capturedVariables);
     return false;
 }
@@ -356 +560 @@
 }
 
-template <class TreeBuilder> TreeSourceElements JSParser::parseSourceElements(TreeBuilder& context)
+template <JSParser::SourceElementsMode mode, class TreeBuilder> TreeSourceElements JSParser::parseSourceElements(TreeBuilder& context)
 {
     TreeSourceElements sourceElements = context.createSourceElements();
-    while (TreeStatement statement = parseStatement(context))
+    bool seenNonDirective = false;
+    const Identifier* directive = 0;
+    unsigned startOffset = m_token.m_info.startOffset;
+    bool hasSetStrict = false;
+    while (TreeStatement statement = parseStatement(context, directive)) {
+        if (mode == CheckForStrictMode && !seenNonDirective) {
+            if (directive) {
+                if (!hasSetStrict && m_globalData->propertyNames->useStrictIdentifier == *directive) {
+                    setStrictMode();
+                    hasSetStrict = true;
+                    failIfFalse(isValidStrictMode());
+                    m_lexer->setOffset(startOffset);
+                    next();
+                    failIfTrue(m_error);
+                    continue;
+                }
+            } else
+                seenNonDirective = true;
+        }
         context.appendStatement(sourceElements, statement);
+    }
 
     if (m_error)
@@ -400 +623 @@
     int startLine = tokenLine();
     next();
-    TreeStatement statement = parseStatement(context);
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
     failIfFalse(statement);
     int endLine = tokenLine();
@@ -423 +649 @@
     int endLine = tokenLine();
     consumeOrFail(CLOSEPAREN);
-    TreeStatement statement = parseStatement(context);
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
     failIfFalse(statement);
     return context.createWhileStatement(expr, statement, startLine, endLine);
@@ -442 +671 @@
         next();
         bool hasInitializer = match(EQUAL);
-        declareVariable(name);
+        failIfFalseIfStrict(declareVariable(name));
         context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
         if (hasInitializer) {
@@ -466 +695 @@
 template <class TreeBuilder> TreeConstDeclList JSParser::parseConstDeclarationList(TreeBuilder& context)
 {
+    failIfTrue(strictMode());
     TreeConstDeclList constDecls = 0;
     TreeConstDeclList tail = 0;
@@ -533 +763 @@
         consumeOrFail(CLOSEPAREN);
 
-        TreeStatement statement = parseStatement(context);
+        const Identifier* unused = 0;
+        startLoop();
+        TreeStatement statement = parseStatement(context, unused);
+        endLoop();
         failIfFalse(statement);
 
@@ -567 +800 @@
         int endLine = tokenLine();
         consumeOrFail(CLOSEPAREN);
-        TreeStatement statement = parseStatement(context);
+        const Identifier* unused = 0;
+        startLoop();
+        TreeStatement statement = parseStatement(context, unused);
+        endLoop();
         failIfFalse(statement);
         return context.createForLoop(decls, condition, increment, statement, hasDeclaration, startLine, endLine);
@@ -580 +816 @@
     int endLine = tokenLine();
     consumeOrFail(CLOSEPAREN);
-    TreeStatement statement = parseStatement(context);
+    const Identifier* unused = 0;
+    startLoop();
+    TreeStatement statement = parseStatement(context, unused);
+    endLoop();
     failIfFalse(statement);
     
@@ -595 +834 @@
     next();
 
-    if (autoSemiColon())
+    if (autoSemiColon()) {
+        failIfFalseIfStrict(breakIsValid());
         return context.createBreakStatement(startCol, endCol, startLine, endLine);
+    }
     matchOrFail(IDENT);
     const Identifier* ident = m_token.m_data.ident;
+    failIfFalseIfStrict(hasLabel(ident));
     endCol = tokenEnd();
     endLine = tokenLine();
@@ -615 +857 @@
     next();
 
-    if (autoSemiColon())
+    if (autoSemiColon()) {
+        failIfFalseIfStrict(breakIsValid());
         return context.createContinueStatement(startCol, endCol, startLine, endLine);
+    }
     matchOrFail(IDENT);
     const Identifier* ident = m_token.m_data.ident;
+    failIfFalseIfStrict(hasLabel(ident));
     endCol = tokenEnd();
     endLine = tokenLine();
@@ -629 +874 @@
 {
     ASSERT(match(RETURN));
+    failIfFalseIfStrict(currentScope()->isFunction());
     int startLine = tokenLine();
     int endLine = startLine;
@@ -669 +915 @@
 {
     ASSERT(match(WITH));
-    currentScope()->needsFullActivation();
+    failIfTrue(strictMode());
+    currentScope()->setNeedsFullActivation();
     int startLine = tokenLine();
     next();
@@ -680 +927 @@
     int endLine = tokenLine();
     consumeOrFail(CLOSEPAREN);
-    
-    TreeStatement statement = parseStatement(context);
+    const Identifier* unused = 0;
+    TreeStatement statement = parseStatement(context, unused);
     failIfFalse(statement);
 
@@ -698 +945 @@
     consumeOrFail(CLOSEPAREN);
     consumeOrFail(OPENBRACE);
-
+    startSwitch();
     TreeClauseList firstClauses = parseSwitchClauses(context);
     failIfTrue(m_error);
@@ -707 +954 @@
     TreeClauseList secondClauses = parseSwitchClauses(context);
     failIfTrue(m_error);
+    endSwitch();
     consumeOrFail(CLOSEBRACE);
 
@@ -721 +969 @@
     failIfFalse(condition);
     consumeOrFail(COLON);
-    TreeSourceElements statements = parseSourceElements(context);
+    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
     failIfFalse(statements);
     TreeClause clause = context.createClause(condition, statements);
@@ -732 +980 @@
         failIfFalse(condition);
         consumeOrFail(COLON);
-        TreeSourceElements statements = parseSourceElements(context);
+        TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
         failIfFalse(statements);
         clause = context.createClause(condition, statements);
@@ -746 +994 @@
     next();
     consumeOrFail(COLON);
-    TreeSourceElements statements = parseSourceElements(context);
+    TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);
     failIfFalse(statements);
     return context.createClause(0, statements);
@@ -768 +1016 @@
 
     if (match(CATCH)) {
-        currentScope()->needsFullActivation();
+        currentScope()->setNeedsFullActivation();
         next();
         consumeOrFail(OPENPAREN);
@@ -775 +1023 @@
         next();
         ScopeRef catchScope = pushScope();
-        catchScope->declareVariable(ident);
+        failIfFalseIfStrict(catchScope->declareVariable(ident));
         catchScope->preventNewDecls();
         consumeOrFail(CLOSEPAREN);
@@ -783 +1031 @@
         failIfFalse(catchBlock);
         catchHasEval = initialEvalCount != context.evalCount();
-        popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo);
+        failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo));
     }
 
@@ -817 +1065 @@
         return context.createBlockStatement(0, start, m_lastLine);
     }
-    TreeSourceElements subtree = parseSourceElements(context);
+    TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
     failIfFalse(subtree);
     matchOrFail(CLOSEBRACE);
@@ -824 +1072 @@
 }
 
-template <class TreeBuilder> TreeStatement JSParser::parseStatement(TreeBuilder& context)
-{
+template <class TreeBuilder> TreeStatement JSParser::parseStatement(TreeBuilder& context, const Identifier*& directive)
+{
+    DepthManager statementDepth(&m_statementDepth);
+    m_statementDepth++;
+    directive = 0;
+    int nonTrivialExpressionCount = 0;
     failIfStackOverflow();
     switch (m_token.m_type) {
@@ -835 +1087 @@
         return parseConstDeclaration(context);
     case FUNCTION:
+        failIfFalseIfStrict(m_statementDepth == 1);
         return parseFunctionDeclaration(context);
     case SEMICOLON:
@@ -871 +1124 @@
     case IDENT:
         return parseExpressionOrLabelStatement(context);
+    case STRING:
+        directive = m_token.m_data.ident;
+        nonTrivialExpressionCount = m_nonTrivialExpressionCount;
     default:
-        return parseExpressionStatement(context);
+        TreeStatement exprStatement = parseExpressionStatement(context);
+        if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)
+            directive = 0;
+        return exprStatement;
     }
 }
@@ -880 +1139 @@
     matchOrFail(IDENT);
     usesArguments = m_globalData->propertyNames->arguments == *m_token.m_data.ident;
-    declareVariable(m_token.m_data.ident);
+    failIfFalseIfStrict(declareParameter(m_token.m_data.ident));
     TreeFormalParameterList list = context.createFormalParameterList(*m_token.m_data.ident);
     TreeFormalParameterList tail = list;
@@ -888 +1147 @@
         matchOrFail(IDENT);
         const Identifier* ident = m_token.m_data.ident;
-        declareVariable(ident);
+        usesArguments |= m_globalData->propertyNames->arguments == *m_token.m_data.ident;
+        failIfFalseIfStrict(declareParameter(ident));
         next();
         usesArguments = usesArguments || m_globalData->propertyNames->arguments == *ident;
@@ -899 +1159 @@
 {
     if (match(CLOSEBRACE))
-        return context.createFunctionBody();
+        return context.createFunctionBody(strictMode());
+    DepthManager statementDepth(&m_statementDepth);
+    m_statementDepth = 0;
     typename TreeBuilder::FunctionBodyBuilder bodyBuilder(m_globalData, m_lexer);
-    failIfFalse(parseSourceElements(bodyBuilder));
-    return context.createFunctionBody();
+    failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
+    return context.createFunctionBody(strictMode());
 }
 
@@ -908 +1170 @@
 {
     ScopeRef functionScope = pushScope();
+    functionScope->setIsFunction();
     if (match(IDENT)) {
         name = m_token.m_data.ident;
         next();
         if (!nameIsInContainingScope)
-            functionScope->declareVariable(name);
+            failIfFalseIfStrict(functionScope->declareVariable(name));
     } else if (requirements == FunctionNeedsName)
         return false;
@@ -932 +1195 @@
     if (usesArguments)
         context.setUsesArguments(body);
-    popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo);
+    if (functionScope->strictMode() && name) {
+        failIfTrue(m_globalData->propertyNames->arguments == *name);
+        failIfTrue(m_globalData->propertyNames->eval == *name);
+    }
+    failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
     matchOrFail(CLOSEBRACE);
     closeBracePos = m_token.m_data.intValue;
@@ -951 +1218 @@
     failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
     failIfFalse(name);
-    declareVariable(name);
+    failIfFalseIfStrict(declareVariable(name));
     return context.createFuncDeclStatement(name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
 }
@@ -974 +1241 @@
     int end = tokenEnd();
     consumeOrFail(COLON);
-    TreeStatement statement = parseStatement(context);
+    const Identifier* unused = 0;
+    if (strictMode() && !m_syntaxAlreadyValidated)
+        pushLabel(ident);
+    TreeStatement statement = parseStatement(context, unused);
+    if (strictMode() && !m_syntaxAlreadyValidated)
+        popLabel();
     failIfFalse(statement);
     return context.createLabelStatement(ident, statement, start, end);
@@ -1002 +1274 @@
     consumeOrFail(CLOSEPAREN);
 
-    TreeStatement trueBlock = parseStatement(context);
+    const Identifier* unused = 0;
+    TreeStatement trueBlock = parseStatement(context, unused);
     failIfFalse(trueBlock);
 
@@ -1015 +1288 @@
         next();
         if (!match(IF)) {
-            TreeStatement block = parseStatement(context);
+            const Identifier* unused = 0;
+            TreeStatement block = parseStatement(context, unused);
             failIfFalse(block);
             statementStack.append(block);
@@ -1030 +1304 @@
         int innerEnd = tokenLine();
         consumeOrFail(CLOSEPAREN);
-        
-        TreeStatement innerTrueBlock = parseStatement(context);
+        const Identifier* unused = 0;
+        TreeStatement innerTrueBlock = parseStatement(context, unused);
         failIfFalse(innerTrueBlock);     
         exprStack.append(innerCondition);
@@ -1071 +1345 @@
         return node;
     next();
+    m_nonTrivialExpressionCount++;
     m_nonLHSCount++;
     TreeExpression right = parseAssignmentExpression(context);
@@ -1116 +1391 @@
             goto end;
         }
+        m_nonTrivialExpressionCount++;
         hadAssignment = true;
         context.assignmentStackAppend(assignmentStack, lhs, start, tokenStart(), m_assignmentCount, op);
@@ -1121 +1397 @@
         m_assignmentCount++;
         next();
+        if (strictMode() && m_lastIdentifier && context.isResolve(lhs)) {
+            failIfTrueIfStrict(m_globalData->propertyNames->eval == *m_lastIdentifier);
+            declareWrite(m_lastIdentifier);
+            m_lastIdentifier = 0;
+        }
         lhs = parseConditionalExpression(context);
         failIfFalse(lhs);
@@ -1145 +1426 @@
     if (!match(QUESTION))
         return cond;
+    m_nonTrivialExpressionCount++;
     m_nonLHSCount++;
     next();
@@ -1182 +1464 @@
         if (!precedence)
             break;
+        m_nonTrivialExpressionCount++;
         m_nonLHSCount++;
         int operatorToken = m_token.m_type;
@@ -1197 +1480 @@
         context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
     }
-
     while (operatorStackDepth) {
         ASSERT(operandStackDepth > 1);
@@ -1328 +1610 @@
             std::pair<ObjectValidationMap::iterator, bool> propertyEntryIter = objectValidator.add(context.getName(property).impl(), context.getType(property));
             if (!propertyEntryIter.second) {
+                failIfTrue(strictMode());
                 if ((context.getType(property) & propertyEntryIter.first->second) != PropertyNode::Constant) {
                     // Can't have multiple getters or setters with the same name, nor can we define 
@@ -1390 +1673 @@
     switch (m_token.m_type) {
     case OPENBRACE:
+        if (strictMode())
+            return parseStrictObjectLiteral(context);
         return parseObjectLiteral(context);
     case OPENBRACKET:
@@ -1411 +1696 @@
         next();
         currentScope()->useVariable(ident, m_globalData->propertyNames->eval == *ident);
+        m_lastIdentifier = ident;
         return context.createResolve(ident, start);
     }
@@ -1486 +1772 @@
         newCount++;
     }
+
     if (match(FUNCTION)) {
         const Identifier* name = &m_globalData->propertyNames->nullIdentifier;
@@ -1503 +1790 @@
         switch (m_token.m_type) {
         case OPENBRACKET: {
+            m_nonTrivialExpressionCount++;
             int expressionEnd = lastTokenEnd();
             next();
@@ -1516 +1804 @@
         }
         case OPENPAREN: {
+            m_nonTrivialExpressionCount++;
             if (newCount) {
                 newCount--;
@@ -1536 +1825 @@
         }
         case DOT: {
+            m_nonTrivialExpressionCount++;
             int expressionEnd = lastTokenEnd();
             next(Lexer::IgnoreReservedWords);
@@ -1557 +1847 @@
     AllowInOverride allowInOverride(this);
     int tokenStackDepth = 0;
+    bool modifiesExpr = false;
+    bool requiresLExpr = false;
     while (isUnaryOp(m_token.m_type)) {
+        if (strictMode()) {
+            switch (m_token.m_type) {
+            case PLUSPLUS:
+            case MINUSMINUS:
+            case AUTOPLUSPLUS:
+            case AUTOMINUSMINUS:
+                failIfTrue(requiresLExpr);
+                modifiesExpr = true;
+                requiresLExpr = true;
+                break;
+            case DELETETOKEN:
+                failIfTrue(requiresLExpr);
+                requiresLExpr = true;
+                break;
+            default:
+                failIfTrue(requiresLExpr);
+                break;
+            }
+        }
         m_nonLHSCount++;
         context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStart());
         next();
+        m_nonTrivialExpressionCount++;
     }
     int subExprStart = tokenStart();
     TreeExpression expr = parseMemberExpression(context);
     failIfFalse(expr);
+    bool isEval = false;
+    if (strictMode() && !m_syntaxAlreadyValidated) {
+        if (context.isResolve(expr))
+            isEval = m_globalData->propertyNames->eval == *m_lastIdentifier;
+    }
+    failIfTrueIfStrict(isEval && modifiesExpr);
     switch (m_token.m_type) {
     case PLUSPLUS:
+        m_nonTrivialExpressionCount++;
         m_nonLHSCount++;
         expr = context.makePostfixNode(expr, OpPlusPlus, subExprStart, lastTokenEnd(), tokenEnd());
         m_assignmentCount++;
+        failIfTrueIfStrict(isEval);
+        failIfTrueIfStrict(requiresLExpr);
         next();
         break;
     case MINUSMINUS:
+        m_nonTrivialExpressionCount++;
         m_nonLHSCount++;
         expr = context.makePostfixNode(expr, OpMinusMinus, subExprStart, lastTokenEnd(), tokenEnd());
         m_assignmentCount++;
+        failIfTrueIfStrict(isEval);
+        failIfTrueIfStrict(requiresLExpr);
         next();
         break;
@@ -1584 +1908 @@
     int end = lastTokenEnd();
 
-    if (!TreeBuilder::CreatesAST)
+    if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
         return expr;
 
@@ -1618 +1942 @@
             break;
         case DELETETOKEN:
+            if (strictMode() && context.isResolve(expr))
+                failIfFalse(deleteProperty(m_lastIdentifier));
             expr = context.makeDeleteNode(expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
             break;