Handle propagating substitution types to retain constraints on positions through instantiation

Author: weswigham

src/compiler/checker.ts

@@ -4064,7 +4064,7 @@ namespace ts {
     // Thus, if Foo has a 'string' constraint on its type parameter, T will satisfy it. Substitution
     // types disappear upon instantiation (just like type parameters).
     export interface SubstitutionType extends InstantiableType {
-        typeVariable: TypeVariable;  // Target type variable
+        typeVariable: Type;          // Target type variable
         substitute: Type;            // Type to substitute for type parameter
         negatedTypes?: Type[];       // Types proven that this type variables _doesn't_ extend
     }
@@ -4153,6 +4153,7 @@ namespace ts {
         InferUnionTypes = 1 << 0,  // Infer union types for disjoint candidates (otherwise unknownType)
         NoDefault       = 1 << 1,  // Infer unknownType for no inferences (otherwise anyType or emptyObjectType)
         AnyDefault      = 1 << 2,  // Infer anyType for no inferences (otherwise emptyObjectType)
+        SkipConstraintCheck = 1 << 3, // Skip checking weather the inference is assignable to the constraint (otherwise is replaced with constraint)
     }
 
     /**

src/compiler/types.ts

@@ -2300,7 +2300,7 @@ declare namespace ts {
         resolvedFalseType?: Type;
     }
     interface SubstitutionType extends InstantiableType {
-        typeVariable: TypeVariable;
+        typeVariable: Type;
         substitute: Type;
         negatedTypes?: Type[];
     }

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -2300,7 +2300,7 @@ declare namespace ts {
         resolvedFalseType?: Type;
     }
     interface SubstitutionType extends InstantiableType {
-        typeVariable: TypeVariable;
+        typeVariable: Type;
         substitute: Type;
         negatedTypes?: Type[];
     }

tests/baselines/reference/api/typescript.d.ts

@@ -0,0 +1,19 @@
+tests/cases/compiler/conditionalTypeGenericAssignability.ts(3,5): error TS2322: Type '0' is not assignable to type 'Extract<keyof T, string>'.
+tests/cases/compiler/conditionalTypeGenericAssignability.ts(7,5): error TS2322: Type '"foo"' is not assignable to type 'Exclude<keyof T, string>'.
+
+
+==== tests/cases/compiler/conditionalTypeGenericAssignability.ts (2 errors) ====
+    function f1<T extends { foo: unknown; 0: unknown }>(_a: T, b: Extract<keyof T, string>) {
+        b = "foo"; // succeeds
+        b = 0; // errors
+        ~
+!!! error TS2322: Type '0' is not assignable to type 'Extract<keyof T, string>'.
+    }
+    
+    function f2<T extends { foo: unknown; 0: unknown }>(_a: T, b: Exclude<keyof T, string>) {
+        b = "foo"; // errors
+        ~
+!!! error TS2322: Type '"foo"' is not assignable to type 'Exclude<keyof T, string>'.
+        b = 0; // succeeds
+    }
+    

tests/baselines/reference/conditionalTypeGenericAssignability.errors.txt

@@ -0,0 +1,22 @@
+//// [conditionalTypeGenericAssignability.ts]
+function f1<T extends { foo: unknown; 0: unknown }>(_a: T, b: Extract<keyof T, string>) {
+    b = "foo"; // succeeds
+    b = 0; // errors
+}
+
+function f2<T extends { foo: unknown; 0: unknown }>(_a: T, b: Exclude<keyof T, string>) {
+    b = "foo"; // errors
+    b = 0; // succeeds
+}
+
+
+//// [conditionalTypeGenericAssignability.js]
+"use strict";
+function f1(_a, b) {
+    b = "foo"; // succeeds
+    b = 0; // errors
+}
+function f2(_a, b) {
+    b = "foo"; // errors
+    b = 0; // succeeds
+}

tests/baselines/reference/conditionalTypeGenericAssignability.js

@@ -0,0 +1,37 @@
+=== tests/cases/compiler/conditionalTypeGenericAssignability.ts ===
+function f1<T extends { foo: unknown; 0: unknown }>(_a: T, b: Extract<keyof T, string>) {
+>f1 : Symbol(f1, Decl(conditionalTypeGenericAssignability.ts, 0, 0))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 0, 12))
+>foo : Symbol(foo, Decl(conditionalTypeGenericAssignability.ts, 0, 23))
+>0 : Symbol(0, Decl(conditionalTypeGenericAssignability.ts, 0, 37))
+>_a : Symbol(_a, Decl(conditionalTypeGenericAssignability.ts, 0, 52))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 0, 12))
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 0, 58))
+>Extract : Symbol(Extract, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 0, 12))
+
+    b = "foo"; // succeeds
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 0, 58))
+
+    b = 0; // errors
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 0, 58))
+}
+
+function f2<T extends { foo: unknown; 0: unknown }>(_a: T, b: Exclude<keyof T, string>) {
+>f2 : Symbol(f2, Decl(conditionalTypeGenericAssignability.ts, 3, 1))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 5, 12))
+>foo : Symbol(foo, Decl(conditionalTypeGenericAssignability.ts, 5, 23))
+>0 : Symbol(0, Decl(conditionalTypeGenericAssignability.ts, 5, 37))
+>_a : Symbol(_a, Decl(conditionalTypeGenericAssignability.ts, 5, 52))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 5, 12))
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 5, 58))
+>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(conditionalTypeGenericAssignability.ts, 5, 12))
+
+    b = "foo"; // errors
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 5, 58))
+
+    b = 0; // succeeds
+>b : Symbol(b, Decl(conditionalTypeGenericAssignability.ts, 5, 58))
+}
+

tests/baselines/reference/conditionalTypeGenericAssignability.symbols

@@ -0,0 +1,45 @@
+=== tests/cases/compiler/conditionalTypeGenericAssignability.ts ===
+function f1<T extends { foo: unknown; 0: unknown }>(_a: T, b: Extract<keyof T, string>) {
+>f1 : <T extends { foo: unknown; 0: unknown; }>(_a: T, b: Extract<keyof T, string>) => void
+>T : T
+>foo : unknown
+>0 : unknown
+>_a : T
+>T : T
+>b : Extract<keyof T, string>
+>Extract : Extract<T, U>
+>T : T
+
+    b = "foo"; // succeeds
+>b = "foo" : "foo"
+>b : Extract<keyof T, string>
+>"foo" : "foo"
+
+    b = 0; // errors
+>b = 0 : 0
+>b : Extract<keyof T, string>
+>0 : 0
+}
+
+function f2<T extends { foo: unknown; 0: unknown }>(_a: T, b: Exclude<keyof T, string>) {
+>f2 : <T extends { foo: unknown; 0: unknown; }>(_a: T, b: Exclude<keyof T, string>) => void
+>T : T
+>foo : unknown
+>0 : unknown
+>_a : T
+>T : T
+>b : Exclude<keyof T, string>
+>Exclude : Exclude<T, U>
+>T : T
+
+    b = "foo"; // errors
+>b = "foo" : "foo"
+>b : Exclude<keyof T, string>
+>"foo" : "foo"
+
+    b = 0; // succeeds
+>b = 0 : 0
+>b : Exclude<keyof T, string>
+>0 : 0
+}
+

tests/baselines/reference/conditionalTypeGenericAssignability.types

@@ -320,7 +320,7 @@ type T61<T> = infer A extends infer B ? infer C : infer D;  // Error
 >D : D
 
 type T62<T> = U extends (infer U)[] ? U : U;  // Error
->T62 : any
+>T62 : {} | any
 >T : T
 >U : No type information available!
 >U : U

tests/baselines/reference/inferTypes1.types

@@ -0,0 +1,10 @@
+// @strict: true
+function f1<T extends { foo: unknown; 0: unknown }>(_a: T, b: Extract<keyof T, string>) {
+    b = "foo"; // succeeds
+    b = 0; // errors
+}
+
+function f2<T extends { foo: unknown; 0: unknown }>(_a: T, b: Exclude<keyof T, string>) {
+    b = "foo"; // errors
+    b = 0; // succeeds
+}