experiment further

src/compiler/checker.ts

@@ -2304,6 +2304,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var deferredGlobalBigIntType: ObjectType | undefined;
     var deferredGlobalNaNSymbol: Symbol | undefined;
     var deferredGlobalRecordSymbol: Symbol | undefined;
+    var deferredGlobalPartialInferenceSymbol: Symbol | undefined;
     var deferredGlobalClassDecoratorContextType: GenericType | undefined;
     var deferredGlobalClassMethodDecoratorContextType: GenericType | undefined;
     var deferredGlobalClassGetterDecoratorContextType: GenericType | undefined;
@@ -17632,6 +17633,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return deferredGlobalRecordSymbol === unknownSymbol ? undefined : deferredGlobalRecordSymbol;
     }
 
+    function getGlobalPartialInferenceSymbol(): Symbol | undefined {
+        deferredGlobalPartialInferenceSymbol ||= getGlobalTypeAliasSymbol("PartialInference" as __String, /*arity*/ 2, /*reportErrors*/ false) || unknownSymbol;
+        return deferredGlobalPartialInferenceSymbol === unknownSymbol ? undefined : deferredGlobalPartialInferenceSymbol;
+    }
+
     /**
      * Instantiates a global type that is generic with some element type, and returns that instantiation.
      */
@@ -26908,11 +26914,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     if (!inference.isFixed) {
                         // Instantiates instance of `type PartialInference<T, Keys extends string> = ({[K in Keys]: {[K1 in K]: T}})[Keys];`
                         // Where `T` is `source` and `Keys` is `target.indexType`
-                        const inferenceTypeSymbol = getGlobalSymbol("PartialInference" as __String, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0);
-                        const inferenceType = inferenceTypeSymbol && getDeclaredTypeOfSymbol(inferenceTypeSymbol);
-                        if (inferenceType && inferenceType !== unknownType) {
-                            const mapper = createTypeMapper(getSymbolLinks(inferenceTypeSymbol).typeParameters!, [source, (target as IndexedAccessType).indexType]);
-                            inference.indexes = append(inference.indexes, instantiateType(inferenceType, mapper));
+                        const partialInferenceTypeSymbol = getGlobalPartialInferenceSymbol();
+                        if (partialInferenceTypeSymbol) {
+                            if ((target as IndexedAccessType).indexType.flags & TypeFlags.Instantiable) {
+                                const recordSymbol = getGlobalRecordSymbol();
+                                if (recordSymbol) {
+                                    inference.indexes = append(inference.indexes, getTypeAliasInstantiation(recordSymbol, [(target as IndexedAccessType).indexType, source]));
+                                }
+                            }
+                            else {
+                                inference.indexes = append(inference.indexes, getTypeAliasInstantiation(partialInferenceTypeSymbol, [source, (target as IndexedAccessType).indexType]));
+                            }
                         }
                     }
                 }
@@ -27590,7 +27602,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     fallbackType = preferCovariantType ? inferredContravariantType : inferredCovariantType;
                 }
                 else if (inference.indexes) {
-                    let aggregateInference = getIntersectionType(inference.indexes);
+                    const eraseSelfMapper = makeUnaryTypeMapper(inference.typeParameter, allKeysUnknownType);
+                    let aggregateInference = instantiateType(getIntersectionType(inference.indexes), mergeTypeMappers(eraseSelfMapper, context.nonFixingMapper));
                     const constraint = getConstraintOfTypeParameter(inference.typeParameter);
                     if (constraint) {
                         const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
@@ -27620,8 +27633,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             }
                         }
                     }
-                    const eraseSelfMapper = makeUnaryTypeMapper(inference.typeParameter, allKeysUnknownType);
-                    inferredType = instantiateType(aggregateInference, mergeTypeMappers(eraseSelfMapper, context.nonFixingMapper));
+                    inferredType = aggregateInference;
                 }
                 else if (context.flags & InferenceFlags.NoDefault) {
                     // We use silentNeverType as the wildcard that signals no inferences.

tests/baselines/reference/completionsCommitCharactersGlobal.baseline

@@ -2692,7 +2692,7 @@
 // | type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void
 // | type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never
 // | type Partial<T> = { [P in keyof T]?: T[P]; }
-// | type PartialInference<T, Keys extends string> = { [K in Keys]: { [K1 in K]: T; }; }[Keys]
+// | type PartialInference<T, Keys extends PropertyKey> = { [K in Keys]: { [K1 in K]: T; }; }[Keys]
 // | type Pick<T, K extends keyof T> = { [P in K]: T[P]; }
 // | interface Promise<T>
 // | type PromiseConstructorLike = new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>
@@ -2873,7 +2873,7 @@
 // | type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void
 // | type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never
 // | type Partial<T> = { [P in keyof T]?: T[P]; }
-// | type PartialInference<T, Keys extends string> = { [K in Keys]: { [K1 in K]: T; }; }[Keys]
+// | type PartialInference<T, Keys extends PropertyKey> = { [K in Keys]: { [K1 in K]: T; }; }[Keys]
 // | type Pick<T, K extends keyof T> = { [P in K]: T[P]; }
 // | interface Promise<T>
 // | type PromiseConstructorLike = new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>
@@ -80663,8 +80663,8 @@
               "kind": "space"
             },
             {
-              "text": "string",
-              "kind": "keyword"
+              "text": "PropertyKey",
+              "kind": "aliasName"
             },
             {
               "text": ">",
@@ -90340,8 +90340,8 @@
               "kind": "space"
             },
             {
-              "text": "string",
-              "kind": "keyword"
+              "text": "PropertyKey",
+              "kind": "aliasName"
             },
             {
               "text": ">",

tests/baselines/reference/inferingFromAny.types

@@ -279,8 +279,8 @@ var a = f18(a);
 
 var a = f19(a, a);
 >a : any
->f19(a, a) : { [x: string]: any; }
->          : ^^^^^^^^^^^^^^^^^^^^^
+>f19(a, a) : Record<any, any>
+>          : ^^^^^^^^^^^^^^^^
 >f19 : <T, K extends keyof T>(k: K, x: T[K]) => T
 >    : ^ ^^ ^^^^^^^^^       ^^ ^^ ^^ ^^    ^^^^^ 
 >a : any

tests/baselines/reference/typeInferenceIndexingUsingOtherTypeParameter1.types

@@ -98,10 +98,10 @@ declare function useController<
 export const { name, values } = useController({
 >name : "test"
 >     : ^^^^^^
->values : { test: string; }
->       : ^^^^^^^^^^^^^^^^^
->useController({  name: "test",  defaultValue: "",}) : { name: "test"; values: { test: string; }; }
->                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : Record<"test", string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^
+>useController({  name: "test",  defaultValue: "",}) : { name: "test"; values: Record<"test", string>; }
+>                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >useController : <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = Path<TFieldValues>>(props: UseControllerProps<TFieldValues, TName>) => { name: TName; values: TFieldValues; }
 >              : ^            ^^^^^^^^^           ^^^^^^^^^^^^^^^^     ^^^^^^^^^                       ^^^^^^^^^^^^^^^^^^^^^^^     ^^                                       ^^^^^                                      
 >{  name: "test",  defaultValue: "",} : { name: "test"; defaultValue: string; }

tests/baselines/reference/typeInferenceSelfIndexingTypeParameter1.errors.txt

@@ -0,0 +1,39 @@
+typeInferenceSelfIndexingTypeParameter1.ts(30,50): error TS2345: Argument of type 'Comparator<Record<"rangeStart", number>>' is not assignable to parameter of type 'Comparator<Record<"sourceOrder", number>>'.
+  Property 'rangeStart' is missing in type 'Record<"sourceOrder", number>' but required in type 'Record<"rangeStart", number>'.
+
+
+==== typeInferenceSelfIndexingTypeParameter1.ts (1 errors) ====
+    type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
+
+    declare const createComparator: <T, K extends keyof T>(
+      property: K,
+      comparator: (a: T[K], b: T[K]) => 0 | 1 | -1,
+    ) => Comparator<T>;
+
+    declare const concatComparators: <T,>(
+      c1: Comparator<T>,
+      c2: Comparator<T>,
+      ...cRest: Comparator<T>[]
+    ) => Comparator<T>;
+
+    declare const compareNumbers: (a: number, b: number) => 0 | 1 | -1;
+
+    declare class ModuleGraphConnection {
+      clone(): ModuleGraphConnection;
+    }
+
+    const bySourceOrder = createComparator("sourceOrder", compareNumbers);
+    const byRangeStart = createComparator("rangeStart", compareNumbers);
+
+    declare const references: {
+      connection: ModuleGraphConnection;
+      sourceOrder: number;
+      rangeStart: number | undefined;
+      defer?: boolean;
+    }[];
+
+    references.sort(concatComparators(bySourceOrder, byRangeStart));
+                                                     ~~~~~~~~~~~~
+!!! error TS2345: Argument of type 'Comparator<Record<"rangeStart", number>>' is not assignable to parameter of type 'Comparator<Record<"sourceOrder", number>>'.
+!!! error TS2345:   Property 'rangeStart' is missing in type 'Record<"sourceOrder", number>' but required in type 'Record<"rangeStart", number>'.
+

tests/baselines/reference/typeInferenceSelfIndexingTypeParameter1.symbols

@@ -9,21 +9,24 @@ type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
 >b : Symbol(b, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 0, 27))
 >T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 0, 16))
 
-declare const createComparator: <T,>(
+declare const createComparator: <T, K extends keyof T>(
 >createComparator : Symbol(createComparator, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 13))
+>T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
+>K : Symbol(K, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 35))
 >T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
 
-  property: string,
->property : Symbol(property, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 37))
+  property: K,
+>property : Symbol(property, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 55))
+>K : Symbol(K, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 35))
 
-  comparator: (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1,
->comparator : Symbol(comparator, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 3, 19))
+  comparator: (a: T[K], b: T[K]) => 0 | 1 | -1,
+>comparator : Symbol(comparator, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 3, 14))
 >a : Symbol(a, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 4, 15))
 >T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
+>K : Symbol(K, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 35))
+>b : Symbol(b, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 4, 23))
 >T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
->b : Symbol(b, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 4, 29))
->T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
->T : Symbol(T, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 33))
+>K : Symbol(K, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 2, 35))
 
 ) => Comparator<T>;
 >Comparator : Symbol(Comparator, Decl(typeInferenceSelfIndexingTypeParameter1.ts, 0, 0))

tests/baselines/reference/typeInferenceSelfIndexingTypeParameter1.types

@@ -13,21 +13,21 @@ type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
 >1 : 1
 >  : ^
 
-declare const createComparator: <T,>(
->createComparator : <T>(property: string, comparator: (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1) => Comparator<T>
->                 : ^ ^^        ^^      ^^          ^^                                            ^^^^^             
-
-  property: string,
->property : string
->         : ^^^^^^
-
-  comparator: (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1,
->comparator : (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1
->           : ^ ^^          ^^ ^^          ^^^^^          
->a : T[keyof T]
->  : ^^^^^^^^^^
->b : T[keyof T]
->  : ^^^^^^^^^^
+declare const createComparator: <T, K extends keyof T>(
+>createComparator : <T, K extends keyof T>(property: K, comparator: (a: T[K], b: T[K]) => 0 | 1 | -1) => Comparator<T>
+>                 : ^ ^^ ^^^^^^^^^       ^^        ^^ ^^          ^^                                ^^^^^             
+
+  property: K,
+>property : K
+>         : ^
+
+  comparator: (a: T[K], b: T[K]) => 0 | 1 | -1,
+>comparator : (a: T[K], b: T[K]) => 0 | 1 | -1
+>           : ^ ^^    ^^ ^^    ^^^^^          
+>a : T[K]
+>  : ^^^^
+>b : T[K]
+>  : ^^^^
 >-1 : -1
 >   : ^^
 >1 : 1
@@ -75,24 +75,24 @@ declare class ModuleGraphConnection {
 }
 
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
->bySourceOrder : Comparator<PartialInference<number, string | number | symbol>>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->createComparator("sourceOrder", compareNumbers) : Comparator<PartialInference<number, string | number | symbol>>
->                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->createComparator : <T>(property: string, comparator: (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1) => Comparator<T>
->                 : ^ ^^        ^^      ^^          ^^                                            ^^^^^             
+>bySourceOrder : Comparator<Record<"sourceOrder", number>>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>createComparator("sourceOrder", compareNumbers) : Comparator<Record<"sourceOrder", number>>
+>                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>createComparator : <T, K extends keyof T>(property: K, comparator: (a: T[K], b: T[K]) => 0 | 1 | -1) => Comparator<T>
+>                 : ^ ^^ ^^^^^^^^^       ^^        ^^ ^^          ^^                                ^^^^^             
 >"sourceOrder" : "sourceOrder"
 >              : ^^^^^^^^^^^^^
 >compareNumbers : (a: number, b: number) => 0 | 1 | -1
 >               : ^ ^^      ^^ ^^      ^^^^^          
 
 const byRangeStart = createComparator("rangeStart", compareNumbers);
->byRangeStart : Comparator<PartialInference<number, string | number | symbol>>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->createComparator("rangeStart", compareNumbers) : Comparator<PartialInference<number, string | number | symbol>>
->                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->createComparator : <T>(property: string, comparator: (a: T[keyof T], b: T[keyof T]) => 0 | 1 | -1) => Comparator<T>
->                 : ^ ^^        ^^      ^^          ^^                                            ^^^^^             
+>byRangeStart : Comparator<Record<"rangeStart", number>>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>createComparator("rangeStart", compareNumbers) : Comparator<Record<"rangeStart", number>>
+>                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>createComparator : <T, K extends keyof T>(property: K, comparator: (a: T[K], b: T[K]) => 0 | 1 | -1) => Comparator<T>
+>                 : ^ ^^ ^^^^^^^^^       ^^        ^^ ^^          ^^                                ^^^^^             
 >"rangeStart" : "rangeStart"
 >             : ^^^^^^^^^^^^
 >compareNumbers : (a: number, b: number) => 0 | 1 | -1
@@ -129,12 +129,12 @@ references.sort(concatComparators(bySourceOrder, byRangeStart));
 >           : ^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^                  ^^^^^^^^^^       ^^^^^
 >sort : (compareFn?: ((a: { connection: ModuleGraphConnection; sourceOrder: number; rangeStart: number | undefined; defer?: boolean; }, b: { connection: ModuleGraphConnection; sourceOrder: number; rangeStart: number | undefined; defer?: boolean; }) => number) | undefined) => { connection: ModuleGraphConnection; sourceOrder: number; rangeStart: number | undefined; defer?: boolean; }[]
 >     : ^         ^^^^^ ^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^                  ^^^^^^^^^^       ^^^^^ ^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^                  ^^^^^^^^^^       ^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^                  ^^^^^^^^^^       ^^^^^
->concatComparators(bySourceOrder, byRangeStart) : Comparator<PartialInference<number, string | number | symbol>>
->                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>concatComparators(bySourceOrder, byRangeStart) : Comparator<Record<"sourceOrder", number>>
+>                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >concatComparators : <T>(c1: Comparator<T>, c2: Comparator<T>, ...cRest: Comparator<T>[]) => Comparator<T>
 >                  : ^ ^^  ^^             ^^  ^^             ^^^^^     ^^               ^^^^^             
->bySourceOrder : Comparator<PartialInference<number, string | number | symbol>>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->byRangeStart : Comparator<PartialInference<number, string | number | symbol>>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>bySourceOrder : Comparator<Record<"sourceOrder", number>>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>byRangeStart : Comparator<Record<"rangeStart", number>>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^