Avoid rewriting homomorphic mapped types with homomorphic instantiations (#53215)

Author: Andarist

src/compiler/checker.ts

@@ -6633,9 +6633,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 return typeToTypeNodeHelper(type, context);
             }
 
+            function isMappedTypeHomomorphic(type: MappedType) {
+                return !!getHomomorphicTypeVariable(type);
+            }
+
             function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type: MappedType) {
-                return isMappedTypeWithKeyofConstraintDeclaration(type)
-                    && !(getModifiersTypeFromMappedType(type).flags & TypeFlags.TypeParameter);
+                return !!type.target && isMappedTypeHomomorphic(type.target as MappedType) && !isMappedTypeHomomorphic(type);
             }
 
             function createMappedTypeNodeFromType(type: MappedType) {

tests/baselines/reference/mappedTypeGenericInstantiationPreservesInlineForm.js

@@ -0,0 +1,19 @@
+//// [mappedTypeGenericInstantiationPreservesInlineForm.ts]
+// repro from #53109
+
+export const test1 = <T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}) => {}
+
+export function test2<T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}) {};
+
+
+
+
+//// [mappedTypeGenericInstantiationPreservesInlineForm.d.ts]
+export declare const test1: <T = Record<string, never>>(schema: { [K in keyof Required<T>]: T[K]; }) => void;
+export declare function test2<T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}): void;

tests/baselines/reference/mappedTypeGenericInstantiationPreservesInlineForm.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/mappedTypeGenericInstantiationPreservesInlineForm.ts ===
+// repro from #53109
+
+export const test1 = <T = Record<string, never>>(schema: {
+>test1 : Symbol(test1, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 2, 12))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 2, 22))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>schema : Symbol(schema, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 2, 49))
+
+    [K in keyof Required<T>]: T[K];
+>K : Symbol(K, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 3, 5))
+>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 2, 22))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 2, 22))
+>K : Symbol(K, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 3, 5))
+
+}) => {}
+
+export function test2<T = Record<string, never>>(schema: {
+>test2 : Symbol(test2, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 4, 8))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 6, 22))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>schema : Symbol(schema, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 6, 49))
+
+    [K in keyof Required<T>]: T[K];
+>K : Symbol(K, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 7, 5))
+>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 6, 22))
+>T : Symbol(T, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 6, 22))
+>K : Symbol(K, Decl(mappedTypeGenericInstantiationPreservesInlineForm.ts, 7, 5))
+
+}) {};
+

tests/baselines/reference/mappedTypeGenericInstantiationPreservesInlineForm.types

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/mappedTypeGenericInstantiationPreservesInlineForm.ts ===
+// repro from #53109
+
+export const test1 = <T = Record<string, never>>(schema: {
+>test1 : <T = Record<string, never>>(schema: { [K in keyof Required<T>]: T[K]; }) => void
+><T = Record<string, never>>(schema: {    [K in keyof Required<T>]: T[K];}) => {} : <T = Record<string, never>>(schema: { [K in keyof Required<T>]: T[K]; }) => void
+>schema : { [K in keyof Required<T>]: T[K]; }
+
+    [K in keyof Required<T>]: T[K];
+}) => {}
+
+export function test2<T = Record<string, never>>(schema: {
+>test2 : <T = Record<string, never>>(schema: { [K in keyof Required<T>]: T[K]; }) => void
+>schema : { [K in keyof Required<T>]: T[K]; }
+
+    [K in keyof Required<T>]: T[K];
+}) {};
+

tests/baselines/reference/mappedTypeUnionConstraintInferences.js

@@ -38,7 +38,7 @@ export declare type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 export declare type PartialProperties<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 export declare function doSomething_Actual<T extends {
     prop: string;
-}>(a: T): PartialProperties<T, "prop"> extends infer T_1 ? { [P in keyof T_1]: PartialProperties<T, "prop">[P]; } : never;
+}>(a: T): { [P in keyof PartialProperties<T, "prop">]: PartialProperties<T, "prop">[P]; };
 export declare function doSomething_Expected<T extends {
     prop: string;
 }>(a: T): {

tests/cases/compiler/mappedTypeGenericInstantiationPreservesInlineForm.ts

@@ -0,0 +1,13 @@
+// @strict: true
+// @declaration: true
+// @emitDeclarationOnly: true
+
+// repro from #53109
+
+export const test1 = <T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}) => {}
+
+export function test2<T = Record<string, never>>(schema: {
+    [K in keyof Required<T>]: T[K];
+}) {};