Mapped type and string index signature relations

src/compiler/checker.ts

@@ -9614,6 +9614,11 @@ namespace ts {
                 if (sourceInfo) {
                     return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors);
                 }
+                if (isGenericMappedType(source)) {
+                    // A generic mapped type { [P in K]: T } is related to an index signature { [x: string]: U }
+                    // if T is related to U.
+                    return kind === IndexKind.String && isRelatedTo(getTemplateTypeFromMappedType(<MappedType>source), targetInfo.type, reportErrors);
+                }
                 if (isObjectLiteralType(source)) {
                     let related = Ternary.True;
                     if (kind === IndexKind.String) {

tests/baselines/reference/indexSignatureAndMappedType.errors.txt

@@ -0,0 +1,47 @@
+tests/cases/compiler/indexSignatureAndMappedType.ts(6,5): error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, T>'.
+tests/cases/compiler/indexSignatureAndMappedType.ts(15,5): error TS2322: Type 'Record<K, U>' is not assignable to type '{ [key: string]: T; }'.
+  Type 'U' is not assignable to type 'T'.
+tests/cases/compiler/indexSignatureAndMappedType.ts(16,5): error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, U>'.
+
+
+==== tests/cases/compiler/indexSignatureAndMappedType.ts (3 errors) ====
+    // A mapped type { [P in K]: X }, where K is a generic type, is related to
+    // { [key: string]: Y } if X is related to Y.
+
+    function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
+        x = y;
+        y = x;  // Error
+        ~
+!!! error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, T>'.
+    }
+
+    function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
+        x = y;
+        y = x;
+    }
+
+    function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
+        x = y;  // Error
+        ~
+!!! error TS2322: Type 'Record<K, U>' is not assignable to type '{ [key: string]: T; }'.
+!!! error TS2322:   Type 'U' is not assignable to type 'T'.
+        y = x;  // Error
+        ~
+!!! error TS2322: Type '{ [key: string]: T; }' is not assignable to type 'Record<K, U>'.
+    }
+
+    // Repro from #14548
+
+    type Dictionary = {
+        [key: string]: string;
+    };
+
+    interface IBaseEntity {
+        name: string;
+        properties: Dictionary;
+    }
+
+    interface IEntity<T extends string> extends IBaseEntity {
+        properties: Record<T, string>;
+    }
+

tests/baselines/reference/indexSignatureAndMappedType.js

@@ -0,0 +1,73 @@
+//// [indexSignatureAndMappedType.ts]
+// A mapped type { [P in K]: X }, where K is a generic type, is related to
+// { [key: string]: Y } if X is related to Y.
+
+function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
+    x = y;
+    y = x;  // Error
+}
+
+function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
+    x = y;
+    y = x;
+}
+
+function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
+    x = y;  // Error
+    y = x;  // Error
+}
+
+// Repro from #14548
+
+type Dictionary = {
+    [key: string]: string;
+};
+
+interface IBaseEntity {
+    name: string;
+    properties: Dictionary;
+}
+
+interface IEntity<T extends string> extends IBaseEntity {
+    properties: Record<T, string>;
+}
+
+
+//// [indexSignatureAndMappedType.js]
+"use strict";
+// A mapped type { [P in K]: X }, where K is a generic type, is related to
+// { [key: string]: Y } if X is related to Y.
+function f1(x, y) {
+    x = y;
+    y = x; // Error
+}
+function f2(x, y) {
+    x = y;
+    y = x;
+}
+function f3(x, y) {
+    x = y; // Error
+    y = x; // Error
+}
+
+
+//// [indexSignatureAndMappedType.d.ts]
+declare function f1<T, K extends string>(x: {
+    [key: string]: T;
+}, y: Record<K, T>): void;
+declare function f2<T>(x: {
+    [key: string]: T;
+}, y: Record<string, T>): void;
+declare function f3<T, U, K extends string>(x: {
+    [key: string]: T;
+}, y: Record<K, U>): void;
+declare type Dictionary = {
+    [key: string]: string;
+};
+interface IBaseEntity {
+    name: string;
+    properties: Dictionary;
+}
+interface IEntity<T extends string> extends IBaseEntity {
+    properties: Record<T, string>;
+}

tests/cases/compiler/indexSignatureAndMappedType.ts

@@ -0,0 +1,35 @@
+// @strict: true
+// @declaration: true
+
+// A mapped type { [P in K]: X }, where K is a generic type, is related to
+// { [key: string]: Y } if X is related to Y.
+
+function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
+    x = y;
+    y = x;  // Error
+}
+
+function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
+    x = y;
+    y = x;
+}
+
+function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
+    x = y;  // Error
+    y = x;  // Error
+}
+
+// Repro from #14548
+
+type Dictionary = {
+    [key: string]: string;
+};
+
+interface IBaseEntity {
+    name: string;
+    properties: Dictionary;
+}
+
+interface IEntity<T extends string> extends IBaseEntity {
+    properties: Record<T, string>;
+}