Make T assignable to Readonly<U> if T is assignable to U, not just if

T = U.

Fixes #27484.

Author: mattmccutchen

src/compiler/checker.ts

@@ -11904,9 +11904,11 @@ namespace ts {
                     const template = getTemplateTypeFromMappedType(target);
                     const modifiers = getMappedTypeModifiers(target);
                     if (!(modifiers & MappedTypeModifiers.ExcludeOptional)) {
-                        if (template.flags & TypeFlags.IndexedAccess && (<IndexedAccessType>template).objectType === source &&
+                        if (template.flags & TypeFlags.IndexedAccess &&
                             (<IndexedAccessType>template).indexType === getTypeParameterFromMappedType(target)) {
-                            return Ternary.True;
+                            if (result = isRelatedTo(source, (<IndexedAccessType>template).objectType)) {
+                                return result;
+                            }
                         }
                         // A source type T is related to a target type { [P in keyof T]: X } if T[P] is related to X.
                         if (!isGenericMappedType(source) && getConstraintTypeFromMappedType(target) === getIndexType(source)) {

tests/baselines/reference/genericMappedTypeIntersections.errors.txt

@@ -0,0 +1,11 @@
+tests/cases/compiler/genericMappedTypeIntersections.ts(3,52): error TS2339: Property 'assign' does not exist on type 'ObjectConstructor'.
+
+
+==== tests/cases/compiler/genericMappedTypeIntersections.ts (1 errors) ====
+    // Repro for #27484
+    function foo<P>(props: Readonly<{children?: string}> & Readonly<P>) {
+        let x: Readonly<P & { name: string }> = Object.assign({}, props, {name: "Matt"});
+                                                       ~~~~~~
+!!! error TS2339: Property 'assign' does not exist on type 'ObjectConstructor'.
+    }
+    

tests/baselines/reference/genericMappedTypeIntersections.js

@@ -0,0 +1,12 @@
+//// [genericMappedTypeIntersections.ts]
+// Repro for #27484
+function foo<P>(props: Readonly<{children?: string}> & Readonly<P>) {
+    let x: Readonly<P & { name: string }> = Object.assign({}, props, {name: "Matt"});
+}
+
+
+//// [genericMappedTypeIntersections.js]
+// Repro for #27484
+function foo(props) {
+    var x = Object.assign({}, props, { name: "Matt" });
+}

tests/baselines/reference/genericMappedTypeIntersections.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/genericMappedTypeIntersections.ts ===
+// Repro for #27484
+function foo<P>(props: Readonly<{children?: string}> & Readonly<P>) {
+>foo : Symbol(foo, Decl(genericMappedTypeIntersections.ts, 0, 0))
+>P : Symbol(P, Decl(genericMappedTypeIntersections.ts, 1, 13))
+>props : Symbol(props, Decl(genericMappedTypeIntersections.ts, 1, 16))
+>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
+>children : Symbol(children, Decl(genericMappedTypeIntersections.ts, 1, 33))
+>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
+>P : Symbol(P, Decl(genericMappedTypeIntersections.ts, 1, 13))
+
+    let x: Readonly<P & { name: string }> = Object.assign({}, props, {name: "Matt"});
+>x : Symbol(x, Decl(genericMappedTypeIntersections.ts, 2, 7))
+>Readonly : Symbol(Readonly, Decl(lib.es5.d.ts, --, --))
+>P : Symbol(P, Decl(genericMappedTypeIntersections.ts, 1, 13))
+>name : Symbol(name, Decl(genericMappedTypeIntersections.ts, 2, 25))
+>Object : Symbol(Object, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>props : Symbol(props, Decl(genericMappedTypeIntersections.ts, 1, 16))
+>name : Symbol(name, Decl(genericMappedTypeIntersections.ts, 2, 70))
+}
+

tests/baselines/reference/genericMappedTypeIntersections.types

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/genericMappedTypeIntersections.ts ===
+// Repro for #27484
+function foo<P>(props: Readonly<{children?: string}> & Readonly<P>) {
+>foo : <P>(props: Readonly<{ children?: string; }> & Readonly<P>) => void
+>props : Readonly<{ children?: string; }> & Readonly<P>
+>children : string
+
+    let x: Readonly<P & { name: string }> = Object.assign({}, props, {name: "Matt"});
+>x : Readonly<P & { name: string; }>
+>name : string
+>Object.assign({}, props, {name: "Matt"}) : any
+>Object.assign : any
+>Object : ObjectConstructor
+>assign : any
+>{} : {}
+>props : Readonly<{ children?: string; }> & Readonly<P>
+>{name: "Matt"} : { name: string; }
+>name : string
+>"Matt" : "Matt"
+}
+

tests/cases/compiler/genericMappedTypeIntersections.ts

@@ -0,0 +1,4 @@
+// Repro for #27484
+function foo<P>(props: Readonly<{children?: string}> & Readonly<P>) {
+    let x: Readonly<P & { name: string }> = Object.assign({}, props, {name: "Matt"});
+}