fixed checker and test results

Author: craigphicks

src/compiler/checker.ts

@@ -1487,6 +1487,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var lastGetCombinedModifierFlagsNode: Declaration | undefined;
     var lastGetCombinedModifierFlagsResult = ModifierFlags.None;
 
+    var chooseOverloadRecursionLevel = -1; // #56013
+    var chooseOverloadFlushNodesSignaturesReq: (Set<Node> | undefined)[] = []; // #56013
+
     // for public members that accept a Node or one of its subtypes, we must guard against
     // synthetic nodes created during transformations by calling `getParseTreeNode`.
     // for most of these, we perform the guard only on `checker` to avoid any possible
@@ -34310,87 +34313,95 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         function chooseOverload(candidates: Signature[], relation: Map<string, RelationComparisonResult>, isSingleNonGenericCandidate: boolean, signatureHelpTrailingComma = false) {
-            candidatesForArgumentError = undefined;
-            candidateForArgumentArityError = undefined;
-            candidateForTypeArgumentError = undefined;
-
-            if (isSingleNonGenericCandidate) {
-                const candidate = candidates[0];
-                if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
-                    return undefined;
-                }
-                if (getSignatureApplicabilityError(node, args, candidate, relation, CheckMode.Normal, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) {
-                    candidatesForArgumentError = [candidate];
-                    return undefined;
+            chooseOverloadRecursionLevel++; // #56013
+            chooseOverloadFlushNodesSignaturesReq[chooseOverloadRecursionLevel] = undefined;
+            const result = (() => {
+                candidatesForArgumentError = undefined;
+                candidateForArgumentArityError = undefined;
+                candidateForTypeArgumentError = undefined;
+
+                if (isSingleNonGenericCandidate) {
+                    const candidate = candidates[0];
+                    if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
+                        return undefined;
+                    }
+                    if (getSignatureApplicabilityError(node, args, candidate, relation, CheckMode.Normal, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) {
+                        candidatesForArgumentError = [candidate];
+                        return undefined;
+                    }
+                    return candidate;
                 }
-                return candidate;
-            }
 
-            for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
-                const candidate = candidates[candidateIndex];
-                if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
-                    continue;
-                }
+                for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+                    if (candidateIndex > 0) chooseOverloadFlushNodesSignaturesReq[chooseOverloadRecursionLevel] = new Set(); // #56013
+                    const candidate = candidates[candidateIndex];
+                    if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
+                        continue;
+                    }
 
-                let checkCandidate: Signature;
-                let inferenceContext: InferenceContext | undefined;
+                    let checkCandidate: Signature;
+                    let inferenceContext: InferenceContext | undefined;
 
-                if (candidate.typeParameters) {
-                    let typeArgumentTypes: Type[] | undefined;
-                    if (some(typeArguments)) {
-                        typeArgumentTypes = checkTypeArguments(candidate, typeArguments, /*reportErrors*/ false);
-                        if (!typeArgumentTypes) {
-                            candidateForTypeArgumentError = candidate;
-                            continue;
+                    if (candidate.typeParameters) {
+                        let typeArgumentTypes: Type[] | undefined;
+                        if (some(typeArguments)) {
+                            typeArgumentTypes = checkTypeArguments(candidate, typeArguments, /*reportErrors*/ false);
+                            if (!typeArgumentTypes) {
+                                candidateForTypeArgumentError = candidate;
+                                continue;
+                            }
                         }
-                    }
-                    else {
-                        inferenceContext = createInferenceContext(candidate.typeParameters, candidate, /*flags*/ isInJSFile(node) ? InferenceFlags.AnyDefault : InferenceFlags.None);
-                        typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | CheckMode.SkipGenericFunctions, inferenceContext);
-                        argCheckMode |= inferenceContext.flags & InferenceFlags.SkippedGenericFunction ? CheckMode.SkipGenericFunctions : CheckMode.Normal;
-                    }
-                    checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
-                    // If the original signature has a generic rest type, instantiation may produce a
-                    // signature with different arity and we need to perform another arity check.
-                    if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
-                        candidateForArgumentArityError = checkCandidate;
-                        continue;
-                    }
-                }
-                else {
-                    checkCandidate = candidate;
-                }
-                if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) {
-                    // Give preference to error candidates that have no rest parameters (as they are more specific)
-                    (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
-                    continue;
-                }
-                if (argCheckMode) {
-                    // If one or more context sensitive arguments were excluded, we start including
-                    // them now (and keeping do so for any subsequent candidates) and perform a second
-                    // round of type inference and applicability checking for this particular candidate.
-                    argCheckMode = CheckMode.Normal;
-                    if (inferenceContext) {
-                        const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
-                        checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
+                        else {
+                            inferenceContext = createInferenceContext(candidate.typeParameters, candidate, /*flags*/ isInJSFile(node) ? InferenceFlags.AnyDefault : InferenceFlags.None);
+                            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | CheckMode.SkipGenericFunctions, inferenceContext);
+                            argCheckMode |= inferenceContext.flags & InferenceFlags.SkippedGenericFunction ? CheckMode.SkipGenericFunctions : CheckMode.Normal;
+                        }
+                        checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
                         // If the original signature has a generic rest type, instantiation may produce a
                         // signature with different arity and we need to perform another arity check.
                         if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
                             candidateForArgumentArityError = checkCandidate;
                             continue;
                         }
                     }
+                    else {
+                        checkCandidate = candidate;
+                    }
                     if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) {
                         // Give preference to error candidates that have no rest parameters (as they are more specific)
                         (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
                         continue;
                     }
+                    if (argCheckMode) {
+                        // If one or more context sensitive arguments were excluded, we start including
+                        // them now (and keeping do so for any subsequent candidates) and perform a second
+                        // round of type inference and applicability checking for this particular candidate.
+                        argCheckMode = CheckMode.Normal;
+                        if (inferenceContext) {
+                            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+                            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
+                            // If the original signature has a generic rest type, instantiation may produce a
+                            // signature with different arity and we need to perform another arity check.
+                            if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
+                                candidateForArgumentArityError = checkCandidate;
+                                continue;
+                            }
+                        }
+                        if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) {
+                            // Give preference to error candidates that have no rest parameters (as they are more specific)
+                            (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
+                            continue;
+                        }
+                    }
+                    candidates[candidateIndex] = checkCandidate;
+                    return checkCandidate;
                 }
-                candidates[candidateIndex] = checkCandidate;
-                return checkCandidate;
-            }
 
-            return undefined;
+                return undefined;
+            })();
+            chooseOverloadFlushNodesSignaturesReq[chooseOverloadRecursionLevel] = undefined;
+            chooseOverloadRecursionLevel--;
+            return result;
         }
     }
 
@@ -35159,14 +35170,19 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // since resolving such signature leads to resolving the potential outer signature, its arguments and thus the very same signature
             // it's possible that this inner resolution sets the resolvedSignature first.
             // In such a case we ignore the local result and reuse the correct one that was cached.
-            if (links.resolvedSignature !== resolvingSignature) {
+            // [cph 56013] This is buggy - links.resolvedSignature could be `undefined`. Unfortunately flow did not warn us.
+            // if (links.resolvedSignature !== resolvingSignature) {
+            //     result = links.resolvedSignature;
+            // }
+            if (links.resolvedSignature /* #56013 */ && links.resolvedSignature !== resolvingSignature) {
                 result = links.resolvedSignature;
             }
             // If signature resolution originated in control flow type analysis (for example to compute the
             // assigned type in a flow assignment) we don't cache the result as it may be based on temporary
             // types from the control flow analysis.
             links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
         }
+        Debug.assert(result); // [cph] #56013
         return result;
     }
 
@@ -35361,6 +35377,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function checkDeprecatedSignature(signature: Signature, node: CallLikeExpression) {
+        Debug.assert(signature);
         if (signature.flags & SignatureFlags.IsSignatureCandidateForOverloadFailure) return;
         if (signature.declaration && signature.declaration.flags & NodeFlags.Deprecated) {
             const suggestionNode = getDeprecatedSuggestionNode(node);
@@ -38932,6 +38949,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const saveCurrentNode = currentNode;
         currentNode = node;
         instantiationCount = 0;
+        // #56013
+        if (node.kind === SyntaxKind.CallExpression && chooseOverloadRecursionLevel >= 0) {
+            let setOfNode: Set<Node> | undefined;
+            if (chooseOverloadRecursionLevel >= 0 && (setOfNode = chooseOverloadFlushNodesSignaturesReq[chooseOverloadRecursionLevel])) {
+                if (!setOfNode.has(node)) {
+                    getNodeLinks(node).resolvedSignature = undefined;
+                    setOfNode.add(node);
+                }
+            }
+        }
         const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
         const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
         if (isConstEnumObjectType(type)) {

tests/baselines/reference/arrayFilterBooleanExternalOverload2.types

@@ -72,7 +72,7 @@ declare const maybe: boolean;
 >'bar' : "bar"
 >undefined : undefined
 >filter : { <S extends string | undefined>(predicate: (value: string | undefined, index: number, array: (string | undefined)[]) => value is S, thisArg?: any): S[]; (predicate: (value: string | undefined, index: number, array: (string | undefined)[]) => unknown, thisArg?: any): (string | undefined)[]; (predicate: BooleanConstructor & { prototype: unique symbol; }): string[]; }
->id() : (t: unknown) => boolean
+>id() : (t: string | undefined) => boolean
 >id : <T>() => (t: T) => boolean
 
     result2;

tests/baselines/reference/arrayFilterBooleanExternalOverload4.errors.txt

@@ -49,6 +49,6 @@ interface F2<T extends number, U extends number> {
 type ID = <I>() => (i: I) => I;
 declare const id: ID;
 declare const t11: 11;
-declare const t12: never;
-declare const t21: never;
-declare const t22: never;
+declare const t12: 19;
+declare const t21: 91;
+declare const t22: 99;

tests/baselines/reference/arrayFilterBooleanExternalOverload4.js

@@ -49,37 +49,37 @@ const t11 = (0 as any as F2<1,1>)(id(),id());
 >id : ID
 
 const t12 = (0 as any as F2<1,2>)(id(),id());
->t12 : never
->(0 as any as F2<1,2>)(id(),id()) : never
+>t12 : 19
+>(0 as any as F2<1,2>)(id(),id()) : 19
 >(0 as any as F2<1,2>) : F2<1, 2>
 >0 as any as F2<1,2> : F2<1, 2>
 >0 as any : any
 >0 : 0
 >id() : (i: 1) => 1
 >id : ID
->id() : (i: 1) => 1
+>id() : (i: 2) => 2
 >id : ID
 
 const t21 = (0 as any as F2<2,1>)(id(),id());
->t21 : never
->(0 as any as F2<2,1>)(id(),id()) : never
+>t21 : 91
+>(0 as any as F2<2,1>)(id(),id()) : 91
 >(0 as any as F2<2,1>) : F2<2, 1>
 >0 as any as F2<2,1> : F2<2, 1>
 >0 as any : any
 >0 : 0
->id() : (i: 1) => 1
+>id() : (i: 2) => 2
 >id : ID
 >id() : (i: 1) => 1
 >id : ID
 
 const t22 = (0 as any as F2<2,2>)(id(),id());
->t22 : never
->(0 as any as F2<2,2>)(id(),id()) : never
+>t22 : 99
+>(0 as any as F2<2,2>)(id(),id()) : 99
 >(0 as any as F2<2,2>) : F2<2, 2>
 >0 as any as F2<2,2> : F2<2, 2>
 >0 as any : any
 >0 : 0
->id() : (i: 1) => 1
+>id() : (i: 2) => 2
 >id : ID
 >id() : (i: 2) => 2
 >id : ID
@@ -89,15 +89,15 @@ t11 satisfies 11;
 >t11 : 11
 
 t12 satisfies 19;
->t12 satisfies 19 : never
->t12 : never
+>t12 satisfies 19 : 19
+>t12 : 19
 
 t21 satisfies 91;
->t21 satisfies 91 : never
->t21 : never
+>t21 satisfies 91 : 91
+>t21 : 91
 
 t22 satisfies 99;
->t22 satisfies 99 : never
->t22 : never
+>t22 satisfies 99 : 99
+>t22 : 99