remove redundant check mode

Author: Andarist

src/compiler/checker.ts

@@ -1334,7 +1334,6 @@ export const enum CheckMode {
                                                     //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
                                                     //   we need to preserve generic types instead of substituting them for constraints
     TypeOnly = 1 << 6,                              // Called from getTypeOfExpression, diagnostics may be omitted
-    ContextualSignatureReturn = 1 << 7              // Checking return expressions of functions with contextual signatures
 }
 
 /** @internal */
@@ -31972,6 +31971,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
+    function isReturnExpressionLiteralContext(node: Node) {
+        const ancestor = findAncestor(node, n => {
+            if (isCallOrNewExpression(n)) {
+                return "quit";
+            }
+            const parent = n.parent;
+            if (isStatement(parent)) {
+                return parent.kind === SyntaxKind.ReturnStatement || "quit";
+            }
+            if (parent.kind === SyntaxKind.ArrowFunction) {
+                return (parent as ArrowFunction).body === n || "quit";
+            }
+            return false;
+        });
+        return !!(ancestor && isExpression(ancestor) && getContextualTypeForReturnExpression(ancestor, /*contextFlags*/ undefined));
+    }
+
     // If the given contextual type contains instantiable types and if a mapper representing
     // return type inferences is available, instantiate those types using that mapper.
     function instantiateContextualType(contextualType: Type | undefined, node: Node, contextFlags: ContextFlags | undefined): Type | undefined {
@@ -31980,7 +31996,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // If no inferences have been made, and none of the type parameters for which we are inferring
             // specify default types, nothing is gained from instantiating as type parameters would just be
             // replaced with their constraints similar to the apparent type.
-            if (inferenceContext && contextFlags! & ContextFlags.ContextualSignature && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
+            if (inferenceContext && (contextFlags! & ContextFlags.ContextualSignature || isReturnExpressionLiteralContext(node)) && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
                 // For contextual signatures we incorporate all inferences made so far, e.g. from return
                 // types as well as arguments to the left in a function call.
                 return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
@@ -38859,7 +38875,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return getTypeOfSymbol(getSymbolOfDeclaration(node));
     }
 
-    function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | ArrowFunction | MethodDeclaration, checkMode = CheckMode.Normal) {
+    function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | ArrowFunction | MethodDeclaration, checkMode?: CheckMode) {
         const links = getNodeLinks(node);
         // Check if function expression is contextually typed and assign parameter types if so.
         if (!(links.flags & NodeCheckFlags.ContextChecked)) {
@@ -38900,7 +38916,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     }
                 }
                 if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) {
-                    const returnType = getReturnTypeFromBody(node, checkMode | CheckMode.ContextualSignatureReturn);
+                    const returnType = getReturnTypeFromBody(node, checkMode);
                     if (!signature.resolvedReturnType) {
                         signature.resolvedReturnType = returnType;
                     }
@@ -40702,11 +40718,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
     }
 
-    function checkExpressionForMutableLocation(node: Expression, checkMode = CheckMode.Normal, forceTuple?: boolean): Type {
+    function checkExpressionForMutableLocation(node: Expression, checkMode?: CheckMode, forceTuple?: boolean): Type {
         const type = checkExpression(node, checkMode, forceTuple);
         return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
             isTypeAssertion(node) ? type :
-            getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(getContextualType(node, checkMode & CheckMode.ContextualSignatureReturn ? ContextFlags.ContextualSignature : ContextFlags.None), node, /*contextFlags*/ undefined));
+            getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(getContextualType(node, /*contextFlags*/ undefined), node, /*contextFlags*/ undefined));
     }
 
     function checkPropertyAssignment(node: PropertyAssignment, checkMode?: CheckMode): Type {