mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-04 14:58:37 +09:00
Stage 1-1: Implement Function.prototype.toString revision proposal.
Tag #960
This commit is contained in:
wolfbeast
Roy Tam
parent
c439386fcb
commit
b68de773fd
13 changed files with 330 additions and 154 deletions
|
|
@ -441,7 +441,8 @@ UsedNameTracker::rewind(RewindToken token)
|
|||
}
|
||||
|
||||
FunctionBox::FunctionBox(ExclusiveContext* cx, LifoAlloc& alloc, ObjectBox* traceListHead,
|
||||
JSFunction* fun, Directives directives, bool extraWarnings,
|
||||
JSFunction* fun, uint32_t preludeStart,
|
||||
Directives directives, bool extraWarnings,
|
||||
GeneratorKind generatorKind, FunctionAsyncKind asyncKind)
|
||||
: ObjectBox(fun, traceListHead),
|
||||
SharedContext(cx, Kind::ObjectBox, directives, extraWarnings),
|
||||
|
|
@ -454,6 +455,7 @@ FunctionBox::FunctionBox(ExclusiveContext* cx, LifoAlloc& alloc, ObjectBox* trac
|
|||
bufEnd(0),
|
||||
startLine(1),
|
||||
startColumn(0),
|
||||
preludeStart(preludeStart),
|
||||
length(0),
|
||||
generatorKindBits_(GeneratorKindAsBits(generatorKind)),
|
||||
asyncKindBits_(AsyncKindAsBits(asyncKind)),
|
||||
|
|
@ -738,7 +740,8 @@ Parser<ParseHandler>::newObjectBox(JSObject* obj)
|
|||
|
||||
template <typename ParseHandler>
|
||||
FunctionBox*
|
||||
Parser<ParseHandler>::newFunctionBox(Node fn, JSFunction* fun, Directives inheritedDirectives,
|
||||
Parser<ParseHandler>::newFunctionBox(Node fn, JSFunction* fun, uint32_t preludeStart,
|
||||
Directives inheritedDirectives,
|
||||
GeneratorKind generatorKind, FunctionAsyncKind asyncKind,
|
||||
bool tryAnnexB)
|
||||
{
|
||||
|
|
@ -753,8 +756,9 @@ Parser<ParseHandler>::newFunctionBox(Node fn, JSFunction* fun, Directives inheri
|
|||
* function.
|
||||
*/
|
||||
FunctionBox* funbox =
|
||||
alloc.new_<FunctionBox>(context, alloc, traceListHead, fun, inheritedDirectives,
|
||||
options().extraWarningsOption, generatorKind, asyncKind);
|
||||
alloc.new_<FunctionBox>(context, alloc, traceListHead, fun, preludeStart,
|
||||
inheritedDirectives, options().extraWarningsOption,
|
||||
generatorKind, asyncKind);
|
||||
if (!funbox) {
|
||||
ReportOutOfMemory(context);
|
||||
return nullptr;
|
||||
|
|
@ -2214,6 +2218,7 @@ Parser<SyntaxParseHandler>::finishFunction()
|
|||
LazyScript* lazy = LazyScript::Create(context, fun, pc->closedOverBindingsForLazy(),
|
||||
pc->innerFunctionsForLazy, versionNumber(),
|
||||
funbox->bufStart, funbox->bufEnd,
|
||||
funbox->preludeStart,
|
||||
funbox->startLine, funbox->startColumn);
|
||||
if (!lazy)
|
||||
return false;
|
||||
|
|
@ -2267,6 +2272,33 @@ Parser<FullParseHandler>::standaloneFunction(HandleFunction fun,
|
|||
{
|
||||
MOZ_ASSERT(checkOptionsCalled);
|
||||
|
||||
// Skip prelude.
|
||||
TokenKind tt;
|
||||
if (!tokenStream.getToken(&tt))
|
||||
return null();
|
||||
if (asyncKind == AsyncFunction) {
|
||||
MOZ_ASSERT(tt == TOK_ASYNC);
|
||||
if (!tokenStream.getToken(&tt))
|
||||
return null();
|
||||
}
|
||||
MOZ_ASSERT(tt == TOK_FUNCTION);
|
||||
|
||||
if (!tokenStream.getToken(&tt))
|
||||
return null();
|
||||
if (generatorKind == StarGenerator && asyncKind == SyncFunction) {
|
||||
MOZ_ASSERT(tt == TOK_MUL);
|
||||
if (!tokenStream.getToken(&tt))
|
||||
return null();
|
||||
}
|
||||
|
||||
// Skip function name, if present.
|
||||
if (tt == TOK_NAME || tt == TOK_YIELD) {
|
||||
MOZ_ASSERT(tokenStream.currentName() == fun->explicitName());
|
||||
} else {
|
||||
MOZ_ASSERT(fun->explicitName() == nullptr);
|
||||
tokenStream.ungetToken();
|
||||
}
|
||||
|
||||
Node fn = handler.newFunctionDefinition();
|
||||
if (!fn)
|
||||
return null();
|
||||
|
|
@ -2276,8 +2308,8 @@ Parser<FullParseHandler>::standaloneFunction(HandleFunction fun,
|
|||
return null();
|
||||
fn->pn_body = argsbody;
|
||||
|
||||
FunctionBox* funbox = newFunctionBox(fn, fun, inheritedDirectives, generatorKind,
|
||||
asyncKind, /* tryAnnexB = */ false);
|
||||
FunctionBox* funbox = newFunctionBox(fn, fun, /* preludeStart = */ 0, inheritedDirectives,
|
||||
generatorKind, asyncKind, /* tryAnnexB = */ false);
|
||||
if (!funbox)
|
||||
return null();
|
||||
funbox->initStandaloneFunction(enclosingScope);
|
||||
|
|
@ -2295,7 +2327,6 @@ Parser<FullParseHandler>::standaloneFunction(HandleFunction fun,
|
|||
return null();
|
||||
}
|
||||
|
||||
TokenKind tt;
|
||||
if (!tokenStream.getToken(&tt, TokenStream::Operand))
|
||||
return null();
|
||||
if (tt != TOK_EOF) {
|
||||
|
|
@ -2991,8 +3022,8 @@ Parser<ParseHandler>::checkFunctionDefinition(HandleAtom funAtom, Node pn, Funct
|
|||
|
||||
template <>
|
||||
bool
|
||||
Parser<FullParseHandler>::skipLazyInnerFunction(ParseNode* pn, FunctionSyntaxKind kind,
|
||||
bool tryAnnexB)
|
||||
Parser<FullParseHandler>::skipLazyInnerFunction(ParseNode* pn, uint32_t preludeStart,
|
||||
FunctionSyntaxKind kind, bool tryAnnexB)
|
||||
{
|
||||
// When a lazily-parsed function is called, we only fully parse (and emit)
|
||||
// that function, not any of its nested children. The initial syntax-only
|
||||
|
|
@ -3001,7 +3032,7 @@ Parser<FullParseHandler>::skipLazyInnerFunction(ParseNode* pn, FunctionSyntaxKin
|
|||
|
||||
RootedFunction fun(context, handler.nextLazyInnerFunction());
|
||||
MOZ_ASSERT(!fun->isLegacyGenerator());
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, Directives(/* strict = */ false),
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, preludeStart, Directives(/* strict = */ false),
|
||||
fun->generatorKind(), fun->asyncKind(), tryAnnexB);
|
||||
if (!funbox)
|
||||
return false;
|
||||
|
|
@ -3031,8 +3062,8 @@ Parser<FullParseHandler>::skipLazyInnerFunction(ParseNode* pn, FunctionSyntaxKin
|
|||
|
||||
template <>
|
||||
bool
|
||||
Parser<SyntaxParseHandler>::skipLazyInnerFunction(Node pn, FunctionSyntaxKind kind,
|
||||
bool tryAnnexB)
|
||||
Parser<SyntaxParseHandler>::skipLazyInnerFunction(Node pn, uint32_t preludeStart,
|
||||
FunctionSyntaxKind kind, bool tryAnnexB)
|
||||
{
|
||||
MOZ_CRASH("Cannot skip lazy inner functions when syntax parsing");
|
||||
}
|
||||
|
|
@ -3108,7 +3139,8 @@ Parser<ParseHandler>::templateLiteral(YieldHandling yieldHandling)
|
|||
|
||||
template <typename ParseHandler>
|
||||
typename ParseHandler::Node
|
||||
Parser<ParseHandler>::functionDefinition(InHandling inHandling, YieldHandling yieldHandling,
|
||||
Parser<ParseHandler>::functionDefinition(uint32_t preludeStart, InHandling inHandling,
|
||||
YieldHandling yieldHandling,
|
||||
HandleAtom funName, FunctionSyntaxKind kind,
|
||||
GeneratorKind generatorKind, FunctionAsyncKind asyncKind,
|
||||
InvokedPrediction invoked)
|
||||
|
|
@ -3132,7 +3164,7 @@ Parser<ParseHandler>::functionDefinition(InHandling inHandling, YieldHandling yi
|
|||
// functions, which are also lazy. Instead, their free variables and
|
||||
// source extents are recorded and may be skipped.
|
||||
if (handler.canSkipLazyInnerFunctions()) {
|
||||
if (!skipLazyInnerFunction(pn, kind, tryAnnexB))
|
||||
if (!skipLazyInnerFunction(pn, preludeStart, kind, tryAnnexB))
|
||||
return null();
|
||||
return pn;
|
||||
}
|
||||
|
|
@ -3165,8 +3197,9 @@ Parser<ParseHandler>::functionDefinition(InHandling inHandling, YieldHandling yi
|
|||
// reparse a function due to failed syntax parsing and encountering new
|
||||
// "use foo" directives.
|
||||
while (true) {
|
||||
if (trySyntaxParseInnerFunction(pn, fun, inHandling, yieldHandling, kind, generatorKind,
|
||||
asyncKind, tryAnnexB, directives, &newDirectives))
|
||||
if (trySyntaxParseInnerFunction(pn, fun, preludeStart, inHandling, yieldHandling, kind,
|
||||
generatorKind, asyncKind, tryAnnexB, directives,
|
||||
&newDirectives))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
@ -3193,6 +3226,7 @@ Parser<ParseHandler>::functionDefinition(InHandling inHandling, YieldHandling yi
|
|||
template <>
|
||||
bool
|
||||
Parser<FullParseHandler>::trySyntaxParseInnerFunction(ParseNode* pn, HandleFunction fun,
|
||||
uint32_t preludeStart,
|
||||
InHandling inHandling,
|
||||
YieldHandling yieldHandling,
|
||||
FunctionSyntaxKind kind,
|
||||
|
|
@ -3226,14 +3260,15 @@ Parser<FullParseHandler>::trySyntaxParseInnerFunction(ParseNode* pn, HandleFunct
|
|||
// Make a FunctionBox before we enter the syntax parser, because |pn|
|
||||
// still expects a FunctionBox to be attached to it during BCE, and
|
||||
// the syntax parser cannot attach one to it.
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, inheritedDirectives, generatorKind,
|
||||
asyncKind, tryAnnexB);
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, preludeStart, inheritedDirectives,
|
||||
generatorKind, asyncKind, tryAnnexB);
|
||||
if (!funbox)
|
||||
return false;
|
||||
funbox->initWithEnclosingParseContext(pc, kind);
|
||||
|
||||
if (!parser->innerFunction(SyntaxParseHandler::NodeGeneric, pc, funbox, inHandling,
|
||||
yieldHandling, kind, inheritedDirectives, newDirectives))
|
||||
if (!parser->innerFunction(SyntaxParseHandler::NodeGeneric, pc, funbox, preludeStart,
|
||||
inHandling, yieldHandling, kind,
|
||||
inheritedDirectives, newDirectives))
|
||||
{
|
||||
if (parser->hadAbortedSyntaxParse()) {
|
||||
// Try again with a full parse. UsedNameTracker needs to be
|
||||
|
|
@ -3259,13 +3294,14 @@ Parser<FullParseHandler>::trySyntaxParseInnerFunction(ParseNode* pn, HandleFunct
|
|||
} while (false);
|
||||
|
||||
// We failed to do a syntax parse above, so do the full parse.
|
||||
return innerFunction(pn, pc, fun, inHandling, yieldHandling, kind, generatorKind, asyncKind,
|
||||
tryAnnexB, inheritedDirectives, newDirectives);
|
||||
return innerFunction(pn, pc, fun, preludeStart, inHandling, yieldHandling, kind,
|
||||
generatorKind, asyncKind, tryAnnexB, inheritedDirectives, newDirectives);
|
||||
}
|
||||
|
||||
template <>
|
||||
bool
|
||||
Parser<SyntaxParseHandler>::trySyntaxParseInnerFunction(Node pn, HandleFunction fun,
|
||||
uint32_t preludeStart,
|
||||
InHandling inHandling,
|
||||
YieldHandling yieldHandling,
|
||||
FunctionSyntaxKind kind,
|
||||
|
|
@ -3276,13 +3312,14 @@ Parser<SyntaxParseHandler>::trySyntaxParseInnerFunction(Node pn, HandleFunction
|
|||
Directives* newDirectives)
|
||||
{
|
||||
// This is already a syntax parser, so just parse the inner function.
|
||||
return innerFunction(pn, pc, fun, inHandling, yieldHandling, kind, generatorKind, asyncKind,
|
||||
tryAnnexB, inheritedDirectives, newDirectives);
|
||||
return innerFunction(pn, pc, fun, preludeStart, inHandling, yieldHandling, kind,
|
||||
generatorKind, asyncKind, tryAnnexB, inheritedDirectives, newDirectives);
|
||||
}
|
||||
|
||||
template <typename ParseHandler>
|
||||
bool
|
||||
Parser<ParseHandler>::innerFunction(Node pn, ParseContext* outerpc, FunctionBox* funbox,
|
||||
uint32_t preludeStart,
|
||||
InHandling inHandling, YieldHandling yieldHandling,
|
||||
FunctionSyntaxKind kind, Directives inheritedDirectives,
|
||||
Directives* newDirectives)
|
||||
|
|
@ -3306,6 +3343,7 @@ Parser<ParseHandler>::innerFunction(Node pn, ParseContext* outerpc, FunctionBox*
|
|||
template <typename ParseHandler>
|
||||
bool
|
||||
Parser<ParseHandler>::innerFunction(Node pn, ParseContext* outerpc, HandleFunction fun,
|
||||
uint32_t preludeStart,
|
||||
InHandling inHandling, YieldHandling yieldHandling,
|
||||
FunctionSyntaxKind kind,
|
||||
GeneratorKind generatorKind, FunctionAsyncKind asyncKind,
|
||||
|
|
@ -3317,14 +3355,14 @@ Parser<ParseHandler>::innerFunction(Node pn, ParseContext* outerpc, HandleFuncti
|
|||
// parser. In that case, outerpc is a ParseContext from the full parser
|
||||
// instead of the current top of the stack of the syntax parser.
|
||||
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, inheritedDirectives, generatorKind,
|
||||
asyncKind, tryAnnexB);
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, preludeStart, inheritedDirectives,
|
||||
generatorKind, asyncKind, tryAnnexB);
|
||||
if (!funbox)
|
||||
return false;
|
||||
funbox->initWithEnclosingParseContext(outerpc, kind);
|
||||
|
||||
return innerFunction(pn, outerpc, funbox, inHandling, yieldHandling, kind, inheritedDirectives,
|
||||
newDirectives);
|
||||
return innerFunction(pn, outerpc, funbox, preludeStart, inHandling, yieldHandling, kind,
|
||||
inheritedDirectives, newDirectives);
|
||||
}
|
||||
|
||||
template <typename ParseHandler>
|
||||
|
|
@ -3359,8 +3397,8 @@ Parser<FullParseHandler>::standaloneLazyFunction(HandleFunction fun, bool strict
|
|||
return null();
|
||||
|
||||
Directives directives(strict);
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, directives, generatorKind, asyncKind,
|
||||
/* tryAnnexB = */ false);
|
||||
FunctionBox* funbox = newFunctionBox(pn, fun, /* preludeStart = */ 0, directives,
|
||||
generatorKind, asyncKind, /* tryAnnexB = */ false);
|
||||
if (!funbox)
|
||||
return null();
|
||||
funbox->initFromLazyFunction();
|
||||
|
|
@ -3529,8 +3567,8 @@ Parser<ParseHandler>::functionFormalParametersAndBody(InHandling inHandling,
|
|||
|
||||
template <typename ParseHandler>
|
||||
typename ParseHandler::Node
|
||||
Parser<ParseHandler>::functionStmt(YieldHandling yieldHandling, DefaultHandling defaultHandling,
|
||||
FunctionAsyncKind asyncKind)
|
||||
Parser<ParseHandler>::functionStmt(uint32_t preludeStart, YieldHandling yieldHandling,
|
||||
DefaultHandling defaultHandling, FunctionAsyncKind asyncKind)
|
||||
{
|
||||
MOZ_ASSERT(tokenStream.isCurrentTokenType(TOK_FUNCTION));
|
||||
|
||||
|
|
@ -3579,8 +3617,8 @@ Parser<ParseHandler>::functionStmt(YieldHandling yieldHandling, DefaultHandling
|
|||
}
|
||||
|
||||
YieldHandling newYieldHandling = GetYieldHandling(generatorKind, asyncKind);
|
||||
Node fun = functionDefinition(InAllowed, newYieldHandling, name, Statement, generatorKind,
|
||||
asyncKind, PredictUninvoked);
|
||||
Node fun = functionDefinition(preludeStart, InAllowed, newYieldHandling, name, Statement,
|
||||
generatorKind, asyncKind, PredictUninvoked);
|
||||
if (!fun)
|
||||
return null();
|
||||
|
||||
|
|
@ -3597,7 +3635,8 @@ Parser<ParseHandler>::functionStmt(YieldHandling yieldHandling, DefaultHandling
|
|||
|
||||
template <typename ParseHandler>
|
||||
typename ParseHandler::Node
|
||||
Parser<ParseHandler>::functionExpr(InvokedPrediction invoked, FunctionAsyncKind asyncKind)
|
||||
Parser<ParseHandler>::functionExpr(uint32_t preludeStart, InvokedPrediction invoked,
|
||||
FunctionAsyncKind asyncKind)
|
||||
{
|
||||
MOZ_ASSERT(tokenStream.isCurrentTokenType(TOK_FUNCTION));
|
||||
|
||||
|
|
@ -3628,8 +3667,8 @@ Parser<ParseHandler>::functionExpr(InvokedPrediction invoked, FunctionAsyncKind
|
|||
tokenStream.ungetToken();
|
||||
}
|
||||
|
||||
return functionDefinition(InAllowed, yieldHandling, name, Expression, generatorKind,
|
||||
asyncKind, invoked);
|
||||
return functionDefinition(preludeStart, InAllowed, yieldHandling, name, Expression,
|
||||
generatorKind, asyncKind, invoked);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -5074,7 +5113,7 @@ Parser<FullParseHandler>::exportDeclaration()
|
|||
}
|
||||
|
||||
case TOK_FUNCTION:
|
||||
kid = functionStmt(YieldIsKeyword, NameRequired);
|
||||
kid = functionStmt(pos().begin, YieldIsKeyword, NameRequired);
|
||||
if (!kid)
|
||||
return null();
|
||||
|
||||
|
|
@ -5114,7 +5153,7 @@ Parser<FullParseHandler>::exportDeclaration()
|
|||
ParseNode* nameNode = nullptr;
|
||||
switch (tt) {
|
||||
case TOK_FUNCTION:
|
||||
kid = functionStmt(YieldIsKeyword, AllowDefaultName);
|
||||
kid = functionStmt(pos().begin, YieldIsKeyword, AllowDefaultName);
|
||||
if (!kid)
|
||||
return null();
|
||||
break;
|
||||
|
|
@ -5131,7 +5170,7 @@ Parser<FullParseHandler>::exportDeclaration()
|
|||
|
||||
if (nextSameLine == TOK_FUNCTION) {
|
||||
tokenStream.consumeKnownToken(nextSameLine);
|
||||
kid = functionStmt(YieldIsName, AllowDefaultName, AsyncFunction);
|
||||
kid = functionStmt(pos().begin, YieldIsName, AllowDefaultName, AsyncFunction);
|
||||
if (!kid)
|
||||
return null();
|
||||
break;
|
||||
|
|
@ -5232,7 +5271,7 @@ Parser<ParseHandler>::consequentOrAlternative(YieldHandling yieldHandling)
|
|||
// will report the strict mode error.
|
||||
if (!pc->sc()->strict()) {
|
||||
tokenStream.consumeKnownToken(next, TokenStream::Operand);
|
||||
return functionStmt(yieldHandling, NameRequired);
|
||||
return functionStmt(pos().begin, yieldHandling, NameRequired);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -6182,7 +6221,7 @@ Parser<ParseHandler>::labeledItem(YieldHandling yieldHandling)
|
|||
return null();
|
||||
}
|
||||
|
||||
return functionStmt(yieldHandling, NameRequired);
|
||||
return functionStmt(pos().begin, yieldHandling, NameRequired);
|
||||
}
|
||||
|
||||
tokenStream.ungetToken();
|
||||
|
|
@ -6649,6 +6688,10 @@ Parser<ParseHandler>::classDefinition(YieldHandling yieldHandling,
|
|||
tokenStream.ungetToken();
|
||||
}
|
||||
|
||||
uint32_t nameOffset;
|
||||
if (!tokenStream.peekOffset(&nameOffset))
|
||||
return null();
|
||||
|
||||
PropertyType propType;
|
||||
Node propName = propertyName(yieldHandling, classMethods, &propType, &propAtom);
|
||||
if (!propName)
|
||||
|
|
@ -6701,7 +6744,7 @@ Parser<ParseHandler>::classDefinition(YieldHandling yieldHandling,
|
|||
if (!tokenStream.isCurrentTokenType(TOK_RB))
|
||||
funName = propAtom;
|
||||
}
|
||||
Node fn = methodDefinition(propType, funName);
|
||||
Node fn = methodDefinition(nameOffset, propType, funName);
|
||||
if (!fn)
|
||||
return null();
|
||||
|
||||
|
|
@ -7094,8 +7137,9 @@ Parser<ParseHandler>::statementListItem(YieldHandling yieldHandling,
|
|||
if (!tokenStream.peekTokenSameLine(&nextSameLine))
|
||||
return null();
|
||||
if (nextSameLine == TOK_FUNCTION) {
|
||||
uint32_t preludeStart = pos().begin;
|
||||
tokenStream.consumeKnownToken(TOK_FUNCTION);
|
||||
return functionStmt(yieldHandling, NameRequired, AsyncFunction);
|
||||
return functionStmt(preludeStart, yieldHandling, NameRequired, AsyncFunction);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -7174,7 +7218,7 @@ Parser<ParseHandler>::statementListItem(YieldHandling yieldHandling,
|
|||
|
||||
// HoistableDeclaration[?Yield, ~Default]
|
||||
case TOK_FUNCTION:
|
||||
return functionStmt(yieldHandling, NameRequired);
|
||||
return functionStmt(pos().begin, yieldHandling, NameRequired);
|
||||
|
||||
// ClassDeclaration[?Yield, ~Default]
|
||||
case TOK_CLASS:
|
||||
|
|
@ -7677,8 +7721,10 @@ Parser<ParseHandler>::assignExpr(InHandling inHandling, YieldHandling yieldHandl
|
|||
|
||||
tokenStream.seek(start);
|
||||
|
||||
if (!tokenStream.peekToken(&next, TokenStream::Operand))
|
||||
if (!tokenStream.getToken(&next, TokenStream::Operand))
|
||||
return null();
|
||||
uint32_t preludeStart = pos().begin;
|
||||
tokenStream.ungetToken();
|
||||
|
||||
GeneratorKind generatorKind = NotGenerator;
|
||||
FunctionAsyncKind asyncKind = SyncFunction;
|
||||
|
|
@ -7702,7 +7748,7 @@ Parser<ParseHandler>::assignExpr(InHandling inHandling, YieldHandling yieldHandl
|
|||
}
|
||||
}
|
||||
|
||||
Node arrowFunc = functionDefinition(inHandling, yieldHandling, nullptr,
|
||||
Node arrowFunc = functionDefinition(preludeStart, inHandling, yieldHandling, nullptr,
|
||||
Arrow, generatorKind, asyncKind);
|
||||
if (!arrowFunc)
|
||||
return null();
|
||||
|
|
@ -8054,8 +8100,8 @@ Parser<ParseHandler>::generatorComprehensionLambda(unsigned begin)
|
|||
|
||||
// Create box for fun->object early to root it.
|
||||
Directives directives(/* strict = */ outerpc->sc()->strict());
|
||||
FunctionBox* genFunbox = newFunctionBox(genfn, fun, directives, StarGenerator, SyncFunction,
|
||||
/* tryAnnexB = */ false);
|
||||
FunctionBox* genFunbox = newFunctionBox(genfn, fun, /* preludeStart = */ 0, directives,
|
||||
StarGenerator, SyncFunction, /* tryAnnexB = */ false);
|
||||
if (!genFunbox)
|
||||
return null();
|
||||
genFunbox->isGenexpLambda = true;
|
||||
|
|
@ -8087,12 +8133,14 @@ Parser<ParseHandler>::generatorComprehensionLambda(unsigned begin)
|
|||
|
||||
MUST_MATCH_TOKEN(TOK_RP, JSMSG_PAREN_IN_PAREN);
|
||||
|
||||
uint32_t end = pos().end;
|
||||
handler.setBeginPosition(comp, begin);
|
||||
handler.setEndPosition(comp, pos().end);
|
||||
handler.setEndPosition(comp, end);
|
||||
genFunbox->bufEnd = end;
|
||||
handler.addStatementToList(body, comp);
|
||||
handler.setEndPosition(body, pos().end);
|
||||
handler.setEndPosition(body, end);
|
||||
handler.setBeginPosition(genfn, begin);
|
||||
handler.setEndPosition(genfn, pos().end);
|
||||
handler.setEndPosition(genfn, end);
|
||||
|
||||
Node generator = newDotGeneratorName();
|
||||
if (!generator)
|
||||
|
|
@ -9158,6 +9206,8 @@ Parser<ParseHandler>::objectLiteral(YieldHandling yieldHandling, PossibleError*
|
|||
if (tt == TOK_RC)
|
||||
break;
|
||||
|
||||
TokenPos namePos = pos();
|
||||
|
||||
tokenStream.ungetToken();
|
||||
|
||||
PropertyType propType;
|
||||
|
|
@ -9309,7 +9359,7 @@ Parser<ParseHandler>::objectLiteral(YieldHandling yieldHandling, PossibleError*
|
|||
}
|
||||
}
|
||||
|
||||
Node fn = methodDefinition(propType, funName);
|
||||
Node fn = methodDefinition(namePos.begin, propType, funName);
|
||||
if (!fn)
|
||||
return null();
|
||||
|
||||
|
|
@ -9336,13 +9386,15 @@ Parser<ParseHandler>::objectLiteral(YieldHandling yieldHandling, PossibleError*
|
|||
|
||||
template <typename ParseHandler>
|
||||
typename ParseHandler::Node
|
||||
Parser<ParseHandler>::methodDefinition(PropertyType propType, HandleAtom funName)
|
||||
Parser<ParseHandler>::methodDefinition(uint32_t preludeStart, PropertyType propType,
|
||||
HandleAtom funName)
|
||||
{
|
||||
FunctionSyntaxKind kind = FunctionSyntaxKindFromPropertyType(propType);
|
||||
GeneratorKind generatorKind = GeneratorKindFromPropertyType(propType);
|
||||
FunctionAsyncKind asyncKind = AsyncKindFromPropertyType(propType);
|
||||
YieldHandling yieldHandling = GetYieldHandling(generatorKind, asyncKind);
|
||||
return functionDefinition(InAllowed, yieldHandling, funName, kind, generatorKind, asyncKind);
|
||||
return functionDefinition(preludeStart, InAllowed, yieldHandling, funName, kind,
|
||||
generatorKind, asyncKind);
|
||||
}
|
||||
|
||||
template <typename ParseHandler>
|
||||
|
|
@ -9404,7 +9456,7 @@ Parser<ParseHandler>::primaryExpr(YieldHandling yieldHandling, TripledotHandling
|
|||
|
||||
switch (tt) {
|
||||
case TOK_FUNCTION:
|
||||
return functionExpr(invoked);
|
||||
return functionExpr(pos().begin, invoked);
|
||||
|
||||
case TOK_CLASS:
|
||||
return classDefinition(yieldHandling, ClassExpression, NameRequired);
|
||||
|
|
@ -9471,8 +9523,9 @@ Parser<ParseHandler>::primaryExpr(YieldHandling yieldHandling, TripledotHandling
|
|||
return null();
|
||||
|
||||
if (nextSameLine == TOK_FUNCTION) {
|
||||
uint32_t preludeStart = pos().begin;
|
||||
tokenStream.consumeKnownToken(TOK_FUNCTION);
|
||||
return functionExpr(PredictUninvoked, AsyncFunction);
|
||||
return functionExpr(preludeStart, PredictUninvoked, AsyncFunction);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue