Revert nameType intantiation

Author: Andarist

src/compiler/checker.ts

@@ -17637,7 +17637,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
      * reduction in the constraintType) when possible.
      * @param noIndexSignatures Indicates if _string_ index signatures should be elided. (other index signatures are always reported)
      */
-    function getIndexTypeForMappedType(type: MappedType, indexFlags: IndexFlags): Type {
+    function getIndexTypeForMappedType(type: MappedType, indexFlags: IndexFlags) {
         const typeParameter = getTypeParameterFromMappedType(type);
         const constraintType = getConstraintTypeFromMappedType(type);
         const nameType = getNameTypeFromMappedType(type.target as MappedType || type);
@@ -17651,12 +17651,6 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // a circular definition. For this reason, we only eagerly manifest the keys if the constraint is non-generic.
         if (isGenericIndexType(constraintType)) {
             if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
-                if (nameType) {
-                    const modifiersIndex = getIndexType(getModifiersTypeFromMappedType(type), indexFlags, UnionReduction.None);
-                    const mapper = makeUnaryTypeMapper(getTypeParameterFromMappedType(type), modifiersIndex);
-                    const nameMapper = combineTypeMappers(type.mapper, mapper);
-                    return instantiateType(nameType, nameMapper);
-                }
                 // We have a generic index and a homomorphic mapping (but a distributive key remapping) - we need to defer
                 // the whole `keyof whatever` for later since it's not safe to resolve the shape of modifier type.
                 return getIndexTypeForGenericType(type, indexFlags);
@@ -17745,13 +17739,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return !!(keyType.flags & include || keyType.flags & TypeFlags.Intersection && some((keyType as IntersectionType).types, t => isKeyTypeIncluded(t, include)));
     }
 
-    function getLiteralTypeFromProperties(type: Type, include: TypeFlags, includeOrigin: boolean, unionReduction = UnionReduction.Literal) {
+    function getLiteralTypeFromProperties(type: Type, include: TypeFlags, includeOrigin: boolean) {
         const origin = includeOrigin && (getObjectFlags(type) & (ObjectFlags.ClassOrInterface | ObjectFlags.Reference) || type.aliasSymbol) ? createOriginIndexType(type) : undefined;
         const propertyTypes = map(getPropertiesOfType(type), prop => getLiteralTypeFromProperty(prop, include));
         const indexKeyTypes = map(getIndexInfosOfType(type), info =>
             info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ?
                 info.keyType === stringType && include & TypeFlags.Number ? stringOrNumberType : info.keyType : neverType);
-        return getUnionType(concatenate(propertyTypes, indexKeyTypes), unionReduction, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
+        return getUnionType(concatenate(propertyTypes, indexKeyTypes), UnionReduction.Literal, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
     }
 
     function shouldDeferIndexType(type: Type, indexFlags = IndexFlags.None) {
@@ -17762,16 +17756,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             type.flags & TypeFlags.Intersection && maybeTypeOfKind(type, TypeFlags.Instantiable) && some((type as IntersectionType).types, isEmptyAnonymousObjectType));
     }
 
-    function getIndexType(type: Type, indexFlags = defaultIndexFlags, unionReduction?: UnionReduction): Type {
+    function getIndexType(type: Type, indexFlags = defaultIndexFlags): Type {
         type = getReducedType(type);
         return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type as InstantiableType | UnionOrIntersectionType, indexFlags) :
             type.flags & TypeFlags.Union ? getIntersectionType(map((type as UnionType).types, t => getIndexType(t, indexFlags))) :
-            type.flags & TypeFlags.Intersection ? getUnionType(map((type as IntersectionType).types, t => getIndexType(t, indexFlags, unionReduction)), unionReduction) :
+            type.flags & TypeFlags.Intersection ? getUnionType(map((type as IntersectionType).types, t => getIndexType(t, indexFlags))) :
             getObjectFlags(type) & ObjectFlags.Mapped ? getIndexTypeForMappedType(type as MappedType, indexFlags) :
             type === wildcardType ? wildcardType :
             type.flags & TypeFlags.Unknown ? neverType :
             type.flags & (TypeFlags.Any | TypeFlags.Never) ? keyofConstraintType :
-            getLiteralTypeFromProperties(type, (indexFlags & IndexFlags.NoIndexSignatures ? TypeFlags.StringLiteral : TypeFlags.StringLike) | (indexFlags & IndexFlags.StringsOnly ? 0 : TypeFlags.NumberLike | TypeFlags.ESSymbolLike), indexFlags === defaultIndexFlags, unionReduction);
+            getLiteralTypeFromProperties(type, (indexFlags & IndexFlags.NoIndexSignatures ? TypeFlags.StringLiteral : TypeFlags.StringLike) | (indexFlags & IndexFlags.StringsOnly ? 0 : TypeFlags.NumberLike | TypeFlags.ESSymbolLike), indexFlags === defaultIndexFlags);
     }
 
     function getExtractStringType(type: Type) {

tests/baselines/reference/keyRemappingKeyofResult.types

@@ -156,19 +156,19 @@ function g<T>() {
     // no string index signature, right?
 
     type Oops = keyof Remapped;
->Oops : unique symbol | "str" | (keyof T extends infer T_1 ? T_1 extends keyof T ? T_1 extends unknown ? {} extends Record<T_1, any> ? never : T_1 : never : never : never)
+>Oops : keyof { [K in keyof ({ [k: string]: any; str: any; [sym]: any; } & T) as K extends unknown ? {} extends Record<K, any> ? never : K : never]: any; }
 
     let x: Oops;
->x : unique symbol | "str" | (keyof T extends infer T_1 ? T_1 extends keyof T ? T_1 extends unknown ? {} extends Record<T_1, any> ? never : T_1 : never : never : never)
+>x : keyof { [K in keyof ({ [k: string]: any; str: any; [sym]: any; } & T) as K extends unknown ? {} extends Record<K, any> ? never : K : never]: any; }
 
     x = sym;
 >x = sym : unique symbol
->x : unique symbol | "str" | (keyof T extends infer T_1 ? T_1 extends keyof T ? T_1 extends unknown ? {} extends Record<T_1, any> ? never : T_1 : never : never : never)
+>x : keyof { [K in keyof ({ [k: string]: any; str: any; [sym]: any; } & T) as K extends unknown ? {} extends Record<K, any> ? never : K : never]: any; }
 >sym : unique symbol
 
     x = "str";
 >x = "str" : "str"
->x : unique symbol | "str" | (keyof T extends infer T_1 ? T_1 extends keyof T ? T_1 extends unknown ? {} extends Record<T_1, any> ? never : T_1 : never : never : never)
+>x : keyof { [K in keyof ({ [k: string]: any; str: any; [sym]: any; } & T) as K extends unknown ? {} extends Record<K, any> ? never : K : never]: any; }
 >"str" : "str"
 }
 

tests/baselines/reference/keyRemappingKeyofResult2.errors.txt

@@ -0,0 +1,51 @@
+keyRemappingKeyofResult2.ts(23,7): error TS2344: Type 'Values<{ [K in keyof TActors as K & string]: { src: K; logic: TActors[K]; }; }>' does not satisfy the constraint 'ProvidedActor'.
+  Types of property 'src' are incompatible.
+    Type 'keyof { [K in keyof TActors as K & string]: { src: K; logic: TActors[K]; }; }' is not assignable to type 'string'.
+      Type 'string | number | symbol' is not assignable to type 'string'.
+        Type 'number' is not assignable to type 'string'.
+
+
+==== keyRemappingKeyofResult2.ts (1 errors) ====
+    // https://github.com/microsoft/TypeScript/issues/56239
+    
+    type Values<T> = T[keyof T];
+    
+    type ProvidedActor = {
+      src: string;
+      logic: unknown;
+    };
+    
+    interface StateMachineConfig<TActors extends ProvidedActor> {
+      invoke: {
+        src: TActors["src"];
+      };
+    }
+    
+    declare function setup<TActors extends Record<string, unknown>>(_: {
+      actors: {
+        [K in keyof TActors]: TActors[K];
+      };
+    }): {
+      createMachine: (
+        config: StateMachineConfig<
+          Values<{
+          ~~~~~~~~
+            [K in keyof TActors as K & string]: {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+              src: K;
+    ~~~~~~~~~~~~~~~~~
+              logic: TActors[K];
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            };
+    ~~~~~~~~~~
+          }>
+    ~~~~~~~~
+!!! error TS2344: Type 'Values<{ [K in keyof TActors as K & string]: { src: K; logic: TActors[K]; }; }>' does not satisfy the constraint 'ProvidedActor'.
+!!! error TS2344:   Types of property 'src' are incompatible.
+!!! error TS2344:     Type 'keyof { [K in keyof TActors as K & string]: { src: K; logic: TActors[K]; }; }' is not assignable to type 'string'.
+!!! error TS2344:       Type 'string | number | symbol' is not assignable to type 'string'.
+!!! error TS2344:         Type 'number' is not assignable to type 'string'.
+        >,
+      ) => void;
+    };
+    

tests/baselines/reference/mappedTypeAsClauses.types

@@ -267,16 +267,16 @@ type NameMap = { 'a': 'x', 'b': 'y', 'c': 'z' };
 // Distributive, will be simplified
 
 type TS0<T> = keyof { [P in keyof T as keyof Record<P, number>]: string };
->TS0 : keyof T
+>TS0 : keyof { [P in keyof T as P]: string; }
 
 type TS1<T> = keyof { [P in keyof T as Extract<P, 'a' | 'b' | 'c'>]: string };
->TS1 : Extract<keyof T, "a" | "b" | "c">
+>TS1 : keyof { [P in keyof T as Extract<P, "a" | "b" | "c">]: string; }
 
 type TS2<T> = keyof { [P in keyof T as P & ('a' | 'b' | 'c')]: string };
->TS2 : keyof T & ("a" | "b" | "c")
+>TS2 : keyof { [P in keyof T as P & ("a" | "b" | "c")]: string; }
 
 type TS3<T> = keyof { [P in keyof T as Exclude<P, 'a' | 'b' | 'c'>]: string };
->TS3 : Exclude<keyof T, "a" | "b" | "c">
+>TS3 : keyof { [P in keyof T as Exclude<P, "a" | "b" | "c">]: string; }
 
 type TS4<T> = keyof { [P in keyof T as NameMap[P & keyof NameMap]]: string };
 >TS4 : keyof { [P in keyof T as NameMap[P & keyof NameMap]]: string; }
@@ -285,7 +285,7 @@ type TS5<T> = keyof { [P in keyof T & keyof NameMap as NameMap[P]]: string };
 >TS5 : keyof { [P in keyof T & keyof NameMap as NameMap[P]]: string; }
 
 type TS6<T, U, V> = keyof { [ K in keyof T as V & (K extends U ? K : never)]: string };
->TS6 : V & (keyof T extends infer T_1 ? T_1 extends keyof T ? T_1 extends U ? T_1 : never : never : never)
+>TS6 : keyof { [K in keyof T as V & (K extends U ? K : never)]: string; }
 
 // Non-distributive, won't be simplified