From 53e5c09b5ddc18922d1e330bf0a594478a94dd2a Mon Sep 17 00:00:00 2001 From: Tom Schuster Date: Fri, 6 Apr 2018 20:56:30 +0200 Subject: [PATCH] Bug 1453006 - Convert FunctionSyntaxKind to an enum class. r=jandem --HG-- extra : rebase_source : f467d26137e21c9b586abea4d2c6bc26ef1f8368 --- js/src/frontend/BinSource.cpp | 2 +- js/src/frontend/ParseNode.h | 11 ++-- js/src/frontend/Parser.cpp | 100 ++++++++++++++++++---------------- js/src/wasm/AsmJS.cpp | 6 +- 4 files changed, 65 insertions(+), 54 deletions(-) diff --git a/js/src/frontend/BinSource.cpp b/js/src/frontend/BinSource.cpp index 9108b918e955..de9362003335 100644 --- a/js/src/frontend/BinSource.cpp +++ b/js/src/frontend/BinSource.cpp @@ -189,7 +189,7 @@ BinASTParser::buildFunctionBox(GeneratorKind generatorKind, FunctionAsyncKind fu functionAsyncKind)); traceListHead_ = funbox; - FunctionSyntaxKind syntax = Expression; // FIXME - What if we're assigning? + FunctionSyntaxKind syntax = FunctionSyntaxKind::Expression; // FIXME - What if we're assigning? // FIXME: The only thing we need to know is whether this is a // ClassConstructor/DerivedClassConstructor funbox->initWithEnclosingParseContext(parseContext_, syntax); diff --git a/js/src/frontend/ParseNode.h b/js/src/frontend/ParseNode.h index 8c993e8cb748..64621b626be8 100644 --- a/js/src/frontend/ParseNode.h +++ b/js/src/frontend/ParseNode.h @@ -1438,7 +1438,7 @@ AccessorTypeToJSOp(AccessorType atype) } } -enum FunctionSyntaxKind +enum class FunctionSyntaxKind { // A non-arrow function expression. Expression, @@ -1457,14 +1457,17 @@ enum FunctionSyntaxKind static inline bool IsConstructorKind(FunctionSyntaxKind kind) { - return kind == ClassConstructor || kind == DerivedClassConstructor; + return kind == FunctionSyntaxKind::ClassConstructor || + kind == FunctionSyntaxKind::DerivedClassConstructor; } static inline bool IsMethodDefinitionKind(FunctionSyntaxKind kind) { - return kind == Method || IsConstructorKind(kind) || - kind == Getter || kind == Setter; + return IsConstructorKind(kind) || + kind == FunctionSyntaxKind::Method || + kind == FunctionSyntaxKind::Getter || + kind == FunctionSyntaxKind::Setter; } static inline ParseNode* diff --git a/js/src/frontend/Parser.cpp b/js/src/frontend/Parser.cpp index 26accf604007..975e61d528fb 100644 --- a/js/src/frontend/Parser.cpp +++ b/js/src/frontend/Parser.cpp @@ -542,12 +542,12 @@ FunctionBox::initWithEnclosingParseContext(ParseContext* enclosing, FunctionSynt allowNewTarget_ = true; allowSuperProperty_ = fun->allowSuperProperty(); - if (kind == ClassConstructor || kind == DerivedClassConstructor) { + if (IsConstructorKind(kind)) { auto stmt = enclosing->findInnermostStatement(); MOZ_ASSERT(stmt); stmt->constructorBox = this; - if (kind == DerivedClassConstructor) { + if (kind == FunctionSyntaxKind::DerivedClassConstructor) { setDerivedClassConstructor(); allowSuperCall_ = true; needsThisTDZChecks_ = true; @@ -2598,7 +2598,7 @@ Parser::standaloneFunction(HandleFunction fun, YieldHandling yieldHandling = GetYieldHandling(generatorKind); AwaitHandling awaitHandling = GetAwaitHandling(asyncKind); AutoAwaitIsKeyword awaitIsKeyword(this, awaitHandling); - if (!functionFormalParametersAndBody(InAllowed, yieldHandling, &fn, Statement, + if (!functionFormalParametersAndBody(InAllowed, yieldHandling, &fn, FunctionSyntaxKind::Statement, parameterListEnd, /* isStandaloneFunction = */ true)) { return null(); @@ -2752,7 +2752,7 @@ GeneralParser::functionBody(InHandling inHandling, } MOZ_ASSERT_IF(!pc->isGenerator() && !pc->isAsync(), pc->lastYieldOffset == startYieldOffset); - MOZ_ASSERT_IF(pc->isGenerator(), kind != Arrow); + MOZ_ASSERT_IF(pc->isGenerator(), kind != FunctionSyntaxKind::Arrow); MOZ_ASSERT_IF(pc->isGenerator(), type == StatementListBody); if (pc->needsDotGeneratorName()) { @@ -2769,7 +2769,7 @@ GeneralParser::functionBody(InHandling inHandling, // Declare the 'arguments' and 'this' bindings if necessary before // finishing up the scope so these special bindings get marked as closed // over if necessary. Arrow functions don't have these bindings. - if (kind != Arrow) { + if (kind != FunctionSyntaxKind::Arrow) { if (!declareFunctionArgumentsObject()) return null(); if (!declareFunctionThis()) @@ -2784,7 +2784,7 @@ ParserBase::newFunction(HandleAtom atom, FunctionSyntaxKind kind, GeneratorKind generatorKind, FunctionAsyncKind asyncKind, HandleObject proto) { - MOZ_ASSERT_IF(kind == Statement, atom != nullptr); + MOZ_ASSERT_IF(kind == FunctionSyntaxKind::Statement, atom != nullptr); RootedFunction fun(context); @@ -2794,38 +2794,38 @@ ParserBase::newFunction(HandleAtom atom, FunctionSyntaxKind kind, bool isGlobalSelfHostedBuiltin = false; #endif switch (kind) { - case Expression: + case FunctionSyntaxKind::Expression: flags = (generatorKind == GeneratorKind::NotGenerator && asyncKind == FunctionAsyncKind::SyncFunction ? JSFunction::INTERPRETED_LAMBDA : JSFunction::INTERPRETED_LAMBDA_GENERATOR_OR_ASYNC); break; - case Arrow: + case FunctionSyntaxKind::Arrow: flags = JSFunction::INTERPRETED_LAMBDA_ARROW; allocKind = gc::AllocKind::FUNCTION_EXTENDED; break; - case Method: + case FunctionSyntaxKind::Method: flags = (generatorKind == GeneratorKind::NotGenerator && asyncKind == FunctionAsyncKind::SyncFunction ? JSFunction::INTERPRETED_METHOD : JSFunction::INTERPRETED_METHOD_GENERATOR_OR_ASYNC); allocKind = gc::AllocKind::FUNCTION_EXTENDED; break; - case ClassConstructor: - case DerivedClassConstructor: + case FunctionSyntaxKind::ClassConstructor: + case FunctionSyntaxKind::DerivedClassConstructor: flags = JSFunction::INTERPRETED_CLASS_CONSTRUCTOR; allocKind = gc::AllocKind::FUNCTION_EXTENDED; break; - case Getter: + case FunctionSyntaxKind::Getter: flags = JSFunction::INTERPRETED_GETTER; allocKind = gc::AllocKind::FUNCTION_EXTENDED; break; - case Setter: + case FunctionSyntaxKind::Setter: flags = JSFunction::INTERPRETED_SETTER; allocKind = gc::AllocKind::FUNCTION_EXTENDED; break; default: - MOZ_ASSERT(kind == Statement); + MOZ_ASSERT(kind == FunctionSyntaxKind::Statement); #ifdef DEBUG if (options().selfHostingMode && !pc->isFunctionBox()) { isGlobalSelfHostedBuiltin = true; @@ -2979,7 +2979,7 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin // async a => 1 // ^ Modifier argModifier = TokenStream::Operand; - if (kind == Arrow) { + if (kind == FunctionSyntaxKind::Arrow) { TokenKind tt; // In async function, the first token after `async` is already gotten // with TokenStream::None. @@ -3000,7 +3000,9 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin if (!tokenStream.getToken(&tt, firstTokenModifier)) return false; if (tt != TokenKind::Lp) { - error(kind == Arrow ? JSMSG_BAD_ARROW_ARGS : JSMSG_PAREN_BEFORE_FORMAL); + error(kind == FunctionSyntaxKind::Arrow + ? JSMSG_BAD_ARROW_ARGS + : JSMSG_PAREN_BEFORE_FORMAL); return false; } @@ -3035,10 +3037,12 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin bool hasRest = false; bool hasDefault = false; bool duplicatedParam = false; - bool disallowDuplicateParams = kind == Arrow || kind == Method || kind == ClassConstructor; + bool disallowDuplicateParams = kind == FunctionSyntaxKind::Arrow || + kind == FunctionSyntaxKind::Method || + kind == FunctionSyntaxKind::ClassConstructor; AtomVector& positionalFormals = pc->positionalFormalParameterNames(); - if (kind == Getter) { + if (kind == FunctionSyntaxKind::Getter) { error(JSMSG_ACCESSOR_WRONG_ARGS, "getter", "no", "s"); return false; } @@ -3056,7 +3060,7 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin MOZ_ASSERT_IF(parenFreeArrow, TokenKindIsPossibleIdentifier(tt)); if (tt == TokenKind::TripleDot) { - if (kind == Setter) { + if (kind == FunctionSyntaxKind::Setter) { error(JSMSG_ACCESSOR_WRONG_ARGS, "setter", "one", ""); return false; } @@ -3183,7 +3187,7 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin } // Setter syntax uniquely requires exactly one argument. - if (kind == Setter) + if (kind == FunctionSyntaxKind::Setter) break; if (!tokenStream.matchToken(&matched, TokenKind::Comma, TokenStream::Operand)) @@ -3204,7 +3208,7 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin if (!tokenStream.getToken(&tt, TokenStream::Operand)) return false; if (tt != TokenKind::Rp) { - if (kind == Setter) { + if (kind == FunctionSyntaxKind::Setter) { error(JSMSG_ACCESSOR_WRONG_ARGS, "setter", "one", ""); return false; } @@ -3221,7 +3225,7 @@ GeneralParser::functionArguments(YieldHandling yieldHandlin funbox->hasDirectEvalInParameterExpr = true; funbox->function()->setArgCount(positionalFormals.length()); - } else if (kind == Setter) { + } else if (kind == FunctionSyntaxKind::Setter) { error(JSMSG_ACCESSOR_WRONG_ARGS, "setter", "one", ""); return false; } @@ -3360,7 +3364,7 @@ GeneralParser::functionDefinition(Node funcNode, uint32_t t FunctionAsyncKind asyncKind, bool tryAnnexB /* = false */) { - MOZ_ASSERT_IF(kind == Statement, funName); + MOZ_ASSERT_IF(kind == FunctionSyntaxKind::Statement, funName); // When fully parsing a LazyScript, we do not fully reparse its inner // functions, which are also lazy. Instead, their free variables and @@ -3682,17 +3686,17 @@ Parser::standaloneLazyFunction(HandleFunction fun, uint return null(); YieldHandling yieldHandling = GetYieldHandling(generatorKind); - FunctionSyntaxKind syntaxKind = Statement; + FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Statement; if (fun->isClassConstructor()) - syntaxKind = ClassConstructor; + syntaxKind = FunctionSyntaxKind::ClassConstructor; else if (fun->isMethod()) - syntaxKind = Method; + syntaxKind = FunctionSyntaxKind::Method; else if (fun->isGetter()) - syntaxKind = Getter; + syntaxKind = FunctionSyntaxKind::Getter; else if (fun->isSetter()) - syntaxKind = Setter; + syntaxKind = FunctionSyntaxKind::Setter; else if (fun->isArrow()) - syntaxKind = Arrow; + syntaxKind = FunctionSyntaxKind::Arrow; if (!functionFormalParametersAndBody(InAllowed, yieldHandling, &pn, syntaxKind)) { MOZ_ASSERT(directives == newDirectives); @@ -3724,9 +3728,10 @@ GeneralParser::functionFormalParametersAndBody(InHandling i // See below for an explanation why arrow function parameters and arrow // function bodies are parsed with different yield/await settings. { - AwaitHandling awaitHandling = funbox->isAsync() || (kind == Arrow && awaitIsKeyword()) - ? AwaitIsKeyword - : AwaitIsName; + AwaitHandling awaitHandling = + (funbox->isAsync() || (kind == FunctionSyntaxKind::Arrow && awaitIsKeyword())) + ? AwaitIsKeyword + : AwaitIsName; AutoAwaitIsKeyword awaitIsKeyword(this, awaitHandling); if (!functionArguments(yieldHandling, kind, *pn)) return false; @@ -3741,7 +3746,7 @@ GeneralParser::functionFormalParametersAndBody(InHandling i pc->functionScope().useAsVarScope(pc); } - if (kind == Arrow) { + if (kind == FunctionSyntaxKind::Arrow) { bool matched; if (!tokenStream.matchToken(&matched, TokenKind::Arrow)) return false; @@ -3765,7 +3770,7 @@ GeneralParser::functionFormalParametersAndBody(InHandling i return false; uint32_t openedPos = 0; if (tt != TokenKind::Lc) { - if (kind != Arrow) { + if (kind != FunctionSyntaxKind::Arrow) { error(JSMSG_CURLY_BEFORE_BODY); return false; } @@ -3795,7 +3800,7 @@ GeneralParser::functionFormalParametersAndBody(InHandling i } // Revalidate the function name when we transitioned to strict mode. - if ((kind == Statement || kind == Expression) && + if ((kind == FunctionSyntaxKind::Statement || kind == FunctionSyntaxKind::Expression) && fun->explicitName() && !inheritedStrict && pc->sc()->strict()) @@ -3805,7 +3810,7 @@ GeneralParser::functionFormalParametersAndBody(InHandling i PropertyName* propertyName = fun->explicitName()->asPropertyName(); YieldHandling nameYieldHandling; - if (kind == Expression) { + if (kind == FunctionSyntaxKind::Expression) { // Named lambda has binding inside it. nameYieldHandling = bodyYieldHandling; } else { @@ -3829,12 +3834,12 @@ GeneralParser::functionFormalParametersAndBody(InHandling i JSMSG_CURLY_OPENED, openedPos)); funbox->setEnd(anyChars); } else { - MOZ_ASSERT(kind == Arrow); + MOZ_ASSERT(kind == FunctionSyntaxKind::Arrow); if (anyChars.hadError()) return false; funbox->setEnd(anyChars); - if (kind == Statement && !matchOrInsertSemicolon()) + if (kind == FunctionSyntaxKind::Statement && !matchOrInsertSemicolon()) return false; } @@ -3938,8 +3943,8 @@ GeneralParser::functionStmt(uint32_t toStringStart, bool tryAnnexB = kind == DeclarationKind::SloppyLexicalFunction; YieldHandling newYieldHandling = GetYieldHandling(generatorKind); - return functionDefinition(pn, toStringStart, InAllowed, newYieldHandling, name, Statement, - generatorKind, asyncKind, tryAnnexB); + return functionDefinition(pn, toStringStart, InAllowed, newYieldHandling, name, + FunctionSyntaxKind::Statement, generatorKind, asyncKind, tryAnnexB); } template @@ -8218,8 +8223,9 @@ GeneralParser::assignExpr(InHandling inHandling, YieldHandl if (!pn) return null(); - return functionDefinition(pn, toStringStart, inHandling, yieldHandling, nullptr, Arrow, - GeneratorKind::NotGenerator, asyncKind); + return functionDefinition(pn, toStringStart, inHandling, yieldHandling, nullptr, + FunctionSyntaxKind::Arrow, GeneratorKind::NotGenerator, + asyncKind); } MOZ_ALWAYS_TRUE(tokenStream.getToken(&tokenAfterLHS, TokenStream::Operand)); @@ -9716,26 +9722,26 @@ GeneralParser::methodDefinition(uint32_t toStringStart, Pro FunctionSyntaxKind kind; switch (propType) { case PropertyType::Getter: - kind = Getter; + kind = FunctionSyntaxKind::Getter; break; case PropertyType::Setter: - kind = Setter; + kind = FunctionSyntaxKind::Setter; break; case PropertyType::Method: case PropertyType::GeneratorMethod: case PropertyType::AsyncMethod: case PropertyType::AsyncGeneratorMethod: - kind = Method; + kind = FunctionSyntaxKind::Method; break; case PropertyType::Constructor: - kind = ClassConstructor; + kind = FunctionSyntaxKind::ClassConstructor; break; case PropertyType::DerivedConstructor: - kind = DerivedClassConstructor; + kind = FunctionSyntaxKind::DerivedClassConstructor; break; default: diff --git a/js/src/wasm/AsmJS.cpp b/js/src/wasm/AsmJS.cpp index e1f02c5dd78b..1b6159e4611d 100644 --- a/js/src/wasm/AsmJS.cpp +++ b/js/src/wasm/AsmJS.cpp @@ -7207,14 +7207,16 @@ ParseFunction(ModuleValidator& m, ParseNode** fnOut, unsigned* line) FunctionAsyncKind::SyncFunction); if (!funbox) return false; - funbox->initWithEnclosingParseContext(outerpc, frontend::Statement); + funbox->initWithEnclosingParseContext(outerpc, FunctionSyntaxKind::Statement); Directives newDirectives = directives; SourceParseContext funpc(&m.parser(), funbox, &newDirectives); if (!funpc.init()) return false; - if (!m.parser().functionFormalParametersAndBody(InAllowed, YieldIsName, &fn, Statement)) { + if (!m.parser().functionFormalParametersAndBody(InAllowed, YieldIsName, &fn, + FunctionSyntaxKind::Statement)) + { if (anyChars.hadError() || directives == newDirectives) return false;