reuse typeParameter symbol

Author: Andarist

src/compiler/checker.ts

@@ -6653,7 +6653,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
                     if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {
                         const newConstraintParam = createTypeParameter(createSymbol(SymbolFlags.TypeParameter, "T" as __String));
-                        const newTypeParam = createTypeParameter(createSymbol(SymbolFlags.TypeParameter, "K" as __String));
+                        const newTypeParam = createTypeParameter(typeParameter.symbol);
                         const name = typeParameterToName(newConstraintParam, context);
                         const target = type.target as MappedType;
                         typeParameter = newTypeParam;

tests/baselines/reference/declarationEmitMappedTypePreservesTypeParameterConstraint.js

@@ -97,13 +97,13 @@ export declare type ZodRawShape = {
 };
 export declare const buildSchema: <V extends string>(version: V) => addQuestionMarks<baseObjectOutputType<{
     version: ZodLiteral<V>;
-}>, undefined extends V ? never : "version"> extends infer T ? { [K in keyof T]: T[K]; } : never;
+}>, undefined extends V ? never : "version"> extends infer T ? { [k in keyof T]: T[k]; } : never;
 type evaluate<t> = {
     [k in keyof t]: t[k];
 } & unknown;
 export type entryOf<o> = evaluate<{
     [k in keyof o]-?: [k, o[k] & ({} | null)];
 }[o extends readonly unknown[] ? keyof o & number : keyof o]>;
 export type entriesOf<o extends object> = evaluate<entryOf<o>[]>;
-export declare const entriesOf: <o extends object>(o: o) => ({ [k in keyof o]-?: [k, o[k] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [K in keyof T]: T[K]; } : never)[];
+export declare const entriesOf: <o extends object>(o: o) => ({ [k_1 in keyof o]-?: [k_1, o[k_1] & ({} | null)]; }[o extends readonly unknown[] ? keyof o & number : keyof o] extends infer T ? { [k in keyof T]: T[k]; } : never)[];
 export {};