Skip to content

Commit

Permalink
Cherry-pick d8aca95. rdar://123524381
Browse files Browse the repository at this point in the history 
    [JSC] Set correct ConstructorKind when reparsing functions
    https://bugs.webkit.org/show_bug.cgi?id=269869
    <rdar://problem/123401267>

    Reviewed by Justin Michaud.

    Before this change, when reparsing a function, ConstructorKind was always set to None,
    which prevents a parser-level workaround to fix https://webkit.org/b/268411.
    Also, ConstructorKind was abused to allow super() in eval(): please see Parser constructor.

    However, passing down ConstructorKind to parser isn't trivial as it would conflict with
    `defaultConstructorKindForTopLevelFunction` that is needed only for bytecode validation.

    To avoid using one parameter for two purposes, this patch extracts parseRootNode(), which has
    parameters special for debugger / bytecode validation while lacking ones needed only for functions.
    overrideConstructorKindForTopLevelFunctionExpressions() is introduced for the same purpose.

    Also, this change:
      * passes correct DerivedContextType for eval() and reimplements SyntaxError check for super(),
        all to avoid setting ConstructorKind for non-functions;
      * hoists ConstructorKind override for bytecode validation up to parseFunctionExpression() to
        limit the surface of this bytecode validation only hack;
      * removes unused ParsingContext::Eval.

    No new tests, no behavior change.

    * Source/JavaScriptCore/API/JSScriptRef.cpp:
    (parseScript):
    * Source/JavaScriptCore/builtins/BuiltinExecutables.cpp:
    (JSC::BuiltinExecutables::createExecutable):
    * Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp:
    (JSC::generateUnlinkedFunctionCodeBlock):
    * Source/JavaScriptCore/debugger/DebuggerParseData.cpp:
    (JSC::gatherDebuggerParseData):
    * Source/JavaScriptCore/parser/Parser.cpp:
    (JSC::Parser<LexerType>::Parser):
    (JSC::Parser<LexerType>::parseFunctionInfo):
    (JSC::Parser<LexerType>::parseFunctionExpression):
    (JSC::Parser<LexerType>::parseMemberExpression):
    * Source/JavaScriptCore/parser/Parser.h:
    (JSC::Scope::setDerivedContextType):
    (JSC::Scope::derivedContextType const):
    (JSC::Parser::overrideConstructorKindForTopLevelFunctionExpressions):
    (JSC::parse):
    (JSC::parseRootNode):
    * Source/JavaScriptCore/runtime/CodeCache.cpp:
    (JSC::generateUnlinkedCodeBlockImpl):
    * Source/JavaScriptCore/runtime/Completion.cpp:
    (JSC::checkSyntaxInternal):
    (JSC::checkModuleSyntax):
    * Source/JavaScriptCore/runtime/JSModuleLoader.cpp:
    (JSC::JSC_DEFINE_HOST_FUNCTION):

    Canonical link: https://commits.webkit.org/275189@main

Canonical link: https://commits.webkit.org/274941.55@safari-7619.1.5-branch
  • Loading branch information
Alexey Shvayka authored and Dan Robson committed Mar 3, 2024
1 parent 4e7939d commit 3ba5278
Show file tree
Hide file tree
Showing 9 changed files with 95 additions and 59 deletions.
7 changes: 3 additions & 4 deletions Source/JavaScriptCore/API/JSScriptRef.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -72,10 +72,9 @@ struct OpaqueJSScript final : public SourceProvider {

static bool parseScript(VM& vm, const SourceCode& source, ParserError& error)
{
return !!JSC::parse<JSC::ProgramNode>(
vm, source, Identifier(), ImplementationVisibility::Public, JSParserBuiltinMode::NotBuiltin,
JSParserStrictMode::NotStrict, JSParserScriptMode::Classic, SourceParseMode::ProgramMode, FunctionMode::None, SuperBinding::NotNeeded,
error);
return !!parseRootNode<ProgramNode>(
vm, source, ImplementationVisibility::Public, JSParserBuiltinMode::NotBuiltin,
JSParserStrictMode::NotStrict, JSParserScriptMode::Classic, SourceParseMode::ProgramMode, error);
}

extern "C" {
Expand Down
8 changes: 4 additions & 4 deletions Source/JavaScriptCore/builtins/BuiltinExecutables.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -219,10 +219,10 @@ UnlinkedFunctionExecutable* BuiltinExecutables::createExecutable(VM& vm, const S
JSTextPosition positionBeforeLastNewlineFromParser;
ParserError error;
JSParserBuiltinMode builtinMode = isBuiltinDefaultClassConstructor ? JSParserBuiltinMode::NotBuiltin : JSParserBuiltinMode::Builtin;
std::unique_ptr<ProgramNode> program = parse<ProgramNode>(
vm, source, Identifier(), implementationVisibility, builtinMode,
JSParserStrictMode::NotStrict, JSParserScriptMode::Classic, SourceParseMode::ProgramMode, FunctionMode::None, SuperBinding::NotNeeded, error,
&positionBeforeLastNewlineFromParser, constructorKind);
std::unique_ptr<ProgramNode> program = parseRootNode<ProgramNode>(
vm, source, implementationVisibility, builtinMode,
JSParserStrictMode::NotStrict, JSParserScriptMode::Classic, SourceParseMode::ProgramMode, error,
constructorKind, &positionBeforeLastNewlineFromParser);

if (program) {
StatementNode* exprStatement = program->singleStatement();
Expand Down
2 changes: 1 addition & 1 deletion Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,7 @@ static UnlinkedFunctionCodeBlock* generateUnlinkedFunctionCodeBlock(
ASSERT(isFunctionParseMode(executable->parseMode()));
auto* classElementDefinitions = executable->classElementDefinitions();
std::unique_ptr<FunctionNode> function = parse<FunctionNode>(
vm, source, executable->name(), executable->implementationVisibility(), builtinMode, strictMode, scriptMode, executable->parseMode(), executable->functionMode(), executable->superBinding(), error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None, nullptr, nullptr, classElementDefinitions);
vm, source, executable->name(), executable->implementationVisibility(), builtinMode, strictMode, scriptMode, executable->parseMode(), executable->functionMode(), executable->superBinding(), error, executable->constructorKind(), executable->derivedContextType(), EvalContextType::None, nullptr, classElementDefinitions);

if (!function) {
ASSERT(error.isValid());
Expand Down
7 changes: 3 additions & 4 deletions Source/JavaScriptCore/debugger/DebuggerParseData.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -176,10 +176,9 @@ bool gatherDebuggerParseData(VM& vm, const SourceCode& source, DebuggerParseData
JSParserScriptMode scriptMode = DebuggerParseInfo<T>::scriptMode;

ParserError error;
std::unique_ptr<RootNode> rootNode = parse<RootNode>(vm, source, Identifier(), ImplementationVisibility::Public,
JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, parseMode, FunctionMode::None, SuperBinding::NotNeeded,
error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None,
&debuggerParseData);
std::unique_ptr<RootNode> rootNode = parseRootNode<RootNode>(vm, source, ImplementationVisibility::Public,
JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, parseMode,
error, ConstructorKind::None, nullptr, &debuggerParseData);
if (!rootNode)
return false;

Expand Down
38 changes: 15 additions & 23 deletions Source/JavaScriptCore/parser/Parser.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -130,7 +130,7 @@ void Parser<LexerType>::logError(bool shouldPrintToken, Args&&... args)
}

template <typename LexerType>
Parser<LexerType>::Parser(VM& vm, const SourceCode& source, ImplementationVisibility implementationVisibility, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode, FunctionMode functionMode, SuperBinding superBinding, ConstructorKind defaultConstructorKindForTopLevelFunction, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType, DebuggerParseData* debuggerParseData, bool isInsideOrdinaryFunction)
Parser<LexerType>::Parser(VM& vm, const SourceCode& source, ImplementationVisibility implementationVisibility, JSParserBuiltinMode builtinMode, JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode, FunctionMode functionMode, SuperBinding superBinding, ConstructorKind constructorKind, DerivedContextType derivedContextType, bool isEvalContext, EvalContextType evalContextType, DebuggerParseData* debuggerParseData, bool isInsideOrdinaryFunction)
: m_vm(vm)
, m_source(&source)
, m_hasStackOverflow(false)
Expand All @@ -142,7 +142,6 @@ Parser<LexerType>::Parser(VM& vm, const SourceCode& source, ImplementationVisibi
, m_functionMode(functionMode)
, m_scriptMode(scriptMode)
, m_superBinding(superBinding)
, m_defaultConstructorKindForTopLevelFunction(defaultConstructorKindForTopLevelFunction)
, m_immediateParentAllowsFunctionDeclarationInStatement(false)
, m_debuggerParseData(debuggerParseData)
, m_isInsideOrdinaryFunction(isInsideOrdinaryFunction)
Expand All @@ -161,13 +160,14 @@ Parser<LexerType>::Parser(VM& vm, const SourceCode& source, ImplementationVisibi
scope->setIsEvalContext(isEvalContext);
if (isEvalContext)
scope->setEvalContextType(evalContextType);

if (derivedContextType == DerivedContextType::DerivedConstructorContext) {
scope->setConstructorKind(ConstructorKind::Extends);
scope->setExpectedSuperBinding(SuperBinding::Needed);
}

if (derivedContextType == DerivedContextType::DerivedMethodContext)

if (scope->isFunction())
scope->setConstructorKind(constructorKind);
else
ASSERT(constructorKind == ConstructorKind::None);

scope->setDerivedContextType(derivedContextType);
if (derivedContextType != DerivedContextType::None)
scope->setExpectedSuperBinding(SuperBinding::Needed);

if (strictMode == JSParserStrictMode::Strict)
Expand Down Expand Up @@ -2616,17 +2616,9 @@ template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuild
// BytecodeGenerator emits code to throw TypeError when a class constructor is "call"ed.
// Set ConstructorKind to None for non-constructor methods of classes.

if (parentScope->isGlobalCode() && m_defaultConstructorKindForTopLevelFunction != ConstructorKind::None) {
constructorKind = m_defaultConstructorKindForTopLevelFunction;
expectedSuperBinding = m_defaultConstructorKindForTopLevelFunction == ConstructorKind::Extends ? SuperBinding::Needed : SuperBinding::NotNeeded;
}

functionBodyType = StandardFunctionBodyBlock;
}

functionScope->setConstructorKind(constructorKind);
functionScope->setExpectedSuperBinding(expectedSuperBinding);

m_parserState.lastFunctionName = lastFunctionName;
ParserState oldState = internalSaveParserState(context);

Expand Down Expand Up @@ -4885,7 +4877,11 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseFunctionExpr
if (consume(TIMES))
parseMode = SourceParseMode::GeneratorWrapperFunctionMode;
SetForScope setInnerParseMode(m_parseMode, parseMode);
failIfFalse((parseFunctionInfo(context, FunctionNameRequirements::None, false, ConstructorKind::None, SuperBinding::NotNeeded, functionStart, functionInfo, FunctionDefinitionType::Expression)), "Cannot parse function expression");

ConstructorKind constructorKind = currentScope()->isGlobalCode() ? m_constructorKindForTopLevelFunctionExpressions : ConstructorKind::None;
SuperBinding expectedSuperBinding = constructorKind == ConstructorKind::Extends ? SuperBinding::Needed : SuperBinding::NotNeeded;

failIfFalse((parseFunctionInfo(context, FunctionNameRequirements::None, false, constructorKind, expectedSuperBinding, functionStart, functionInfo, FunctionDefinitionType::Expression)), "Cannot parse function expression");
return context.createFunctionExpr(location, functionInfo);
}

Expand Down Expand Up @@ -5433,11 +5429,7 @@ template <class TreeBuilder> TreeExpression Parser<LexerType>::parseMemberExpres
// inside of the constructor or method.
if (!m_lexer->isReparsingFunction()) {
ScopeRef closestOrdinaryFunctionScope = closestParentOrdinaryFunctionNonLexicalScope();
ConstructorKind functionConstructorKind = !functionScope->isArrowFunction() && !closestOrdinaryFunctionScope->isEvalContext()
? functionScope->constructorKind()
: closestOrdinaryFunctionScope->constructorKind();
semanticFailIfTrue(functionConstructorKind == ConstructorKind::None, "super is not valid in this context");
semanticFailIfTrue(functionConstructorKind != ConstructorKind::Extends, "super is not valid in this context");
semanticFailIfFalse(closestOrdinaryFunctionScope->constructorKind() == ConstructorKind::Extends || (closestOrdinaryFunctionScope->isEvalContext() && closestOrdinaryFunctionScope->derivedContextType() == DerivedContextType::DerivedConstructorContext), "super is not valid in this context");
}
if (currentScope()->isArrowFunction())
functionScope->setInnerArrowFunctionUsesSuperCall();
Expand Down
72 changes: 59 additions & 13 deletions Source/JavaScriptCore/parser/Parser.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -654,6 +654,9 @@ struct Scope {

void setEvalContextType(EvalContextType evalContextType) { m_evalContextType = evalContextType; }
EvalContextType evalContextType() { return m_evalContextType; }

void setDerivedContextType(DerivedContextType derivedContextType) { m_derivedContextType = derivedContextType; }
DerivedContextType derivedContextType() const { return m_derivedContextType; }

InnerArrowFunctionCodeFeatures innerArrowFunctionFeatures() { return m_innerArrowFunctionFeatures; }

Expand Down Expand Up @@ -977,6 +980,7 @@ struct Scope {
bool m_isClassScope : 1 { false };
EvalContextType m_evalContextType { EvalContextType::None };
ConstructorKind m_constructorKind { ConstructorKind::None };
DerivedContextType m_derivedContextType { DerivedContextType::None };
SuperBinding m_expectedSuperBinding { SuperBinding::NotNeeded };
int m_loopDepth { 0 };
int m_switchDepth { 0 };
Expand Down Expand Up @@ -1028,20 +1032,22 @@ struct ScopeRef {
};

enum class ArgumentType { Normal, Spread };
enum class ParsingContext { Program, FunctionConstructor, Eval };
enum class ParsingContext { Normal, FunctionConstructor };

template <typename LexerType>
class Parser {
WTF_MAKE_NONCOPYABLE(Parser);
WTF_MAKE_TZONE_ALLOCATED(Parser);

public:
Parser(VM&, const SourceCode&, ImplementationVisibility, JSParserBuiltinMode, JSParserStrictMode, JSParserScriptMode, SourceParseMode, FunctionMode, SuperBinding, ConstructorKind defaultConstructorKindForTopLevelFunction = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None, DebuggerParseData* = nullptr, bool isInsideOrdinaryFunction = false);
Parser(VM&, const SourceCode&, ImplementationVisibility, JSParserBuiltinMode, JSParserStrictMode, JSParserScriptMode, SourceParseMode, FunctionMode, SuperBinding, ConstructorKind = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None, DebuggerParseData* = nullptr, bool isInsideOrdinaryFunction = false);
~Parser();

template <class ParsedNode>
std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, ParsingContext, std::optional<int> functionConstructorParametersEndPosition = std::nullopt, const PrivateNameEnvironment* = nullptr, const FixedVector<UnlinkedFunctionExecutable::ClassElementDefinition>* = nullptr);

void overrideConstructorKindForTopLevelFunctionExpressions(ConstructorKind constructorKind) { m_constructorKindForTopLevelFunctionExpressions = constructorKind; }

JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }

Expand Down Expand Up @@ -2165,7 +2171,7 @@ class Parser {
FunctionMode m_functionMode;
JSParserScriptMode m_scriptMode;
SuperBinding m_superBinding;
ConstructorKind m_defaultConstructorKindForTopLevelFunction;
ConstructorKind m_constructorKindForTopLevelFunctionExpressions { ConstructorKind::None };
ExpressionErrorClassifier* m_expressionErrorClassifier;
bool m_isEvalContext;
bool m_immediateParentAllowsFunctionDeclarationInStatement;
Expand Down Expand Up @@ -2276,11 +2282,10 @@ std::unique_ptr<ParsedNode> parse(
VM& vm, const SourceCode& source,
const Identifier& name, ImplementationVisibility implementationVisibility, JSParserBuiltinMode builtinMode,
JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode, FunctionMode functionMode, SuperBinding superBinding,
ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
ConstructorKind defaultConstructorKindForTopLevelFunction = ConstructorKind::None,
ParserError& error,
ConstructorKind constructorKind = ConstructorKind::None,
DerivedContextType derivedContextType = DerivedContextType::None,
EvalContextType evalContextType = EvalContextType::None,
DebuggerParseData* debuggerParseData = nullptr,
const PrivateNameEnvironment* parentScopePrivateNames = nullptr,
const FixedVector<UnlinkedFunctionExecutable::ClassElementDefinition>* classElementDefinitions = nullptr,
bool isInsideOrdinaryFunction = false)
Expand All @@ -2293,10 +2298,8 @@ std::unique_ptr<ParsedNode> parse(

std::unique_ptr<ParsedNode> result;
if (source.provider()->source().is8Bit()) {
Parser<Lexer<LChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, functionMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);
result = parser.parse<ParsedNode>(error, name, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, std::nullopt, parentScopePrivateNames, classElementDefinitions);
if (positionBeforeLastNewline)
*positionBeforeLastNewline = parser.positionBeforeLastNewline();
Parser<Lexer<LChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, functionMode, superBinding, constructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, nullptr, isInsideOrdinaryFunction);
result = parser.parse<ParsedNode>(error, name, ParsingContext::Normal, std::nullopt, parentScopePrivateNames, classElementDefinitions);
if (builtinMode == JSParserBuiltinMode::Builtin) {
if (!result) {
ASSERT(error.isValid());
Expand All @@ -2305,11 +2308,54 @@ std::unique_ptr<ParsedNode> parse(
}
}
} else {
ASSERT_WITH_MESSAGE(defaultConstructorKindForTopLevelFunction == ConstructorKind::None, "BuiltinExecutables's special constructors should always use a 8-bit string");
Parser<Lexer<UChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, functionMode, superBinding, defaultConstructorKindForTopLevelFunction, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, debuggerParseData, isInsideOrdinaryFunction);
result = parser.parse<ParsedNode>(error, name, isEvalNode<ParsedNode>() ? ParsingContext::Eval : ParsingContext::Program, std::nullopt, parentScopePrivateNames, classElementDefinitions);
Parser<Lexer<UChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, functionMode, superBinding, constructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType, nullptr, isInsideOrdinaryFunction);
result = parser.parse<ParsedNode>(error, name, ParsingContext::Normal, std::nullopt, parentScopePrivateNames, classElementDefinitions);
}

if (UNLIKELY(Options::countParseTimes()))
globalParseCount++;

if (UNLIKELY(Options::reportParseTimes())) {
MonotonicTime after = MonotonicTime::now();
ParseHash hash(source);
dataLogLn(result ? "Parsed #" : "Failed to parse #", hash.hashForCall(), "/#", hash.hashForConstruct(), " in ", (after - before).milliseconds(), " ms.");
}

return result;
}

template <class ParsedNode>
std::unique_ptr<ParsedNode> parseRootNode(
VM& vm, const SourceCode& source,
ImplementationVisibility implementationVisibility, JSParserBuiltinMode builtinMode,
JSParserStrictMode strictMode, JSParserScriptMode scriptMode, SourceParseMode parseMode,
ParserError& error,
ConstructorKind constructorKindForTopLevelFunctionExpressions = ConstructorKind::None,
JSTextPosition* positionBeforeLastNewline = nullptr,
DebuggerParseData* debuggerParseData = nullptr)
{
static_assert(std::is_same_v<ParsedNode, ProgramNode> || std::is_same_v<ParsedNode, ModuleProgramNode>);
ASSERT(!source.provider()->source().isNull());

MonotonicTime before;
if (UNLIKELY(Options::reportParseTimes()))
before = MonotonicTime::now();

Identifier name;
bool isEvalNode = false;
bool isInsideOrdinaryFunction = false;
std::unique_ptr<ParsedNode> result;
if (source.provider()->source().is8Bit()) {
Parser<Lexer<LChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, FunctionMode::None, SuperBinding::NotNeeded, ConstructorKind::None, DerivedContextType::None, isEvalNode, EvalContextType::None, debuggerParseData, isInsideOrdinaryFunction);
parser.overrideConstructorKindForTopLevelFunctionExpressions(constructorKindForTopLevelFunctionExpressions);
result = parser.parse<ParsedNode>(error, name, ParsingContext::Normal);
if (positionBeforeLastNewline)
*positionBeforeLastNewline = parser.positionBeforeLastNewline();
} else {
ASSERT_WITH_MESSAGE(!positionBeforeLastNewline, "BuiltinExecutables should always use a 8-bit string");
ASSERT_WITH_MESSAGE(constructorKindForTopLevelFunctionExpressions == ConstructorKind::None, "BuiltinExecutables' special constructors should always use a 8-bit string");
Parser<Lexer<UChar>> parser(vm, source, implementationVisibility, builtinMode, strictMode, scriptMode, parseMode, FunctionMode::None, SuperBinding::NotNeeded, ConstructorKind::None, DerivedContextType::None, isEvalNode, EvalContextType::None, debuggerParseData, isInsideOrdinaryFunction);
result = parser.parse<ParsedNode>(error, name, ParsingContext::Normal);
}

if (UNLIKELY(Options::countParseTimes()))
Expand Down
2 changes: 1 addition & 1 deletion Source/JavaScriptCore/runtime/CodeCache.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,7 +80,7 @@ UnlinkedCodeBlockType* generateUnlinkedCodeBlockImpl(VM& vm, const SourceCode& s
bool isInsideOrdinaryFunction = executable && executable->isInsideOrdinaryFunction();

std::unique_ptr<RootNode> rootNode = parse<RootNode>(
vm, source, Identifier(), ImplementationVisibility::Public, JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, FunctionMode::None, SuperBinding::NotNeeded, error, nullptr, ConstructorKind::None, derivedContextType, evalContextType, nullptr, privateNameEnvironment, nullptr, isInsideOrdinaryFunction);
vm, source, Identifier(), ImplementationVisibility::Public, JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, CacheTypes<UnlinkedCodeBlockType>::parseMode, FunctionMode::None, SuperBinding::NotNeeded, error, ConstructorKind::None, derivedContextType, evalContextType, privateNameEnvironment, nullptr, isInsideOrdinaryFunction);

if (!rootNode)
return nullptr;
Expand Down
Loading

0 comments on commit 3ba5278

Please sign in to comment.