@typescript-deploys/pr-build 4.7.0-pr-48788-2 → 4.7.0-pr-48792-5

package/lib/tsc.js

@@ -27596,7 +27596,7 @@ var ts;
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125) {
@@ -27638,7 +27638,7 @@ var ts;
                 return undefined;
             }
             return triState === 1 ?
-                parseParenthesizedArrowFunctionExpression(true, false) :
+                parseParenthesizedArrowFunctionExpression(true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         function isParenthesizedArrowFunctionExpression() {
@@ -27796,7 +27796,9 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58;
+            if (disallowReturnTypeInArrowFunction && token() === 58) {
+                return undefined;
+            }
             var type = parseReturnType(58, false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -27814,11 +27816,6 @@ var ts;
             var body = (lastToken === 38 || lastToken === 18)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                if (token() !== 58) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -27841,14 +27838,14 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             var questionToken = parseOptionalToken(57);
             if (!questionToken) {
                 return leftOperand;
             }
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(true); }), colonToken = parseExpectedToken(58), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction)
                 : createMissingNode(79, false, ts.Diagnostics._0_expected, ts.tokenToString(58))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/lib/tsserver.js

@@ -34223,7 +34223,7 @@ var ts;
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34298,7 +34298,7 @@ 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, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
@@ -34506,7 +34506,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // 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, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34537,30 +34548,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // 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 && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -34597,7 +34584,7 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34607,7 +34594,7 @@ var ts;
             // we do not that for the 'whenFalse' part.
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) // inherit disallowReturnTypeInArrowFunction in false side
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/lib/tsserverlibrary.js

@@ -34417,7 +34417,7 @@ var ts;
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34492,7 +34492,7 @@ 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, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
@@ -34700,7 +34700,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // 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, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34742,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // 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 && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -34791,7 +34778,7 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34801,7 +34788,7 @@ var ts;
             // we do not that for the 'whenFalse' part.
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) // inherit disallowReturnTypeInArrowFunction in false side
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/lib/typescript.js

@@ -34417,7 +34417,7 @@ var ts;
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34492,7 +34492,7 @@ 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, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
@@ -34700,7 +34700,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // 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, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34742,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // 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 && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -34791,7 +34778,7 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34801,7 +34788,7 @@ var ts;
             // we do not that for the 'whenFalse' part.
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) // inherit disallowReturnTypeInArrowFunction in false side
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/lib/typescriptServices.js

@@ -34417,7 +34417,7 @@ var ts;
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34492,7 +34492,7 @@ 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, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
@@ -34700,7 +34700,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // 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, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34742,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // 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 && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -34791,7 +34778,7 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34801,7 +34788,7 @@ var ts;
             // we do not that for the 'whenFalse' part.
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) // inherit disallowReturnTypeInArrowFunction in false side
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/lib/typingsInstaller.js

@@ -34212,7 +34212,7 @@ var ts;
                 return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, disallowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34287,7 +34287,7 @@ 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, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
@@ -34495,7 +34495,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // 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, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34526,30 +34537,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // 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 && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -34586,7 +34573,7 @@ var ts;
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, disallowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34596,7 +34583,7 @@ var ts;
             // we do not that for the 'whenFalse' part.
             var colonToken;
             return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+                ? parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) // inherit disallowReturnTypeInArrowFunction in false side
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {

package/package.json

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