Propegate outer type parameters of single signature types

weswigham · weswigham · commit 1ea52a45e261 · 2024-02-13T15:37:54.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -965,6 +965,7 @@ import {
     SignatureFlags,
     SignatureKind,
     singleElementArray,
+    SingleSignatureType,
     skipOuterExpressions,
     skipParentheses,
     skipTrivia,
@@ -7088,7 +7089,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
                 const abstractSignatures = filter(resolved.constructSignatures, signature => !!(signature.flags & SignatureFlags.Abstract));
                 if (some(abstractSignatures)) {
-                    const types = map(abstractSignatures, getOrCreateTypeFromSignature);
+                    const types = map(abstractSignatures, s => getOrCreateTypeFromSignature(s));
                     // count the number of type elements excluding abstract constructors
                     const typeElementCount = resolved.callSignatures.length +
                         (resolved.constructSignatures.length - abstractSignatures.length) +
@@ -15648,7 +15649,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return signature;
     }
 
-    function getOrCreateTypeFromSignature(signature: Signature): ObjectType {
+    function getOrCreateTypeFromSignature(signature: Signature, outerTypeParameters?: TypeParameter[]): ObjectType {
         // There are two ways to declare a construct signature, one is by declaring a class constructor
         // using the constructor keyword, and the other is declaring a bare construct signature in an
         // object type literal or interface (using the new keyword). Each way of declaring a constructor
@@ -15659,7 +15660,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // If declaration is undefined, it is likely to be the signature of the default constructor.
             const isConstructor = kind === undefined || kind === SyntaxKind.Constructor || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.ConstructorType;
 
-            const type = createObjectType(ObjectFlags.Anonymous);
+            // The type must have a symbol with a `Function` flag and a declaration in order to be correctly flagged as possibly containing
+            // type variables by `couldContainTypeVariables`
+            const type = createObjectType(ObjectFlags.Anonymous | ObjectFlags.SingleSignatureType, createSymbol(SymbolFlags.Function, InternalSymbolName.Function)) as SingleSignatureType;
+            if (signature.declaration) {
+                type.symbol.declarations = [signature.declaration];
+                type.symbol.valueDeclaration = signature.declaration;
+            }
+            outerTypeParameters ||= signature.declaration && getOuterTypeParameters(signature.declaration, /*includeThisTypes*/ true);
+            type.outerTypeParameters = outerTypeParameters;
+
             type.members = emptySymbols;
             type.properties = emptyArray;
             type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -19630,7 +19640,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const links = getNodeLinks(declaration);
         const target = type.objectFlags & ObjectFlags.Reference ? links.resolvedType! as DeferredTypeReference :
             type.objectFlags & ObjectFlags.Instantiated ? type.target! : type;
-        let typeParameters = links.outerTypeParameters;
+        let typeParameters = type.objectFlags & ObjectFlags.SingleSignatureType ? (type as SingleSignatureType).outerTypeParameters : links.outerTypeParameters;
         if (!typeParameters) {
             // The first time an anonymous type is instantiated we compute and store a list of the type
             // parameters that are in scope (and therefore potentially referenced). For type literals that
@@ -19860,6 +19870,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         if (type.objectFlags & ObjectFlags.InstantiationExpressionType) {
             (result as InstantiationExpressionType).node = (type as InstantiationExpressionType).node;
         }
+        if (type.objectFlags & ObjectFlags.SingleSignatureType) {
+            (result as SingleSignatureType).outerTypeParameters = (type as SingleSignatureType).outerTypeParameters;
+        }
         result.target = type;
         result.mapper = mapper;
         result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -25483,6 +25496,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
     }
 
+    /**
+     * @returns `true` if `type` has the shape `[T[0]]` where `T` is `typeParameter`
+     */
+    function isTupleOfSelf(typeParameter: TypeParameter, type: Type) {
+        return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1" as __String);
+    }
+
     function inferTypes(inferences: InferenceInfo[], originalSource: Type, originalTarget: Type, priority = InferencePriority.None, contravariant = false) {
         let bivariant = false;
         let propagationType: Type;
@@ -25611,6 +25631,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             inference.priority = priority;
                         }
                         if (priority === inference.priority) {
+                            // Inferring A to [A[0]] is a zero information inference (it guarantees A becomes its constraint), but oft arises from generic argument list inferences
+                            // By discarding it early, we can allow more fruitful results to be used instead.
+                            if (isTupleOfSelf(inference.typeParameter, candidate)) {
+                                return;
+                            }
                             // We make contravariant inferences only if we are in a pure contravariant position,
                             // i.e. only if we have not descended into a bivariant position.
                             if (contravariant && !bivariant) {
@@ -26347,23 +26372,25 @@ 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);
-                    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));
-                    }
+                    inferredType = defaultType;
                 }
             }
             else {
                 inferredType = getTypeFromInference(inference);
             }
 
-            inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & InferenceFlags.AnyDefault));
+            const isDefault = !inferredType;
+            inferredType ||= getDefaultTypeArgumentType(!!(context.flags & InferenceFlags.AnyDefault));
+            inference.inferredType = inferredType;
+            // Instantiate the inferred type. Any forward reference to a type
+            // parameter should be instantiated to the empty object type.
+            inferredType = instantiateType(inferredType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
+            inference.inferredType = inferredType;
 
             const constraint = getConstraintOfTypeParameter(inference.typeParameter);
             if (constraint) {
                 const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
-                if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
+                if (isDefault || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
                     // If the fallback type satisfies the constraint, we pick it. Otherwise, we pick the constraint.
                     inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
                 }
@@ -34265,7 +34292,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // If one or more arguments are still excluded (as indicated by CheckMode.SkipContextSensitive),
                 // we obtain the regular type of any object literal arguments because we may not have inferred complete
                 // parameter types yet and therefore excess property checks may yield false positives (see #17041).
-                const checkArgType = checkMode & CheckMode.SkipContextSensitive ? getRegularTypeOfObjectLiteral(argType) : argType;
+                const checkArgType = instantiateType(checkMode & CheckMode.SkipContextSensitive ? getRegularTypeOfObjectLiteral(argType) : argType, signature.mapper);
                 const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
                 if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? effectiveCheckArgumentNode : undefined, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
                     Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -39287,7 +39314,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                                 }
                             }
                         }
-                        return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+                        // TODO: The signature may reference any outer inference contexts, but we map pop off and then apply new inference contexts, and thus get different inferred types.
+                        // That this is cached on the *first* such attempt is not currently an issue, since expression types *also* get cached on the first pass. If we ever properly speculate, though,
+                        // the cached "isolatedSignatureType" signature field absolutely needs to be included in the list of speculative caches.
+                        return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, c => c && map(c.inferences, i => i.typeParameter)).slice());
                     }
                 }
             }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -6317,6 +6317,7 @@ export const enum ObjectFlags {
     ContainsSpread   = 1 << 21,  // Object literal contains spread operation
     ObjectRestType   = 1 << 22,  // Originates in object rest declaration
     InstantiationExpressionType = 1 << 23,  // Originates in instantiation expression
+    SingleSignatureType = 1 << 27,  // A single signature type extracted from a potentially broader type
     /** @internal */
     IsClassInstanceClone = 1 << 24, // Type is a clone of a class instance type
     // Flags that require TypeFlags.Object and ObjectFlags.Reference
@@ -6527,6 +6528,12 @@ export interface AnonymousType extends ObjectType {
     instantiations?: Map<string, Type>; // Instantiations of generic type alias (undefined if non-generic)
 }
 
+/** @internal */
+// A SingleSignatureType may have bespoke outer type parameters to handle free type variable inferences
+export interface SingleSignatureType extends AnonymousType {
+    outerTypeParameters?: TypeParameter[];
+}
+
 /** @internal */
 export interface InstantiationExpressionType extends AnonymousType {
     node: NodeWithTypeArguments;
diff --git a/tests/baselines/reference/nestedGenericSpreadInference.js b/tests/baselines/reference/nestedGenericSpreadInference.js
@@ -0,0 +1,14 @@
+//// [tests/cases/compiler/nestedGenericSpreadInference.ts] ////
+
+//// [nestedGenericSpreadInference.ts]
+declare function wrap<X>(x: X): { x: X };
+declare function call<A extends unknown[], T>(x: { x: (...args: A) => T }, ...args: A): T;
+
+// This should be of type `number` - ideally, it also would not error.
+const leak = call(wrap(<T>(x: T) => x), 1);
+
+
+//// [nestedGenericSpreadInference.js]
+"use strict";
+// This should be of type `number` - ideally, it also would not error.
+var leak = call(wrap(function (x) { return x; }), 1);
diff --git a/tests/baselines/reference/nestedGenericSpreadInference.symbols b/tests/baselines/reference/nestedGenericSpreadInference.symbols
@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/nestedGenericSpreadInference.ts] ////
+
+=== nestedGenericSpreadInference.ts ===
+declare function wrap<X>(x: X): { x: X };
+>wrap : Symbol(wrap, Decl(nestedGenericSpreadInference.ts, 0, 0))
+>X : Symbol(X, Decl(nestedGenericSpreadInference.ts, 0, 22))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 0, 25))
+>X : Symbol(X, Decl(nestedGenericSpreadInference.ts, 0, 22))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 0, 33))
+>X : Symbol(X, Decl(nestedGenericSpreadInference.ts, 0, 22))
+
+declare function call<A extends unknown[], T>(x: { x: (...args: A) => T }, ...args: A): T;
+>call : Symbol(call, Decl(nestedGenericSpreadInference.ts, 0, 41))
+>A : Symbol(A, Decl(nestedGenericSpreadInference.ts, 1, 22))
+>T : Symbol(T, Decl(nestedGenericSpreadInference.ts, 1, 42))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 1, 46))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 1, 50))
+>args : Symbol(args, Decl(nestedGenericSpreadInference.ts, 1, 55))
+>A : Symbol(A, Decl(nestedGenericSpreadInference.ts, 1, 22))
+>T : Symbol(T, Decl(nestedGenericSpreadInference.ts, 1, 42))
+>args : Symbol(args, Decl(nestedGenericSpreadInference.ts, 1, 74))
+>A : Symbol(A, Decl(nestedGenericSpreadInference.ts, 1, 22))
+>T : Symbol(T, Decl(nestedGenericSpreadInference.ts, 1, 42))
+
+// This should be of type `number` - ideally, it also would not error.
+const leak = call(wrap(<T>(x: T) => x), 1);
+>leak : Symbol(leak, Decl(nestedGenericSpreadInference.ts, 4, 5))
+>call : Symbol(call, Decl(nestedGenericSpreadInference.ts, 0, 41))
+>wrap : Symbol(wrap, Decl(nestedGenericSpreadInference.ts, 0, 0))
+>T : Symbol(T, Decl(nestedGenericSpreadInference.ts, 4, 24))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 4, 27))
+>T : Symbol(T, Decl(nestedGenericSpreadInference.ts, 4, 24))
+>x : Symbol(x, Decl(nestedGenericSpreadInference.ts, 4, 27))
+
diff --git a/tests/baselines/reference/nestedGenericSpreadInference.types b/tests/baselines/reference/nestedGenericSpreadInference.types
@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/nestedGenericSpreadInference.ts] ////
+
+=== nestedGenericSpreadInference.ts ===
+declare function wrap<X>(x: X): { x: X };
+>wrap : <X>(x: X) => {    x: X;}
+>x : X
+>x : X
+
+declare function call<A extends unknown[], T>(x: { x: (...args: A) => T }, ...args: A): T;
+>call : <A extends unknown[], T>(x: { x: (...args: A) => T; }, ...args: A) => T
+>x : { x: (...args: A) => T; }
+>x : (...args: A) => T
+>args : A
+>args : A
+
+// This should be of type `number` - ideally, it also would not error.
+const leak = call(wrap(<T>(x: T) => x), 1);
+>leak : number
+>call(wrap(<T>(x: T) => x), 1) : number
+>call : <A extends unknown[], T>(x: { x: (...args: A) => T; }, ...args: A) => T
+>wrap(<T>(x: T) => x) : { x: (x: A[0]) => A[0]; }
+>wrap : <X>(x: X) => { x: X; }
+><T>(x: T) => x : <T>(x: T) => T
+>x : T
+>x : T
+>1 : 1
+
diff --git a/tests/cases/compiler/nestedGenericSpreadInference.ts b/tests/cases/compiler/nestedGenericSpreadInference.ts
@@ -0,0 +1,6 @@
+// @strict: true
+declare function wrap<X>(x: X): { x: X };
+declare function call<A extends unknown[], T>(x: { x: (...args: A) => T }, ...args: A): T;
+
+// This should be of type `number` - ideally, it also would not error.
+const leak = call(wrap(<T>(x: T) => x), 1);
