typescript 4.7.0-dev.20220225 → 4.7.0-dev.20220228

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220225";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220228";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33667,10 +33667,10 @@ var ts;
                 setDecoratorContext(/*val*/ false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher();
+            var expr = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27 /* CommaToken */))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -33678,9 +33678,9 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
+            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false) : undefined;
         }
-        function parseAssignmentExpressionOrHigher() {
+        function parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -33706,7 +33706,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -33725,7 +33725,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -33734,7 +33734,7 @@ var ts;
             // Note: we call reScanGreaterToken so that we get an appropriately merged token
             // for cases like `> > =` becoming `>>=`
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
             return parseConditionalExpressionRest(expr, pos);
@@ -33777,7 +33777,7 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher()), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false)), pos);
             }
             else {
                 // if the next token is not on the same line as yield.  or we don't have an '*' or
@@ -33785,7 +33785,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, disallowReturnTypeInArrowFunction, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*decorators*/ undefined, 
@@ -33797,11 +33797,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, disallowReturnTypeInArrowFunction);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression() {
+        function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -33812,8 +33812,8 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
-                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -33943,25 +33943,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression() {
+        function parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, disallowReturnTypeInArrowFunction);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression() {
+        function tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, asyncModifier);
                 }
             }
             return undefined;
@@ -33985,7 +33985,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, disallowReturnTypeInArrowFunction) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -34011,6 +34011,23 @@ var ts;
                     return undefined;
                 }
             }
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            //
+            // For example,
+            //     a() ? (b: number, c?: string): void => d() : e
+            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
+            // be an arrow expression, so we allow a return type.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34039,12 +34056,12 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync) {
+        function parseArrowFunctionExpressionBody(isAsync, disallowReturnTypeInArrowFunction) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -34072,8 +34089,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
-                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); })
+                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); });
             topLevel = savedTopLevel;
             return node;
         }
@@ -34086,8 +34103,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher()
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -35003,13 +35020,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25 /* DotDotDotToken */);
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() :
                 token() === 27 /* CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher();
+                    parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -35026,7 +35043,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25 /* DotDotDotToken */)) {
-                var expression = parseAssignmentExpressionOrHigher();
+                var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -35055,7 +35072,7 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* ColonToken */);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63 /* EqualsToken */);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); }) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 // Save equals token for error reporting.
                 // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful.
@@ -35063,7 +35080,7 @@ var ts;
             }
             else {
                 parseExpected(58 /* ColonToken */);
-                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
                 node = factory.createPropertyAssignment(name, initializer);
             }
             // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
@@ -35243,7 +35260,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(159 /* OfKeyword */) : parseOptional(159 /* OfKeyword */)) {
-                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
+                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
                 parseExpected(21 /* CloseParenToken */);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -36410,7 +36427,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
             parseExpected(58 /* ColonToken */);
-            var value = parseAssignmentExpressionOrHigher();
+            var value = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause() {
@@ -36647,7 +36664,7 @@ var ts;
             else {
                 parseExpected(88 /* DefaultKeyword */);
             }
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
@@ -135521,6 +135538,9 @@ var ts;
                     // *don’t* include readonly member modifiers.
                     return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken, node.kind === 144 /* ReadonlyKeyword */ ? isReadonlyTypeOperator : undefined);
                 }
+                if (ts.isImportMeta(node.parent) && node.parent.name === node) {
+                    return getAllReferencesForImportMeta(sourceFiles, cancellationToken);
+                }
                 if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) {
                     return [{ definition: { type: 2 /* Keyword */, node: node }, references: [nodeEntry(node)] }];
                 }
@@ -136002,6 +136022,18 @@ var ts;
                         return false;
                 }
             }
+            function getAllReferencesForImportMeta(sourceFiles, cancellationToken) {
+                var references = ts.flatMap(sourceFiles, function (sourceFile) {
+                    cancellationToken.throwIfCancellationRequested();
+                    return ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "meta", sourceFile), function (node) {
+                        var parent = node.parent;
+                        if (ts.isImportMeta(parent)) {
+                            return nodeEntry(parent);
+                        }
+                    });
+                });
+                return references.length ? [{ definition: { type: 2 /* Keyword */, node: references[0].node }, references: references }] : undefined;
+            }
             function getAllReferencesForKeyword(sourceFiles, keywordKind, cancellationToken, filter) {
                 var references = ts.flatMap(sourceFiles, function (sourceFile) {
                     cancellationToken.throwIfCancellationRequested();
@@ -137714,6 +137746,9 @@ var ts;
             if (node === sourceFile) {
                 return undefined;
             }
+            if (ts.isImportMeta(node.parent) && node.parent.name === node) {
+                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent);
+            }
             var symbol = getSymbol(node, typeChecker);
             if (!symbol)
                 return undefined;
@@ -162842,6 +162877,9 @@ var ts;
             if (ts.isNamedTupleMember(node.parent) && node.pos === node.parent.pos) {
                 return node.parent;
             }
+            if (ts.isImportMeta(node.parent) && node.parent.name === node) {
+                return node.parent;
+            }
             return node;
         }
         function shouldGetType(sourceFile, node, position) {
@@ -162857,6 +162895,8 @@ var ts;
                 case 106 /* SuperKeyword */:
                 case 196 /* NamedTupleMember */:
                     return true;
+                case 230 /* MetaProperty */:
+                    return ts.isImportMeta(node);
                 default:
                     return false;
             }

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220225";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220228";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33462,10 +33462,10 @@ var ts;
                 setDecoratorContext(/*val*/ false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher();
+            var expr = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27 /* CommaToken */))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -33473,9 +33473,9 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
+            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false) : undefined;
         }
-        function parseAssignmentExpressionOrHigher() {
+        function parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -33501,7 +33501,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -33520,7 +33520,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -33529,7 +33529,7 @@ var ts;
             // Note: we call reScanGreaterToken so that we get an appropriately merged token
             // for cases like `> > =` becoming `>>=`
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
             return parseConditionalExpressionRest(expr, pos);
@@ -33572,7 +33572,7 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher()), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false)), pos);
             }
             else {
                 // if the next token is not on the same line as yield.  or we don't have an '*' or
@@ -33580,7 +33580,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, disallowReturnTypeInArrowFunction, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*decorators*/ undefined, 
@@ -33592,11 +33592,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, disallowReturnTypeInArrowFunction);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression() {
+        function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -33607,8 +33607,8 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
-                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -33738,25 +33738,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression() {
+        function parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, disallowReturnTypeInArrowFunction);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression() {
+        function tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, asyncModifier);
                 }
             }
             return undefined;
@@ -33780,7 +33780,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, disallowReturnTypeInArrowFunction) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -33806,6 +33806,23 @@ var ts;
                     return undefined;
                 }
             }
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            //
+            // For example,
+            //     a() ? (b: number, c?: string): void => d() : e
+            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
+            // be an arrow expression, so we allow a return type.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -33834,12 +33851,12 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync) {
+        function parseArrowFunctionExpressionBody(isAsync, disallowReturnTypeInArrowFunction) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -33867,8 +33884,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
-                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); })
+                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); });
             topLevel = savedTopLevel;
             return node;
         }
@@ -33881,8 +33898,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher()
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -34798,13 +34815,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25 /* DotDotDotToken */);
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() :
                 token() === 27 /* CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher();
+                    parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -34821,7 +34838,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25 /* DotDotDotToken */)) {
-                var expression = parseAssignmentExpressionOrHigher();
+                var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -34850,7 +34867,7 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* ColonToken */);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63 /* EqualsToken */);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); }) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 // Save equals token for error reporting.
                 // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful.
@@ -34858,7 +34875,7 @@ var ts;
             }
             else {
                 parseExpected(58 /* ColonToken */);
-                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
                 node = factory.createPropertyAssignment(name, initializer);
             }
             // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
@@ -35038,7 +35055,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(159 /* OfKeyword */) : parseOptional(159 /* OfKeyword */)) {
-                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
+                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
                 parseExpected(21 /* CloseParenToken */);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -36205,7 +36222,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
             parseExpected(58 /* ColonToken */);
-            var value = parseAssignmentExpressionOrHigher();
+            var value = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause() {
@@ -36442,7 +36459,7 @@ var ts;
             else {
                 parseExpected(88 /* DefaultKeyword */);
             }
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.7.0-dev.20220225",
+    "version": "4.7.0-dev.20220228",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [