Look at properties of constraint-instantiated optional mapped types when deciding assignability

Author: andrewbranch

src/compiler/checker.ts

@@ -13200,14 +13200,14 @@ namespace ts {
                         if (!isGenericMappedType(source)) {
                             const targetConstraint = getConstraintTypeFromMappedType(target);
                             const sourceKeys = getIndexType(source, /*stringsOnly*/ undefined, /*noIndexSignatures*/ true);
-                            const hasOptionalUnionKeys = modifiers & MappedTypeModifiers.IncludeOptional && targetConstraint.flags & TypeFlags.Union;
-                            const filteredByApplicability = hasOptionalUnionKeys ? filterType(targetConstraint, t => !!isRelatedTo(t, sourceKeys)) : undefined;
+                            const includeOptional = modifiers & MappedTypeModifiers.IncludeOptional;
+                            const filteredByApplicability = includeOptional ? filterType(getLiteralTypeFromProperties(target, TypeFlags.StringOrNumberLiteralOrUnique), t => !!isRelatedTo(t, sourceKeys)) : undefined;
                             // A source type T is related to a target type { [P in Q]: X } if Q is related to keyof T and T[Q] is related to X.
                             // A source type T is related to a target type { [P in Q]?: X } if some constituent Q' of Q is related to keyof T and T[Q'] is related to X.
-                            if (hasOptionalUnionKeys
+                            if (includeOptional
                                     ? !(filteredByApplicability!.flags & TypeFlags.Never)
                                     : isRelatedTo(targetConstraint, sourceKeys)) {
-                                const indexingType = hasOptionalUnionKeys ? filteredByApplicability! : getTypeParameterFromMappedType(target);
+                                const indexingType = filteredByApplicability || getTypeParameterFromMappedType(target);
                                 const indexedAccessType = getIndexedAccessType(source, indexingType);
                                 const templateType = getTemplateTypeFromMappedType(target);
                                 if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {

tests/baselines/reference/circularlyConstrainedMappedTypeContainingConditionalNoInfiniteInstantiationDepth.errors.txt

@@ -386,4 +386,10 @@ tests/cases/conformance/types/mapped/mappedTypeRelationships.ts(168,5): error TS
     function f82<T, K1 extends keyof T, K2 extends keyof T[K1]>(t: T, k1: K1, k2: K2): Partial<T[K1][K2]> {
         return t[k1][k2];
     }
+    
+    // #31070
+    type Numeric<T> = { [K in keyof T]?: number };
+    function f90<T extends { x: number }>() {
+        const n: Numeric<T> = { x: 1 };
+    }
 

tests/baselines/reference/mappedTypeRelationships.errors.txt

@@ -180,6 +180,12 @@ function f81<T, K extends keyof T>(t: T, k: K): Partial<T[K]> {
 function f82<T, K1 extends keyof T, K2 extends keyof T[K1]>(t: T, k1: K1, k2: K2): Partial<T[K1][K2]> {
     return t[k1][k2];
 }
+
+// #31070
+type Numeric<T> = { [K in keyof T]?: number };
+function f90<T extends { x: number }>() {
+    const n: Numeric<T> = { x: 1 };
+}
 
 
 //// [mappedTypeRelationships.js]
@@ -310,6 +316,9 @@ function f81(t, k) {
 function f82(t, k1, k2) {
     return t[k1][k2];
 }
+function f90() {
+    var n = { x: 1 };
+}
 
 
 //// [mappedTypeRelationships.d.ts]
@@ -393,3 +402,9 @@ declare function f76<T, U extends T, K extends keyof T>(x: {
 declare function f80<T>(t: T): Partial<T>;
 declare function f81<T, K extends keyof T>(t: T, k: K): Partial<T[K]>;
 declare function f82<T, K1 extends keyof T, K2 extends keyof T[K1]>(t: T, k1: K1, k2: K2): Partial<T[K1][K2]>;
+declare type Numeric<T> = {
+    [K in keyof T]?: number;
+};
+declare function f90<T extends {
+    x: number;
+}>(): void;

tests/baselines/reference/mappedTypeRelationships.js

@@ -805,3 +805,22 @@ function f82<T, K1 extends keyof T, K2 extends keyof T[K1]>(t: T, k1: K1, k2: K2
 >k2 : Symbol(k2, Decl(mappedTypeRelationships.ts, 178, 73))
 }
 
+// #31070
+type Numeric<T> = { [K in keyof T]?: number };
+>Numeric : Symbol(Numeric, Decl(mappedTypeRelationships.ts, 180, 1))
+>T : Symbol(T, Decl(mappedTypeRelationships.ts, 183, 13))
+>K : Symbol(K, Decl(mappedTypeRelationships.ts, 183, 21))
+>T : Symbol(T, Decl(mappedTypeRelationships.ts, 183, 13))
+
+function f90<T extends { x: number }>() {
+>f90 : Symbol(f90, Decl(mappedTypeRelationships.ts, 183, 46))
+>T : Symbol(T, Decl(mappedTypeRelationships.ts, 184, 13))
+>x : Symbol(x, Decl(mappedTypeRelationships.ts, 184, 24))
+
+    const n: Numeric<T> = { x: 1 };
+>n : Symbol(n, Decl(mappedTypeRelationships.ts, 185, 9))
+>Numeric : Symbol(Numeric, Decl(mappedTypeRelationships.ts, 180, 1))
+>T : Symbol(T, Decl(mappedTypeRelationships.ts, 184, 13))
+>x : Symbol(x, Decl(mappedTypeRelationships.ts, 185, 27))
+}
+

tests/baselines/reference/mappedTypeRelationships.symbols

@@ -653,3 +653,18 @@ function f82<T, K1 extends keyof T, K2 extends keyof T[K1]>(t: T, k1: K1, k2: K2
 >k2 : K2
 }
 
+// #31070
+type Numeric<T> = { [K in keyof T]?: number };
+>Numeric : Numeric<T>
+
+function f90<T extends { x: number }>() {
+>f90 : <T extends { x: number; }>() => void
+>x : number
+
+    const n: Numeric<T> = { x: 1 };
+>n : Numeric<T>
+>{ x: 1 } : { x: number; }
+>x : number
+>1 : 1
+}
+