Fix borked test, re-add type parameter copying

Author: weswigham

src/compiler/checker.ts

@@ -15632,6 +15632,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         );
     }
 
+    function getImplementationSignature(signature: Signature) {
+        return signature.typeParameters ?
+            signature.implementationSignatureCache ||= createImplementationSignature(signature) :
+            signature;
+    }
+
+    function createImplementationSignature(signature: Signature) {
+        return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
+    }
+
     function getBaseSignature(signature: Signature) {
         const typeParameters = signature.typeParameters;
         if (typeParameters) {
@@ -26364,9 +26374,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // inference error only occurs when there are *conflicting* candidates, i.e.
                     // candidates with no common supertype.
                     const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
-                    // Instantiate the default type. Any forward reference to a type
-                    // parameter should be instantiated to the empty object type.
-                    inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
+                    if (defaultType) {
+                        // Instantiate the default type. Any forward reference to a type
+                        // parameter should be instantiated to the empty object type.
+                        inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
+                    }
                 }
             }
             else {
@@ -34867,7 +34879,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
 
             for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
-                const candidate = candidates[candidateIndex];
+                let candidate = candidates[candidateIndex];
                 if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) {
                     continue;
                 }
@@ -34876,6 +34888,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 let inferenceContext: InferenceContext | undefined;
 
                 if (candidate.typeParameters) {
+                    // If we are *inside the body of candidate*, we need to create a clone of `candidate` with differing type parameter identities,
+                    // so our inference results for this call doesn't pollute expression types referencing the outer type parameter!
+                    if (candidate.declaration && findAncestor(node, a => a === candidate.declaration)) {
+                        candidate = getImplementationSignature(candidate);
+                    }
                     let typeArgumentTypes: readonly Type[] | undefined;
                     if (some(typeArguments)) {
                         typeArgumentTypes = checkTypeArguments(candidate, typeArguments, /*reportErrors*/ false);
@@ -34885,7 +34902,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         }
                     }
                     else {
-                        inferenceContext = createInferenceContext(candidate.typeParameters, candidate, /*flags*/ isInJSFile(node) ? InferenceFlags.AnyDefault : InferenceFlags.None);
+                        inferenceContext = createInferenceContext(candidate.typeParameters!, candidate, /*flags*/ isInJSFile(node) ? InferenceFlags.AnyDefault : InferenceFlags.None);
                         // The resulting type arguments are instantiated with the inference context mapper, as the inferred types may still contain references to the inference context's
                         //  type variables via contextual projection. These are kept generic until all inferences are locked in, so the dependencies expressed can pass constraint checks.
                         typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | CheckMode.SkipGenericFunctions, inferenceContext), inferenceContext.nonFixingMapper);

src/compiler/types.ts

@@ -6819,6 +6819,8 @@ export interface Signature {
     isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison
     /** @internal */
     instantiations?: Map<string, Signature>;    // Generic signature instantiation cache
+    /** @internal */
+    implementationSignatureCache?: Signature;  // Copy of the signature with fresh type parameters to use in checking the body of a potentially self-referential generic function (deferred)
 }
 
 export const enum IndexKind {

tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.js

@@ -22,7 +22,7 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
         const result = fn(input)
         return {
             then(onFulfilled) {
-                return toThenable(onFulfilled)(result as Result)
+                return toThenableInferred(onFulfilled)(result as Result)
             }
         };
     }
@@ -45,7 +45,7 @@ var toThenableInferred = function (fn) {
         var result = fn(input);
         return {
             then: function (onFulfilled) {
-                return toThenable(onFulfilled)(result);
+                return toThenableInferred(onFulfilled)(result);
             }
         };
     };

tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.symbols

@@ -93,8 +93,8 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
 >then : Symbol(then, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 19, 16))
 >onFulfilled : Symbol(onFulfilled, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 20, 17))
 
-                return toThenable(onFulfilled)(result as Result)
->toThenable : Symbol(toThenable, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 6, 5))
+                return toThenableInferred(onFulfilled)(result as Result)
+>toThenableInferred : Symbol(toThenableInferred, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 16, 5))
 >onFulfilled : Symbol(onFulfilled, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 20, 17))
 >result : Symbol(result, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 18, 13))
 >Result : Symbol(Result, Decl(genericCallWithinOwnBodyCastTypeParameterIdentity.ts, 16, 28))

tests/baselines/reference/genericCallWithinOwnBodyCastTypeParameterIdentity.types

@@ -49,12 +49,12 @@ const toThenable = <Result, Input>(fn: (input: Input) => Result | Thenable<Resul
 
 const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) =>
 >toThenableInferred : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
-><Result, Input>(fn: (input: Input) => Result | Thenable<Result>) =>    (input: Input): Thenable<Result> => {        const result = fn(input)        return {            then(onFulfilled) {                return toThenable(onFulfilled)(result as Result)            }        };    } : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
+><Result, Input>(fn: (input: Input) => Result | Thenable<Result>) =>    (input: Input): Thenable<Result> => {        const result = fn(input)        return {            then(onFulfilled) {                return toThenableInferred(onFulfilled)(result as Result)            }        };    } : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
 >fn : (input: Input) => Result | Thenable<Result>
 >input : Input
 
     (input: Input): Thenable<Result> => {
->(input: Input): Thenable<Result> => {        const result = fn(input)        return {            then(onFulfilled) {                return toThenable(onFulfilled)(result as Result)            }        };    } : (input: Input) => Thenable<Result>
+>(input: Input): Thenable<Result> => {        const result = fn(input)        return {            then(onFulfilled) {                return toThenableInferred(onFulfilled)(result as Result)            }        };    } : (input: Input) => Thenable<Result>
 >input : Input
 
         const result = fn(input)
@@ -64,16 +64,16 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
 >input : Input
 
         return {
->{            then(onFulfilled) {                return toThenable(onFulfilled)(result as Result)            }        } : { then<V>(onFulfilled: (value: Result) => V | Thenable<V>): Thenable<V>; }
+>{            then(onFulfilled) {                return toThenableInferred(onFulfilled)(result as Result)            }        } : { then<V>(onFulfilled: (value: Result) => V | Thenable<V>): Thenable<V>; }
 
             then(onFulfilled) {
 >then : <V>(onFulfilled: (value: Result) => V | Thenable<V>) => Thenable<V>
 >onFulfilled : (value: Result) => V | Thenable<V>
 
-                return toThenable(onFulfilled)(result as Result)
->toThenable(onFulfilled)(result as Result) : Thenable<V>
->toThenable(onFulfilled) : (input: Result) => Thenable<V>
->toThenable : <Result_1, Input_1>(fn: (input: Input_1) => Result_1 | Thenable<Result_1>) => (input: Input_1) => Thenable<Result_1>
+                return toThenableInferred(onFulfilled)(result as Result)
+>toThenableInferred(onFulfilled)(result as Result) : Thenable<V>
+>toThenableInferred(onFulfilled) : (input: Result) => Thenable<V>
+>toThenableInferred : <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) => (input: Input) => Thenable<Result>
 >onFulfilled : (value: Result) => V | Thenable<V>
 >result as Result : Result
 >result : Result | Thenable<Result>

tests/cases/compiler/genericCallWithinOwnBodyCastTypeParameterIdentity.ts

@@ -20,7 +20,7 @@ const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenab
         const result = fn(input)
         return {
             then(onFulfilled) {
-                return toThenable(onFulfilled)(result as Result)
+                return toThenableInferred(onFulfilled)(result as Result)
             }
         };
     }