⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 181664 in webkit


Ignore:
Timestamp:
Mar 17, 2015, 2:15:03 PM (11 years ago)
Author:
ggaren@apple.com
Message:

Built-in functions should know that they use strict mode
​https://bugs.webkit.org/show_bug.cgi?id=142788

Reviewed by Mark Lam.

Even though all of our builtin functions use strict mode, the parser
thinks that they don't. This is because Executable::toStrictness treats
builtin-ness and strict-ness as mutually exclusive.

The fix is to disambiguate builtin-ness from strict-ness.

This bug is currently unobservable because of some other parser bugs. But
it causes lots of test failures once those other bugs are fixed.

  • API/JSScriptRef.cpp:

(parseScript):

  • builtins/BuiltinExecutables.cpp:

(JSC::BuiltinExecutables::createBuiltinExecutable): Adopt the new API
for a separate value to indicate builtin-ness vs strict-ness.

  • bytecode/UnlinkedCodeBlock.cpp:

(JSC::generateFunctionCodeBlock):
(JSC::UnlinkedFunctionExecutable::codeBlockFor): Ditto.

  • bytecode/UnlinkedCodeBlock.h:

(JSC::UnlinkedFunctionExecutable::toStrictness): Deleted. This function
was misleading since it pretended that no builtin function was ever
strict, which is the opposite of true.

  • parser/Lexer.cpp:

(JSC::Lexer<T>::Lexer):

  • parser/Lexer.h:
  • parser/Parser.cpp:

(JSC::Parser<LexerType>::Parser):

  • parser/Parser.h:

(JSC::parse): Adopt the new API.

  • parser/ParserModes.h: Added JSParserBuiltinMode, and tried to give

existing modes clearer names.

  • runtime/CodeCache.cpp:

(JSC::CodeCache::getGlobalCodeBlock):
(JSC::CodeCache::getProgramCodeBlock):
(JSC::CodeCache::getEvalCodeBlock):
(JSC::CodeCache::getFunctionExecutableFromGlobalCode): Adopt the new API.

  • runtime/CodeCache.h:

(JSC::SourceCodeKey::SourceCodeKey): Be sure to treat strict-ness and
bulitin-ness as separate pieces of the code cache key. We would not want
a user function to match a built-in function in the cache, even if they
agreed about strictness, since builtin functions have different lexing
rules.

  • runtime/Completion.cpp:

(JSC::checkSyntax):

  • runtime/Executable.cpp:

(JSC::FunctionExecutable::FunctionExecutable):
(JSC::ProgramExecutable::checkSyntax):

  • runtime/Executable.h:

(JSC::FunctionExecutable::create):

  • runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::createProgramCodeBlock):
(JSC::JSGlobalObject::createEvalCodeBlock): Adopt the new API.

Location:
trunk/Source/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSScriptRef.cpp

    r180637 r181664  
    6969static bool parseScript(VM* vm, const SourceCode& source, ParserError& error)
    7070{
    71     return !!JSC::parse<JSC::ProgramNode>(vm, source, 0, Identifier(), JSParseNormal, JSParseProgramCode, error);
     71    return !!JSC::parse<JSC::ProgramNode>(
     72        vm, source, 0, Identifier(), JSParserBuiltinMode::NotBuiltin,
     73        JSParserStrictMode::NotStrict, JSParserCodeType::Program,
     74        error);
    7275}
    7376

  • trunk/Source/JavaScriptCore/ChangeLog

    r181650 r181664  
     12015-03-17  Geoffrey Garen  <ggaren@apple.com>
     2
     3        Built-in functions should know that they use strict mode
     4        https://bugs.webkit.org/show_bug.cgi?id=142788
     5
     6        Reviewed by Mark Lam.
     7
     8        Even though all of our builtin functions use strict mode, the parser
     9        thinks that they don't. This is because Executable::toStrictness treats
     10        builtin-ness and strict-ness as mutually exclusive.
     11
     12        The fix is to disambiguate builtin-ness from strict-ness.
     13
     14        This bug is currently unobservable because of some other parser bugs. But
     15        it causes lots of test failures once those other bugs are fixed.
     16
     17        * API/JSScriptRef.cpp:
     18        (parseScript):
     19        * builtins/BuiltinExecutables.cpp:
     20        (JSC::BuiltinExecutables::createBuiltinExecutable): Adopt the new API
     21        for a separate value to indicate builtin-ness vs strict-ness.
     22
     23        * bytecode/UnlinkedCodeBlock.cpp:
     24        (JSC::generateFunctionCodeBlock):
     25        (JSC::UnlinkedFunctionExecutable::codeBlockFor): Ditto.
     26
     27        * bytecode/UnlinkedCodeBlock.h:
     28        (JSC::UnlinkedFunctionExecutable::toStrictness): Deleted. This function
     29        was misleading since it pretended that no builtin function was ever
     30        strict, which is the opposite of true.
     31
     32        * parser/Lexer.cpp:
     33        (JSC::Lexer<T>::Lexer):
     34        * parser/Lexer.h:
     35        * parser/Parser.cpp:
     36        (JSC::Parser<LexerType>::Parser):
     37        * parser/Parser.h:
     38        (JSC::parse): Adopt the new API.
     39
     40        * parser/ParserModes.h: Added JSParserBuiltinMode, and tried to give
     41        existing modes clearer names.
     42
     43        * runtime/CodeCache.cpp:
     44        (JSC::CodeCache::getGlobalCodeBlock):
     45        (JSC::CodeCache::getProgramCodeBlock):
     46        (JSC::CodeCache::getEvalCodeBlock):
     47        (JSC::CodeCache::getFunctionExecutableFromGlobalCode): Adopt the new API.
     48
     49        * runtime/CodeCache.h:
     50        (JSC::SourceCodeKey::SourceCodeKey): Be sure to treat strict-ness and
     51        bulitin-ness as separate pieces of the code cache key. We would not want
     52        a user function to match a built-in function in the cache, even if they
     53        agreed about strictness, since builtin functions have different lexing
     54        rules.
     55
     56        * runtime/Completion.cpp:
     57        (JSC::checkSyntax):
     58        * runtime/Executable.cpp:
     59        (JSC::FunctionExecutable::FunctionExecutable):
     60        (JSC::ProgramExecutable::checkSyntax):
     61        * runtime/Executable.h:
     62        (JSC::FunctionExecutable::create):
     63        * runtime/JSGlobalObject.cpp:
     64        (JSC::JSGlobalObject::createProgramCodeBlock):
     65        (JSC::JSGlobalObject::createEvalCodeBlock): Adopt the new API.
     66
    1672015-03-16  Filip Pizlo  <fpizlo@apple.com>
    268

  • trunk/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp

    r181611 r181664  
    6666    ParserError error;
    6767    bool isParsingDefaultConstructor = constructorKind != ConstructorKind::None;
    68     JSParserStrictness strictness = isParsingDefaultConstructor ? JSParseNormal : JSParseBuiltin;
     68    JSParserBuiltinMode builtinMode = isParsingDefaultConstructor ? JSParserBuiltinMode::NotBuiltin : JSParserBuiltinMode::Builtin;
    6969    UnlinkedFunctionKind kind = isParsingDefaultConstructor ? UnlinkedNormalFunction : UnlinkedBuiltinFunction;
    7070    RefPtr<SourceProvider> sourceOverride = isParsingDefaultConstructor ? source.provider() : nullptr;
    71     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(&m_vm, source, 0, Identifier(), strictness, JSParseProgramCode,
     71    std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
     72        &m_vm, source, 0, Identifier(), builtinMode,
     73        JSParserStrictMode::NotStrict,
     74        JSParserCodeType::Program,
    7275        error, &positionBeforeLastNewline, false, constructorKind);
    7376

  • trunk/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.cpp

    r181611 r181664  
    5050const ClassInfo UnlinkedFunctionCodeBlock::s_info = { "UnlinkedFunctionCodeBlock", &Base::s_info, 0, CREATE_METHOD_TABLE(UnlinkedFunctionCodeBlock) };
    5151
    52 static UnlinkedFunctionCodeBlock* generateFunctionCodeBlock(VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source, CodeSpecializationKind kind, DebuggerMode debuggerMode, ProfilerMode profilerMode, UnlinkedFunctionKind functionKind, bool bodyIncludesBraces, ParserError& error)
    53 {
    54     std::unique_ptr<FunctionNode> function = parse<FunctionNode>(&vm, source, executable->parameters(), executable->name(), executable->toStrictness(), JSParseFunctionCode, error, 0, bodyIncludesBraces);
     52static UnlinkedFunctionCodeBlock* generateFunctionCodeBlock(
     53    VM& vm, UnlinkedFunctionExecutable* executable, const SourceCode& source,
     54    CodeSpecializationKind kind, DebuggerMode debuggerMode, ProfilerMode profilerMode,
     55    UnlinkedFunctionKind functionKind, bool bodyIncludesBraces, ParserError& error)
     56{
     57    JSParserBuiltinMode builtinMode = executable->isBuiltinFunction() ? JSParserBuiltinMode::Builtin : JSParserBuiltinMode::NotBuiltin;
     58    JSParserStrictMode strictMode = executable->isInStrictContext() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
     59    std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
     60        &vm, source, executable->parameters(), executable->name(), builtinMode,
     61        strictMode, JSParserCodeType::Function, error, 0, bodyIncludesBraces);
    5562
    5663    if (!function) {
    … …  
    178185}
    179186
    180 UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::codeBlockFor(VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind, DebuggerMode debuggerMode, ProfilerMode profilerMode, bool bodyIncludesBraces, ParserError& error)
     187UnlinkedFunctionCodeBlock* UnlinkedFunctionExecutable::codeBlockFor(
     188    VM& vm, const SourceCode& source, CodeSpecializationKind specializationKind,
     189    DebuggerMode debuggerMode, ProfilerMode profilerMode, bool bodyIncludesBraces,
     190    ParserError& error)
    181191{
    182192    switch (specializationKind) {
    … …  
    191201    }
    192202
    193     UnlinkedFunctionCodeBlock* result = generateFunctionCodeBlock(vm, this, source, specializationKind, debuggerMode, profilerMode, isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, bodyIncludesBraces, error);
     203    UnlinkedFunctionCodeBlock* result = generateFunctionCodeBlock(
     204        vm, this, source, specializationKind, debuggerMode, profilerMode,
     205        isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction,
     206        bodyIncludesBraces, error);
    194207   
    195208    if (error.isValid())

  • trunk/Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h

    r181611 r181664  
    122122    bool isInStrictContext() const { return m_isInStrictContext; }
    123123    FunctionMode functionMode() const { return m_functionMode; }
    124     JSParserStrictness toStrictness() const
    125     {
    126         if (m_isBuiltinFunction)
    127             return JSParseBuiltin;
    128         if (m_isInStrictContext)
    129             return JSParseStrict;
    130         return JSParseNormal;
    131     }
    132124    ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
    133125
    … …  
    142134    String paramString() const;
    143135
    144     UnlinkedFunctionCodeBlock* codeBlockFor(VM&, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode, bool bodyIncludesBraces, ParserError&);
     136    UnlinkedFunctionCodeBlock* codeBlockFor(
     137        VM&, const SourceCode&, CodeSpecializationKind, DebuggerMode, ProfilerMode,
     138        bool bodyIncludesBraces, ParserError&);
    145139
    146140    static UnlinkedFunctionExecutable* fromGlobalCode(const Identifier&, ExecState&, const SourceCode&, JSObject*& exception);

  • trunk/Source/JavaScriptCore/parser/Lexer.cpp

    r181497 r181664  
    489489
    490490template <typename T>
    491 Lexer<T>::Lexer(VM* vm, JSParserStrictness strictness)
     491Lexer<T>::Lexer(VM* vm, JSParserBuiltinMode builtinMode)
    492492    : m_isReparsing(false)
    493493    , m_vm(vm)
    494     , m_parsingBuiltinFunction(strictness == JSParseBuiltin)
     494    , m_parsingBuiltinFunction(builtinMode == JSParserBuiltinMode::Builtin)
    495495{
    496496}

  • trunk/Source/JavaScriptCore/parser/Lexer.h

    r181497 r181664  
    7272
    7373public:
    74     Lexer(VM*, JSParserStrictness);
     74    Lexer(VM*, JSParserBuiltinMode);
    7575    ~Lexer();
    7676

  • trunk/Source/JavaScriptCore/parser/Parser.cpp

    r181611 r181664  
    191191
    192192template <typename LexerType>
    193 Parser<LexerType>::Parser(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode, ConstructorKind defaultConstructorKind)
     193Parser<LexerType>::Parser(
     194    VM* vm, const SourceCode& source, FunctionParameters* parameters,
     195    const Identifier& name, JSParserBuiltinMode builtinMode,
     196    JSParserStrictMode strictMode, JSParserCodeType codeType,
     197    ConstructorKind defaultConstructorKind)
    194198    : m_vm(vm)
    195199    , m_source(&source)
    … …  
    204208    , m_lastFunctionName(nullptr)
    205209    , m_sourceElements(0)
    206     , m_parsingBuiltin(strictness == JSParseBuiltin)
     210    , m_parsingBuiltin(builtinMode == JSParserBuiltinMode::Builtin)
    207211    , m_defaultConstructorKind(defaultConstructorKind)
    208212{
    209     m_lexer = std::make_unique<LexerType>(vm, strictness);
     213    m_lexer = std::make_unique<LexerType>(vm, builtinMode);
    210214    m_lexer->setCode(source, &m_parserArena);
    211215    m_token.m_location.line = source.firstLine();
    … …  
    215219    m_functionCache = vm->addSourceProviderCache(source.provider());
    216220    ScopeRef scope = pushScope();
    217     if (parserMode == JSParseFunctionCode)
     221    if (codeType == JSParserCodeType::Function)
    218222        scope->setIsFunction();
    219     if (strictness == JSParseStrict)
     223    if (strictMode == JSParserStrictMode::Strict)
    220224        scope->setStrictMode();
    221225    if (parameters) {

  • trunk/Source/JavaScriptCore/parser/Parser.h

    r181611 r181664  
    427427
    428428public:
    429     Parser(VM*, const SourceCode&, FunctionParameters*, const Identifier&, JSParserStrictness, JSParserMode,
     429    Parser(
     430        VM*, const SourceCode&, FunctionParameters*, const Identifier&,
     431        JSParserBuiltinMode, JSParserStrictMode, JSParserCodeType,
    430432        ConstructorKind defaultConstructorKind = ConstructorKind::None);
    431433    ~Parser();
    … …  
    982984
    983985template <class ParsedNode>
    984 std::unique_ptr<ParsedNode> parse(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name,
    985     JSParserStrictness strictness, JSParserMode parserMode, ParserError& error, JSTextPosition* positionBeforeLastNewline = 0,
    986     bool needReparsingAdjustment = false, ConstructorKind defaultConstructorKind = ConstructorKind::None)
     986std::unique_ptr<ParsedNode> parse(
     987    VM* vm, const SourceCode& source, FunctionParameters* parameters,
     988    const Identifier& name, JSParserBuiltinMode builtinMode,
     989    JSParserStrictMode strictMode, JSParserCodeType codeType,
     990    ParserError& error, JSTextPosition* positionBeforeLastNewline = 0,
     991    bool needReparsingAdjustment = false,
     992    ConstructorKind defaultConstructorKind = ConstructorKind::None)
    987993{
    988994    SamplingRegion samplingRegion("Parsing");
    … …  
    990996    ASSERT(!source.provider()->source().isNull());
    991997    if (source.provider()->source().is8Bit()) {
    992         Parser<Lexer<LChar>> parser(vm, source, parameters, name, strictness, parserMode, defaultConstructorKind);
     998        Parser<Lexer<LChar>> parser(vm, source, parameters, name, builtinMode, strictMode, codeType, defaultConstructorKind);
    993999        std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, needReparsingAdjustment);
    9941000        if (positionBeforeLastNewline)
    9951001            *positionBeforeLastNewline = parser.positionBeforeLastNewline();
    996         if (strictness == JSParseBuiltin) {
     1002        if (builtinMode == JSParserBuiltinMode::Builtin) {
    9971003            if (!result)
    9981004                WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
    … …  
    10021008        return result;
    10031009    }
    1004     Parser<Lexer<UChar>> parser(vm, source, parameters, name, strictness, parserMode);
     1010    Parser<Lexer<UChar>> parser(vm, source, parameters, name, builtinMode, strictMode, codeType);
    10051011    std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, needReparsingAdjustment);
    10061012    if (positionBeforeLastNewline)

  • trunk/Source/JavaScriptCore/parser/ParserModes.h

    r181490 r181664  
    3232namespace JSC {
    3333
    34 enum JSParserStrictness { JSParseNormal, JSParseBuiltin, JSParseStrict };
    35 enum JSParserMode { JSParseProgramCode, JSParseFunctionCode };
     34enum class JSParserStrictMode { NotStrict, Strict };
     35enum class JSParserBuiltinMode { NotBuiltin, Builtin };
     36enum class JSParserCodeType { Program, Function };
    3637
    3738enum class ConstructorKind { None, Base, Derived };

  • trunk/Source/JavaScriptCore/runtime/CodeCache.cpp

    r181482 r181664  
    7676
    7777template <class UnlinkedCodeBlockType, class ExecutableType>
    78 UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserStrictness strictness, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
     78UnlinkedCodeBlockType* CodeCache::getGlobalCodeBlock(VM& vm, ExecutableType* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
    7979{
    80     SourceCodeKey key = SourceCodeKey(source, String(), CacheTypes<UnlinkedCodeBlockType>::codeType, strictness);
     80    SourceCodeKey key = SourceCodeKey(source, String(), CacheTypes<UnlinkedCodeBlockType>::codeType, builtinMode, strictMode);
    8181    SourceCodeValue* cache = m_sourceCode.findCacheAndUpdateAge(key);
    8282    bool canCache = debuggerMode == DebuggerOff && profilerMode == ProfilerOff && !vm.typeProfiler() && !vm.controlFlowProfiler();
    … …  
    9393
    9494    typedef typename CacheTypes<UnlinkedCodeBlockType>::RootNode RootNode;
    95     std::unique_ptr<RootNode> rootNode = parse<RootNode>(&vm, source, 0, Identifier(), strictness, JSParseProgramCode, error);
     95    std::unique_ptr<RootNode> rootNode = parse<RootNode>(
     96        &vm, source, 0, Identifier(), builtinMode, strictMode,
     97        JSParserCodeType::Program, error);
    9698    if (!rootNode)
    9799        return nullptr;
    … …  
    119121}
    120122
    121 UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, ProgramExecutable* executable, const SourceCode& source, JSParserStrictness strictness, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
     123UnlinkedProgramCodeBlock* CodeCache::getProgramCodeBlock(VM& vm, ProgramExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
    122124{
    123     return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, executable, source, strictness, debuggerMode, profilerMode, error);
     125    return getGlobalCodeBlock<UnlinkedProgramCodeBlock>(vm, executable, source, builtinMode, strictMode, debuggerMode, profilerMode, error);
    124126}
    125127
    126 UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, EvalExecutable* executable, const SourceCode& source, JSParserStrictness strictness, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
     128UnlinkedEvalCodeBlock* CodeCache::getEvalCodeBlock(VM& vm, EvalExecutable* executable, const SourceCode& source, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, DebuggerMode debuggerMode, ProfilerMode profilerMode, ParserError& error)
    127129{
    128     return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, strictness, debuggerMode, profilerMode, error);
     130    return getGlobalCodeBlock<UnlinkedEvalCodeBlock>(vm, executable, source, builtinMode, strictMode, debuggerMode, profilerMode, error);
    129131}
    130132
    131133UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(VM& vm, const Identifier& name, const SourceCode& source, ParserError& error)
    132134{
    133     SourceCodeKey key = SourceCodeKey(source, name.string(), SourceCodeKey::FunctionType, JSParseNormal);
     135    SourceCodeKey key = SourceCodeKey(
     136        source, name.string(), SourceCodeKey::FunctionType,
     137        JSParserBuiltinMode::NotBuiltin,
     138        JSParserStrictMode::NotStrict);
    134139    SourceCodeValue* cache = m_sourceCode.findCacheAndUpdateAge(key);
    135140    if (cache)
    … …  
    137142
    138143    JSTextPosition positionBeforeLastNewline;
    139     std::unique_ptr<ProgramNode> program = parse<ProgramNode>(&vm, source, 0, Identifier(), JSParseNormal, JSParseProgramCode, error, &positionBeforeLastNewline);
     144    std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
     145        &vm, source, 0, Identifier(), JSParserBuiltinMode::NotBuiltin,
     146        JSParserStrictMode::NotStrict, JSParserCodeType::Program,
     147        error, &positionBeforeLastNewline);
    140148    if (!program) {
    141149        RELEASE_ASSERT(error.isValid());

  • trunk/Source/JavaScriptCore/runtime/CodeCache.h

    r181482 r181664  
    6262    }
    6363
    64     SourceCodeKey(const SourceCode& sourceCode, const String& name, CodeType codeType, JSParserStrictness jsParserStrictness)
     64    SourceCodeKey(const SourceCode& sourceCode, const String& name, CodeType codeType, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode)
    6565        : m_sourceCode(sourceCode)
    6666        , m_name(name)
    67         , m_flags((codeType << 2) | jsParserStrictness)
     67        , m_flags(
     68            (static_cast<unsigned>(codeType) << 2)
     69            | (static_cast<unsigned>(builtinMode) << 1)
     70            | static_cast<unsigned>(strictMode))
    6871        , m_hash(string().impl()->hash())
    6972    {
    … …  
    250253    ~CodeCache();
    251254
    252     UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, ProgramExecutable*, const SourceCode&, JSParserStrictness, DebuggerMode, ProfilerMode, ParserError&);
    253     UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, EvalExecutable*, const SourceCode&, JSParserStrictness, DebuggerMode, ProfilerMode, ParserError&);
     255    UnlinkedProgramCodeBlock* getProgramCodeBlock(VM&, ProgramExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ProfilerMode, ParserError&);
     256    UnlinkedEvalCodeBlock* getEvalCodeBlock(VM&, EvalExecutable*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ProfilerMode, ParserError&);
    254257    UnlinkedFunctionExecutable* getFunctionExecutableFromGlobalCode(VM&, const Identifier&, const SourceCode&, ParserError&);
    255258
    … …  
    261264private:
    262265    template <class UnlinkedCodeBlockType, class ExecutableType>
    263     UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, ExecutableType*, const SourceCode&, JSParserStrictness, DebuggerMode, ProfilerMode, ParserError&);
     266    UnlinkedCodeBlockType* getGlobalCodeBlock(VM&, ExecutableType*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, DebuggerMode, ProfilerMode, ParserError&);
    264267
    265268    CodeCacheMap m_sourceCode;

  • trunk/Source/JavaScriptCore/runtime/Completion.cpp

    r176825 r181664  
    5656    JSLockHolder lock(vm);
    5757    RELEASE_ASSERT(vm.atomicStringTable() == wtfThreadData().atomicStringTable());
    58     return !!parse<ProgramNode>(&vm, source, 0, Identifier(), JSParseNormal, JSParseProgramCode, error);
     58    return !!parse<ProgramNode>(
     59        &vm, source, 0, Identifier(), JSParserBuiltinMode::NotBuiltin,
     60        JSParserStrictMode::NotStrict, JSParserCodeType::Program, error);
    5961}
    6062

  • trunk/Source/JavaScriptCore/runtime/Executable.cpp

    r181213 r181664  
    395395const ClassInfo FunctionExecutable::s_info = { "FunctionExecutable", &ScriptExecutable::s_info, 0, CREATE_METHOD_TABLE(FunctionExecutable) };
    396396
    397 FunctionExecutable::FunctionExecutable(VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn, bool bodyIncludesBraces)
     397FunctionExecutable::FunctionExecutable(VM& vm, const SourceCode& source,
     398    UnlinkedFunctionExecutable* unlinkedExecutable, unsigned firstLine,
     399    unsigned lastLine, unsigned startColumn, unsigned endColumn,
     400    bool bodyIncludesBraces)
    398401    : ScriptExecutable(vm.functionExecutableStructure.get(), vm, source, unlinkedExecutable->isInStrictContext())
    399402    , m_unlinkedExecutable(vm, this, unlinkedExecutable)
    … …  
    466469    VM* vm = &exec->vm();
    467470    JSGlobalObject* lexicalGlobalObject = exec->lexicalGlobalObject();
    468     std::unique_ptr<ProgramNode> programNode = parse<ProgramNode>(vm, m_source, 0, Identifier(), JSParseNormal, JSParseProgramCode, error);
     471    std::unique_ptr<ProgramNode> programNode = parse<ProgramNode>(
     472        vm, m_source, 0, Identifier(), JSParserBuiltinMode::NotBuiltin,
     473        JSParserStrictMode::NotStrict, JSParserCodeType::Program, error);
    469474    if (programNode)
    470475        return 0;

  • trunk/Source/JavaScriptCore/runtime/Executable.h

    r181490 r181664  
    542542    typedef ScriptExecutable Base;
    543543
    544     static FunctionExecutable* create(VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn, bool bodyIncludesBraces = true)
     544    static FunctionExecutable* create(
     545        VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable,
     546        unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn,
     547        bool bodyIncludesBraces = true)
    545548    {
    546549        FunctionExecutable* executable = new (NotNull, allocateCell<FunctionExecutable>(vm.heap)) FunctionExecutable(vm, source, unlinkedExecutable, firstLine, lastLine, startColumn, endColumn, bodyIncludesBraces);
    … …  
    644647
    645648private:
    646     FunctionExecutable(VM&, const SourceCode&, UnlinkedFunctionExecutable*, unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn, bool bodyIncludesBraces);
     649    FunctionExecutable(
     650        VM&, const SourceCode&, UnlinkedFunctionExecutable*, unsigned firstLine,
     651        unsigned lastLine, unsigned startColumn, unsigned endColumn,
     652        bool bodyIncludesBraces);
    647653
    648654    bool isCompiling()

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r181297 r181664  
    784784{
    785785    ParserError error;
    786     JSParserStrictness strictness = executable->isStrictMode() ? JSParseStrict : JSParseNormal;
     786    JSParserStrictMode strictMode = executable->isStrictMode() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
    787787    DebuggerMode debuggerMode = hasDebugger() ? DebuggerOn : DebuggerOff;
    788788    ProfilerMode profilerMode = hasProfiler() ? ProfilerOn : ProfilerOff;
    789     UnlinkedProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getProgramCodeBlock(vm(), executable, executable->source(), strictness, debuggerMode, profilerMode, error);
     789    UnlinkedProgramCodeBlock* unlinkedCodeBlock = vm().codeCache()->getProgramCodeBlock(
     790        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode,
     791        debuggerMode, profilerMode, error);
    790792
    791793    if (hasDebugger())
    … …  
    803805{
    804806    ParserError error;
    805     JSParserStrictness strictness = executable->isStrictMode() ? JSParseStrict : JSParseNormal;
     807    JSParserStrictMode strictMode = executable->isStrictMode() ? JSParserStrictMode::Strict : JSParserStrictMode::NotStrict;
    806808    DebuggerMode debuggerMode = hasDebugger() ? DebuggerOn : DebuggerOff;
    807809    ProfilerMode profilerMode = hasProfiler() ? ProfilerOn : ProfilerOff;
    808     UnlinkedEvalCodeBlock* unlinkedCodeBlock = vm().codeCache()->getEvalCodeBlock(vm(), executable, executable->source(), strictness, debuggerMode, profilerMode, error);
     810    UnlinkedEvalCodeBlock* unlinkedCodeBlock = vm().codeCache()->getEvalCodeBlock(
     811        vm(), executable, executable->source(), JSParserBuiltinMode::NotBuiltin, strictMode,
     812        debuggerMode, profilerMode, error);
    809813
    810814    if (hasDebugger())
Note: See TracChangeset for help on using the changeset viewer.