Bug 1450574 - Remove expressionClosureHandling from Parser. r=jorendorff
authorTom Schuster <evilpies@gmail.com>
Wed, 04 Apr 2018 20:07:47 +0200
changeset 411960 42b231ec2fbcb90db404050715cbf8b267016b99
parent 411959 a4bb451ae0df89b58ec63e6747716e4fcd9d5edd
child 411961 db6ccdb848165514252bf3d7958d9679cc0fc062
push id101803
push userevilpies@gmail.com
push dateThu, 05 Apr 2018 23:11:39 +0000
treeherdermozilla-inbound@42b231ec2fbc [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorendorff
bugs1450574
milestone61.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1450574 - Remove expressionClosureHandling from Parser. r=jorendorff
js/src/frontend/BinSource.cpp
js/src/frontend/ParseNode.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -977,17 +977,17 @@ BinASTParser::parseFunctionAux(const Bin
     traceListHead_ = funbox;
 
     FunctionSyntaxKind syntax;
     switch (kind) {
       case BinKind::FunctionDeclaration:
         syntax = Statement;
         break;
       case BinKind::FunctionExpression:
-        syntax = PrimaryExpression; // FIXME: Probably doesn't work.
+        syntax = Expression; // FIXME: Probably doesn't work.
         break;
       case BinKind::ObjectMethod:
         syntax = Method;
         break;
       case BinKind::ObjectGetter:
         syntax = Getter;
         break;
       case BinKind::ObjectSetter:
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -1435,50 +1435,31 @@ AccessorTypeToJSOp(AccessorType atype)
         return JSOP_INITPROP_SETTER;
       default:
         MOZ_CRASH("unexpected accessor type");
     }
 }
 
 enum FunctionSyntaxKind
 {
-    // A non-arrow function expression that is a PrimaryExpression and *also* a
-    // complete AssignmentExpression.  For example, in
-    //
-    //   var x = (function y() {});
-    //
-    // |y| is such a function expression.
-    AssignmentExpression,
-
-    // A non-arrow function expression that is a PrimaryExpression but *not* a
-    // complete AssignmentExpression.  For example, in
-    //
-    //   var x = (1 + function y() {});
-    //
-    // |y| is such a function expression.
-    PrimaryExpression,
+    // A non-arrow function expression.
+    Expression,
 
     // A named function appearing as a Statement.
     Statement,
 
     Arrow,
     Method,
     ClassConstructor,
     DerivedClassConstructor,
     Getter,
     Setter,
 };
 
 static inline bool
-IsFunctionExpression(FunctionSyntaxKind kind)
-{
-    return kind == AssignmentExpression || kind == PrimaryExpression;
-}
-
-static inline bool
 IsConstructorKind(FunctionSyntaxKind kind)
 {
     return kind == ClassConstructor || kind == DerivedClassConstructor;
 }
 
 static inline bool
 IsMethodDefinitionKind(FunctionSyntaxKind kind)
 {
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -2789,18 +2789,17 @@ ParserBase::newFunction(HandleAtom atom,
     RootedFunction fun(context);
 
     gc::AllocKind allocKind = gc::AllocKind::FUNCTION;
     JSFunction::Flags flags;
 #ifdef DEBUG
     bool isGlobalSelfHostedBuiltin = false;
 #endif
     switch (kind) {
-      case AssignmentExpression:
-      case PrimaryExpression:
+      case Expression:
         flags = (generatorKind == GeneratorKind::NotGenerator &&
                  asyncKind == FunctionAsyncKind::SyncFunction
                  ? JSFunction::INTERPRETED_LAMBDA
                  : JSFunction::INTERPRETED_LAMBDA_GENERATOR_OR_ASYNC);
         break;
       case Arrow:
         flags = JSFunction::INTERPRETED_LAMBDA_ARROW;
         allocKind = gc::AllocKind::FUNCTION_EXTENDED;
@@ -3793,27 +3792,27 @@ GeneralParser<ParseHandler, CharT>::func
     {
         AutoAwaitIsKeyword<ParseHandler, CharT> awaitIsKeyword(this, bodyAwaitHandling);
         body = functionBody(inHandling, bodyYieldHandling, kind, bodyType);
         if (!body)
             return false;
     }
 
     // Revalidate the function name when we transitioned to strict mode.
-    if ((kind == Statement || IsFunctionExpression(kind)) &&
+    if ((kind == Statement || kind == Expression) &&
         fun->explicitName() &&
         !inheritedStrict &&
         pc->sc()->strict())
     {
         MOZ_ASSERT(pc->sc()->hasExplicitUseStrict(),
                    "strict mode should only change when a 'use strict' directive is present");
 
         PropertyName* propertyName = fun->explicitName()->asPropertyName();
         YieldHandling nameYieldHandling;
-        if (IsFunctionExpression(kind)) {
+        if (kind == Expression) {
             // Named lambda has binding inside it.
             nameYieldHandling = bodyYieldHandling;
         } else {
             // Otherwise YieldHandling cannot be checked at this point
             // because of different context.
             // It should already be checked before this point.
             nameYieldHandling = YieldIsName;
         }
@@ -3943,17 +3942,16 @@ GeneralParser<ParseHandler, CharT>::func
     YieldHandling newYieldHandling = GetYieldHandling(generatorKind);
     return functionDefinition(pn, toStringStart, InAllowed, newYieldHandling, name, Statement,
                               generatorKind, asyncKind, tryAnnexB);
 }
 
 template <class ParseHandler, typename CharT>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::functionExpr(uint32_t toStringStart,
-                                                 ExpressionClosure expressionClosureHandling,
                                                  InvokedPrediction invoked,
                                                  FunctionAsyncKind asyncKind)
 {
     MOZ_ASSERT(anyChars.isCurrentTokenType(TokenKind::Function));
 
     AutoAwaitIsKeyword<ParseHandler, CharT> awaitIsKeyword(this, GetAwaitHandling(asyncKind));
     GeneratorKind generatorKind = GeneratorKind::NotGenerator;
     TokenKind tt;
@@ -3979,22 +3977,18 @@ GeneralParser<ParseHandler, CharT>::func
 
     Node pn = handler.newFunctionExpression(pos());
     if (!pn)
         return null();
 
     if (invoked)
         pn = handler.setLikelyIIFE(pn);
 
-    FunctionSyntaxKind kind = expressionClosureHandling == ExpressionClosure::Allowed
-                              ? AssignmentExpression
-                              : PrimaryExpression;
-
-    return functionDefinition(pn, toStringStart, InAllowed, yieldHandling, name, kind,
-                              generatorKind, asyncKind);
+    return functionDefinition(pn, toStringStart, InAllowed, yieldHandling, name,
+                              FunctionSyntaxKind::Expression, generatorKind, asyncKind);
 }
 
 /*
  * Return true if this node, known to be an unparenthesized string literal,
  * could be the string of a directive in a Directive Prologue. Directive
  * strings never contain escape sequences or line continuations.
  * isEscapeFreeStringLiteral, below, checks whether the node itself could be
  * a directive.
@@ -7229,18 +7223,17 @@ GeneralParser<ParseHandler, CharT>::clas
 
     Node classHeritage = null();
     bool hasHeritage;
     if (!tokenStream.matchToken(&hasHeritage, TokenKind::Extends))
         return null();
     if (hasHeritage) {
         if (!tokenStream.getToken(&tt))
             return null();
-        classHeritage = memberExpr(yieldHandling, TripledotProhibited,
-                                   ExpressionClosure::Forbidden, tt);
+        classHeritage = memberExpr(yieldHandling, TripledotProhibited, tt);
         if (!classHeritage)
             return null();
     }
 
     MUST_MATCH_TOKEN(TokenKind::Lc, JSMSG_CURLY_BEFORE_CLASS);
 
     Node classMethods = handler.newClassMethodList(pos().begin);
     if (!classMethods)
@@ -7967,37 +7960,33 @@ Precedence(ParseNodeKind pnk)
     MOZ_ASSERT(pnk <= ParseNodeKind::BinOpLast);
     return PrecedenceTable[size_t(pnk) - size_t(ParseNodeKind::BinOpFirst)];
 }
 
 template <class ParseHandler, typename CharT>
 MOZ_ALWAYS_INLINE typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::orExpr(InHandling inHandling, YieldHandling yieldHandling,
                                            TripledotHandling tripledotHandling,
-                                           ExpressionClosure expressionClosureHandling,
                                            PossibleError* possibleError,
                                            InvokedPrediction invoked /* = PredictUninvoked */)
 {
     // Shift-reduce parser for the binary operator part of the JS expression
     // syntax.
 
     // Conceptually there's just one stack, a stack of pairs (lhs, op).
     // It's implemented using two separate arrays, though.
     Node nodeStack[PRECEDENCE_CLASSES];
     ParseNodeKind kindStack[PRECEDENCE_CLASSES];
     int depth = 0;
     Node pn;
     for (;;) {
-        pn = unaryExpr(yieldHandling, tripledotHandling, expressionClosureHandling, possibleError,
-                       invoked);
+        pn = unaryExpr(yieldHandling, tripledotHandling, possibleError, invoked);
         if (!pn)
             return null();
 
-        expressionClosureHandling = ExpressionClosure::Forbidden;
-
         // If a binary operator follows, consume it and compute the
         // corresponding operator.
         TokenKind tok;
         if (!tokenStream.getToken(&tok))
             return null();
 
         ParseNodeKind pnk;
         if (tok == TokenKind::In ? inHandling == InAllowed : TokenKindIsBinaryOp(tok)) {
@@ -8052,22 +8041,20 @@ GeneralParser<ParseHandler, CharT>::orEx
     MOZ_ASSERT(depth == 0);
     return pn;
 }
 
 template <class ParseHandler, typename CharT>
 MOZ_ALWAYS_INLINE typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::condExpr(InHandling inHandling, YieldHandling yieldHandling,
                                              TripledotHandling tripledotHandling,
-                                             ExpressionClosure expressionClosureHandling,
                                              PossibleError* possibleError,
                                              InvokedPrediction invoked /* = PredictUninvoked */)
 {
-    Node condition = orExpr(inHandling, yieldHandling, tripledotHandling,
-                            expressionClosureHandling, possibleError, invoked);
+    Node condition = orExpr(inHandling, yieldHandling, tripledotHandling, possibleError, invoked);
     if (!condition)
         return null();
 
     bool matched;
     if (!tokenStream.matchToken(&matched, TokenKind::Hook))
         return null();
     if (!matched)
         return condition;
@@ -8185,18 +8172,17 @@ GeneralParser<ParseHandler, CharT>::assi
         if (tokenAfterLHS != TokenKind::Arrow) {
             error(JSMSG_UNEXPECTED_TOKEN,
                   "'=>' on the same line after an argument list", TokenKindToDesc(tokenAfterLHS));
             return null();
         }
 
         isArrow = true;
     } else {
-        lhs = condExpr(inHandling, yieldHandling, tripledotHandling, ExpressionClosure::Allowed,
-                       &possibleErrorInner, invoked);
+        lhs = condExpr(inHandling, yieldHandling, tripledotHandling, &possibleErrorInner, invoked);
         if (!lhs)
             return null();
 
         // Use Operand here because the ConditionalExpression parsed above
         // could be the entirety of this AssignmentExpression, and then ASI
         // permits this token to be a regular expression.
         if (!tokenStream.peekTokenSameLine(&tokenAfterLHS, TokenStream::Operand))
             return null();
@@ -8378,27 +8364,26 @@ GeneralParser<ParseHandler, CharT>::chec
     return true;
 }
 
 template <class ParseHandler, typename CharT>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::unaryOpExpr(YieldHandling yieldHandling, ParseNodeKind kind,
                                                 uint32_t begin)
 {
-    Node kid = unaryExpr(yieldHandling, TripledotProhibited, ExpressionClosure::Forbidden);
+    Node kid = unaryExpr(yieldHandling, TripledotProhibited);
     if (!kid)
         return null();
     return handler.newUnary(kind, begin, kid);
 }
 
 template <class ParseHandler, typename CharT>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::unaryExpr(YieldHandling yieldHandling,
                                               TripledotHandling tripledotHandling,
-                                              ExpressionClosure expressionClosureHandling,
                                               PossibleError* possibleError /* = nullptr */,
                                               InvokedPrediction invoked /* = PredictUninvoked */)
 {
     if (!CheckRecursionLimit(context))
         return null();
 
     TokenKind tt;
     if (!tokenStream.getToken(&tt, TokenStream::Operand))
@@ -8423,47 +8408,47 @@ GeneralParser<ParseHandler, CharT>::unar
         //
         //   // Looks up the name, doesn't find it and so evaluates to
         //   // "undefined".
         //   assertEq(typeof nonExistentName, "undefined");
         //
         //   // Evaluates expression, triggering a runtime ReferenceError for
         //   // the undefined name.
         //   typeof (1, nonExistentName);
-        Node kid = unaryExpr(yieldHandling, TripledotProhibited, ExpressionClosure::Forbidden);
+        Node kid = unaryExpr(yieldHandling, TripledotProhibited);
         if (!kid)
             return null();
 
         return handler.newTypeof(begin, kid);
       }
 
       case TokenKind::Inc:
       case TokenKind::Dec:
       {
         TokenKind tt2;
         if (!tokenStream.getToken(&tt2, TokenStream::Operand))
             return null();
 
         uint32_t operandOffset = pos().begin;
         Node operand =
-            memberExpr(yieldHandling, TripledotProhibited, ExpressionClosure::Forbidden, tt2);
+            memberExpr(yieldHandling, TripledotProhibited, tt2);
         if (!operand || !checkIncDecOperand(operand, operandOffset))
             return null();
         ParseNodeKind pnk = (tt == TokenKind::Inc)
                             ? ParseNodeKind::PreIncrement
                             : ParseNodeKind::PreDecrement;
         return handler.newUpdate(pnk, begin, operand);
       }
 
       case TokenKind::Delete: {
         uint32_t exprOffset;
         if (!tokenStream.peekOffset(&exprOffset, TokenStream::Operand))
             return null();
 
-        Node expr = unaryExpr(yieldHandling, TripledotProhibited, ExpressionClosure::Forbidden);
+        Node expr = unaryExpr(yieldHandling, TripledotProhibited);
         if (!expr)
             return null();
 
         // Per spec, deleting any unary expression is valid -- it simply
         // returns true -- except for one case that is illegal in strict mode.
         if (handler.isName(expr)) {
             if (!strictModeErrorAt(exprOffset, JSMSG_DEPRECATED_DELETE_OPERAND))
                 return null();
@@ -8471,29 +8456,28 @@ GeneralParser<ParseHandler, CharT>::unar
             pc->sc()->setBindingsAccessedDynamically();
         }
 
         return handler.newDelete(begin, expr);
       }
 
       case TokenKind::Await: {
         if (pc->isAsync()) {
-            Node kid = unaryExpr(yieldHandling, tripledotHandling, ExpressionClosure::Forbidden,
-                                 possibleError, invoked);
+            Node kid = unaryExpr(yieldHandling, tripledotHandling, possibleError, invoked);
             if (!kid)
                 return null();
             pc->lastAwaitOffset = begin;
             return handler.newAwaitExpression(begin, kid);
         }
       }
 
         MOZ_FALLTHROUGH;
 
       default: {
-        Node expr = memberExpr(yieldHandling, tripledotHandling, expressionClosureHandling, tt,
+        Node expr = memberExpr(yieldHandling, tripledotHandling, tt,
                                /* allowCallSyntax = */ true, possibleError, invoked);
         if (!expr)
             return null();
 
         /* Don't look across a newline boundary for a postfix incop. */
         if (!tokenStream.peekTokenSameLine(&tt))
             return null();
 
@@ -8597,17 +8581,16 @@ ParserBase::checkAndMarkSuperScope()
     pc->setSuperScopeNeedsHomeObject();
     return true;
 }
 
 template <class ParseHandler, typename CharT>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::memberExpr(YieldHandling yieldHandling,
                                                TripledotHandling tripledotHandling,
-                                               ExpressionClosure expressionClosureHandling,
                                                TokenKind tt, bool allowCallSyntax /* = true */,
                                                PossibleError* possibleError /* = nullptr */,
                                                InvokedPrediction invoked /* = PredictUninvoked */)
 {
     MOZ_ASSERT(anyChars.isCurrentTokenType(tt));
 
     Node lhs;
 
@@ -8621,18 +8604,17 @@ GeneralParser<ParseHandler, CharT>::memb
         Node newTarget;
         if (!tryNewTarget(newTarget))
             return null();
         if (newTarget) {
             lhs = newTarget;
         } else {
             // Gotten by tryNewTarget
             tt = anyChars.currentToken().type;
-            Node ctorExpr = memberExpr(yieldHandling, TripledotProhibited,
-                                       ExpressionClosure::Forbidden, tt,
+            Node ctorExpr = memberExpr(yieldHandling, TripledotProhibited, tt,
                                        /* allowCallSyntax = */ false,
                                        /* possibleError = */ nullptr, PredictInvoked);
             if (!ctorExpr)
                 return null();
 
             lhs = handler.newNewExpression(newBegin, ctorExpr);
             if (!lhs)
                 return null();
@@ -8651,18 +8633,17 @@ GeneralParser<ParseHandler, CharT>::memb
     } else if (tt == TokenKind::Super) {
         Node thisName = newThisName();
         if (!thisName)
             return null();
         lhs = handler.newSuperBase(thisName, pos());
         if (!lhs)
             return null();
     } else {
-        lhs = primaryExpr(yieldHandling, tripledotHandling, expressionClosureHandling, tt,
-                          possibleError, invoked);
+        lhs = primaryExpr(yieldHandling, tripledotHandling, tt, possibleError, invoked);
         if (!lhs)
             return null();
     }
 
     MOZ_ASSERT_IF(handler.isSuperBase(lhs), anyChars.isCurrentTokenType(TokenKind::Super));
 
     while (true) {
         if (!tokenStream.getToken(&tt))
@@ -9827,28 +9808,26 @@ GeneralParser<ParseHandler, CharT>::tryN
     newTarget = handler.newNewTarget(newHolder, targetHolder);
     return !!newTarget;
 }
 
 template <class ParseHandler, typename CharT>
 typename ParseHandler::Node
 GeneralParser<ParseHandler, CharT>::primaryExpr(YieldHandling yieldHandling,
                                                 TripledotHandling tripledotHandling,
-                                                ExpressionClosure expressionClosureHandling,
                                                 TokenKind tt, PossibleError* possibleError,
                                                 InvokedPrediction invoked /* = PredictUninvoked */)
 {
     MOZ_ASSERT(anyChars.isCurrentTokenType(tt));
     if (!CheckRecursionLimit(context))
         return null();
 
     switch (tt) {
       case TokenKind::Function:
-        return functionExpr(pos().begin, expressionClosureHandling, invoked,
-                            FunctionAsyncKind::SyncFunction);
+        return functionExpr(pos().begin, invoked, FunctionAsyncKind::SyncFunction);
 
       case TokenKind::Class:
         return classDefinition(yieldHandling, ClassExpression, NameRequired);
 
       case TokenKind::Lb:
         return arrayInitializer(yieldHandling, possibleError);
 
       case TokenKind::Lc:
@@ -9903,18 +9882,17 @@ GeneralParser<ParseHandler, CharT>::prim
         if (tt == TokenKind::Async) {
             TokenKind nextSameLine = TokenKind::Eof;
             if (!tokenStream.peekTokenSameLine(&nextSameLine))
                 return null();
 
             if (nextSameLine == TokenKind::Function) {
                 uint32_t toStringStart = pos().begin;
                 tokenStream.consumeKnownToken(TokenKind::Function);
-                return functionExpr(toStringStart, expressionClosureHandling, PredictUninvoked,
-                                    FunctionAsyncKind::AsyncFunction);
+                return functionExpr(toStringStart, PredictUninvoked, FunctionAsyncKind::AsyncFunction);
             }
         }
 
         Rooted<PropertyName*> name(context, identifierReference(yieldHandling));
         if (!name)
             return null();
 
         return identifierReference(name);
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -611,18 +611,16 @@ PerHandlerParser<FullParseHandler>::hadA
 }
 
 template<>
 inline void
 PerHandlerParser<FullParseHandler>::clearAbortedSyntaxParse()
 {
 }
 
-enum class ExpressionClosure { Allowed, Forbidden };
-
 template<class Parser>
 class ParserAnyCharsAccess
 {
   public:
     using TokenStreamSpecific = typename Parser::TokenStream;
     using GeneralTokenStreamChars = typename TokenStreamSpecific::GeneralCharsBase;
 
     static inline TokenStreamAnyChars& anyChars(GeneralTokenStreamChars* ts);
@@ -969,18 +967,18 @@ class GeneralParser
      * Each parser must be called during the dynamic scope of a ParseContext
      * object, pointed to by this->pc.
      *
      * Each returns a parse node tree or null on error.
      */
     Node functionStmt(uint32_t toStringStart,
                       YieldHandling yieldHandling, DefaultHandling defaultHandling,
                       FunctionAsyncKind asyncKind = FunctionAsyncKind::SyncFunction);
-    Node functionExpr(uint32_t toStringStart, ExpressionClosure expressionClosureHandling,
-                      InvokedPrediction invoked, FunctionAsyncKind asyncKind);
+    Node functionExpr(uint32_t toStringStart, InvokedPrediction invoked,
+                      FunctionAsyncKind asyncKind);
 
     Node statement(YieldHandling yieldHandling);
     bool maybeParseDirective(Node list, Node pn, bool* cont);
 
     Node blockStatement(YieldHandling yieldHandling,
                         unsigned errorNumber = JSMSG_CURLY_IN_COMPOUND);
     Node doWhileStatement(YieldHandling yieldHandling);
     Node whileStatement(YieldHandling yieldHandling);
@@ -1089,34 +1087,30 @@ class GeneralParser
               TripledotHandling tripledotHandling, PossibleError* possibleError = nullptr,
               InvokedPrediction invoked = PredictUninvoked);
     Node assignExpr(InHandling inHandling, YieldHandling yieldHandling,
                     TripledotHandling tripledotHandling, PossibleError* possibleError = nullptr,
                     InvokedPrediction invoked = PredictUninvoked);
     Node assignExprWithoutYieldOrAwait(YieldHandling yieldHandling);
     Node yieldExpression(InHandling inHandling);
     Node condExpr(InHandling inHandling, YieldHandling yieldHandling,
-                  TripledotHandling tripledotHandling, ExpressionClosure expressionClosureHandling,
-                  PossibleError* possibleError,
+                  TripledotHandling tripledotHandling, PossibleError* possibleError,
                   InvokedPrediction invoked = PredictUninvoked);
     Node orExpr(InHandling inHandling, YieldHandling yieldHandling,
-                TripledotHandling tripledotHandling, ExpressionClosure expressionClosureHandling,
-                PossibleError* possibleError,
+                TripledotHandling tripledotHandling, PossibleError* possibleError,
                 InvokedPrediction invoked = PredictUninvoked);
     Node unaryExpr(YieldHandling yieldHandling, TripledotHandling tripledotHandling,
-                   ExpressionClosure expressionClosureHandling,
                    PossibleError* possibleError = nullptr,
                    InvokedPrediction invoked = PredictUninvoked);
-    Node memberExpr(YieldHandling yieldHandling, TripledotHandling tripledotHandling,
-                    ExpressionClosure expressionClosureHandling, TokenKind tt,
+    Node memberExpr(YieldHandling yieldHandling, TripledotHandling tripledotHandling, TokenKind tt,
                     bool allowCallSyntax = true, PossibleError* possibleError = nullptr,
                     InvokedPrediction invoked = PredictUninvoked);
     Node primaryExpr(YieldHandling yieldHandling, TripledotHandling tripledotHandling,
-                     ExpressionClosure expressionClosureHandling, TokenKind tt,
-                     PossibleError* possibleError, InvokedPrediction invoked = PredictUninvoked);
+                     TokenKind tt, PossibleError* possibleError,
+                     InvokedPrediction invoked = PredictUninvoked);
     Node exprInParens(InHandling inHandling, YieldHandling yieldHandling,
                       TripledotHandling tripledotHandling, PossibleError* possibleError = nullptr);
 
     bool tryNewTarget(Node& newTarget);
 
     Node methodDefinition(uint32_t toStringStart, PropertyType propType, HandleAtom funName);
 
     /*