From 8ae70d563f2eb34122ebcac425d0b9640d569f22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Thu, 9 Feb 2023 21:01:10 +0100 Subject: [PATCH] Add tests for inferring contextual generic mapped types --- .../reference/genericContextualTypes2.symbols | 123 ++++++++++++++++++ .../reference/genericContextualTypes2.types | 93 +++++++++++++ .../reference/genericContextualTypes3.symbols | 122 +++++++++++++++++ .../reference/genericContextualTypes3.types | 92 +++++++++++++ .../typeInference/genericContextualTypes2.ts | 41 ++++++ .../typeInference/genericContextualTypes3.ts | 41 ++++++ 6 files changed, 512 insertions(+) create mode 100644 tests/baselines/reference/genericContextualTypes2.symbols create mode 100644 tests/baselines/reference/genericContextualTypes2.types create mode 100644 tests/baselines/reference/genericContextualTypes3.symbols create mode 100644 tests/baselines/reference/genericContextualTypes3.types create mode 100644 tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts create mode 100644 tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts diff --git a/tests/baselines/reference/genericContextualTypes2.symbols b/tests/baselines/reference/genericContextualTypes2.symbols new file mode 100644 index 0000000000000..c33272d2cdd40 --- /dev/null +++ b/tests/baselines/reference/genericContextualTypes2.symbols @@ -0,0 +1,123 @@ +=== tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts === +type LowInfer = T & {}; +>LowInfer : Symbol(LowInfer, Decl(genericContextualTypes2.ts, 0, 0)) +>T : Symbol(T, Decl(genericContextualTypes2.ts, 0, 14)) +>T : Symbol(T, Decl(genericContextualTypes2.ts, 0, 14)) + +type PartialAssigner = ( +>PartialAssigner : Symbol(PartialAssigner, Decl(genericContextualTypes2.ts, 0, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 2, 21)) +>TKey : Symbol(TKey, Decl(genericContextualTypes2.ts, 2, 30)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 2, 21)) + + context: TContext +>context : Symbol(context, Decl(genericContextualTypes2.ts, 2, 63)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 2, 21)) + +) => TContext[TKey]; +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 2, 21)) +>TKey : Symbol(TKey, Decl(genericContextualTypes2.ts, 2, 30)) + +type PropertyAssigner = { +>PropertyAssigner : Symbol(PropertyAssigner, Decl(genericContextualTypes2.ts, 4, 20)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 6, 22)) + + [K in keyof TContext]?: PartialAssigner | TContext[K]; +>K : Symbol(K, Decl(genericContextualTypes2.ts, 7, 3)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 6, 22)) +>PartialAssigner : Symbol(PartialAssigner, Decl(genericContextualTypes2.ts, 0, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 6, 22)) +>K : Symbol(K, Decl(genericContextualTypes2.ts, 7, 3)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 6, 22)) +>K : Symbol(K, Decl(genericContextualTypes2.ts, 7, 3)) + +}; + +type Meta = { +>Meta : Symbol(Meta, Decl(genericContextualTypes2.ts, 8, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 10, 10)) + + action: (ctx: TContext) => void +>action : Symbol(action, Decl(genericContextualTypes2.ts, 10, 23)) +>ctx : Symbol(ctx, Decl(genericContextualTypes2.ts, 11, 11)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 10, 10)) +} + +interface AssignAction { +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes2.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 14, 23)) + + type: "xstate.assign"; +>type : Symbol(AssignAction.type, Decl(genericContextualTypes2.ts, 14, 34)) + + exec: (arg: TContext, meta: Meta) => void; +>exec : Symbol(AssignAction.exec, Decl(genericContextualTypes2.ts, 15, 24)) +>arg : Symbol(arg, Decl(genericContextualTypes2.ts, 16, 9)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 14, 23)) +>meta : Symbol(meta, Decl(genericContextualTypes2.ts, 16, 23)) +>Meta : Symbol(Meta, Decl(genericContextualTypes2.ts, 8, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 14, 23)) +} + +declare function assign( +>assign : Symbol(assign, Decl(genericContextualTypes2.ts, 17, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 19, 24)) + + assignment: PropertyAssigner> +>assignment : Symbol(assignment, Decl(genericContextualTypes2.ts, 19, 34)) +>PropertyAssigner : Symbol(PropertyAssigner, Decl(genericContextualTypes2.ts, 4, 20)) +>LowInfer : Symbol(LowInfer, Decl(genericContextualTypes2.ts, 0, 0)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 19, 24)) + +): AssignAction; +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes2.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 19, 24)) + +type Config = { +>Config : Symbol(Config, Decl(genericContextualTypes2.ts, 21, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 23, 12)) + + context: TContext; +>context : Symbol(context, Decl(genericContextualTypes2.ts, 23, 25)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 23, 12)) + + entry?: AssignAction; +>entry : Symbol(entry, Decl(genericContextualTypes2.ts, 24, 20)) +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes2.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 23, 12)) + +}; + +declare function createMachine(config: Config): void; +>createMachine : Symbol(createMachine, Decl(genericContextualTypes2.ts, 26, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 28, 31)) +>config : Symbol(config, Decl(genericContextualTypes2.ts, 28, 41)) +>Config : Symbol(Config, Decl(genericContextualTypes2.ts, 21, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes2.ts, 28, 31)) + +createMachine<{ count: number }>({ +>createMachine : Symbol(createMachine, Decl(genericContextualTypes2.ts, 26, 2)) +>count : Symbol(count, Decl(genericContextualTypes2.ts, 30, 15)) + + context: { +>context : Symbol(context, Decl(genericContextualTypes2.ts, 30, 34)) + + count: 0, +>count : Symbol(count, Decl(genericContextualTypes2.ts, 31, 12)) + + }, + entry: assign({ +>entry : Symbol(entry, Decl(genericContextualTypes2.ts, 33, 4)) +>assign : Symbol(assign, Decl(genericContextualTypes2.ts, 17, 1)) + + count: (ctx: { count: number }) => ++ctx.count, +>count : Symbol(count, Decl(genericContextualTypes2.ts, 34, 17)) +>ctx : Symbol(ctx, Decl(genericContextualTypes2.ts, 35, 12)) +>count : Symbol(count, Decl(genericContextualTypes2.ts, 35, 18)) +>ctx.count : Symbol(count, Decl(genericContextualTypes2.ts, 35, 18)) +>ctx : Symbol(ctx, Decl(genericContextualTypes2.ts, 35, 12)) +>count : Symbol(count, Decl(genericContextualTypes2.ts, 35, 18)) + + }), +}); + diff --git a/tests/baselines/reference/genericContextualTypes2.types b/tests/baselines/reference/genericContextualTypes2.types new file mode 100644 index 0000000000000..7509edec56008 --- /dev/null +++ b/tests/baselines/reference/genericContextualTypes2.types @@ -0,0 +1,93 @@ +=== tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts === +type LowInfer = T & {}; +>LowInfer : LowInfer + +type PartialAssigner = ( +>PartialAssigner : PartialAssigner + + context: TContext +>context : TContext + +) => TContext[TKey]; + +type PropertyAssigner = { +>PropertyAssigner : PropertyAssigner + + [K in keyof TContext]?: PartialAssigner | TContext[K]; +}; + +type Meta = { +>Meta : Meta + + action: (ctx: TContext) => void +>action : (ctx: TContext) => void +>ctx : TContext +} + +interface AssignAction { + type: "xstate.assign"; +>type : "xstate.assign" + + exec: (arg: TContext, meta: Meta) => void; +>exec : (arg: TContext, meta: Meta) => void +>arg : TContext +>meta : Meta +} + +declare function assign( +>assign : (assignment: PropertyAssigner>) => AssignAction + + assignment: PropertyAssigner> +>assignment : PropertyAssigner> + +): AssignAction; + +type Config = { +>Config : Config + + context: TContext; +>context : TContext + + entry?: AssignAction; +>entry : AssignAction | undefined + +}; + +declare function createMachine(config: Config): void; +>createMachine : (config: Config) => void +>config : Config + +createMachine<{ count: number }>({ +>createMachine<{ count: number }>({ context: { count: 0, }, entry: assign({ count: (ctx: { count: number }) => ++ctx.count, }),}) : void +>createMachine : (config: Config) => void +>count : number +>{ context: { count: 0, }, entry: assign({ count: (ctx: { count: number }) => ++ctx.count, }),} : { context: { count: number; }; entry: AssignAction<{ count: number; }>; } + + context: { +>context : { count: number; } +>{ count: 0, } : { count: number; } + + count: 0, +>count : number +>0 : 0 + + }, + entry: assign({ +>entry : AssignAction<{ count: number; }> +>assign({ count: (ctx: { count: number }) => ++ctx.count, }) : AssignAction<{ count: number; }> +>assign : (assignment: PropertyAssigner>) => AssignAction +>{ count: (ctx: { count: number }) => ++ctx.count, } : { count: (ctx: { count: number;}) => number; } + + count: (ctx: { count: number }) => ++ctx.count, +>count : (ctx: { count: number;}) => number +>(ctx: { count: number }) => ++ctx.count : (ctx: { count: number;}) => number +>ctx : { count: number; } +>count : number +>++ctx.count : number +>ctx.count : number +>ctx : { count: number; } +>count : number + + }), +}); + diff --git a/tests/baselines/reference/genericContextualTypes3.symbols b/tests/baselines/reference/genericContextualTypes3.symbols new file mode 100644 index 0000000000000..ec18bb12bddeb --- /dev/null +++ b/tests/baselines/reference/genericContextualTypes3.symbols @@ -0,0 +1,122 @@ +=== tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts === +type LowInfer = T & {}; +>LowInfer : Symbol(LowInfer, Decl(genericContextualTypes3.ts, 0, 0)) +>T : Symbol(T, Decl(genericContextualTypes3.ts, 0, 14)) +>T : Symbol(T, Decl(genericContextualTypes3.ts, 0, 14)) + +type PartialAssigner = ( +>PartialAssigner : Symbol(PartialAssigner, Decl(genericContextualTypes3.ts, 0, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 2, 21)) +>TKey : Symbol(TKey, Decl(genericContextualTypes3.ts, 2, 30)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 2, 21)) + + context: TContext +>context : Symbol(context, Decl(genericContextualTypes3.ts, 2, 63)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 2, 21)) + +) => TContext[TKey]; +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 2, 21)) +>TKey : Symbol(TKey, Decl(genericContextualTypes3.ts, 2, 30)) + +type PropertyAssigner = { +>PropertyAssigner : Symbol(PropertyAssigner, Decl(genericContextualTypes3.ts, 4, 20)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 6, 22)) + + [K in keyof TContext]?: PartialAssigner | TContext[K]; +>K : Symbol(K, Decl(genericContextualTypes3.ts, 7, 3)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 6, 22)) +>PartialAssigner : Symbol(PartialAssigner, Decl(genericContextualTypes3.ts, 0, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 6, 22)) +>K : Symbol(K, Decl(genericContextualTypes3.ts, 7, 3)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 6, 22)) +>K : Symbol(K, Decl(genericContextualTypes3.ts, 7, 3)) + +}; + +type Meta = { +>Meta : Symbol(Meta, Decl(genericContextualTypes3.ts, 8, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 10, 10)) + + action: (ctx: TContext) => void +>action : Symbol(action, Decl(genericContextualTypes3.ts, 10, 23)) +>ctx : Symbol(ctx, Decl(genericContextualTypes3.ts, 11, 11)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 10, 10)) +} + +interface AssignAction { +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes3.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 14, 23)) + + type: "xstate.assign"; +>type : Symbol(AssignAction.type, Decl(genericContextualTypes3.ts, 14, 34)) + + (arg: TContext, meta: Meta): void; +>arg : Symbol(arg, Decl(genericContextualTypes3.ts, 16, 3)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 14, 23)) +>meta : Symbol(meta, Decl(genericContextualTypes3.ts, 16, 17)) +>Meta : Symbol(Meta, Decl(genericContextualTypes3.ts, 8, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 14, 23)) +} + +declare function assign( +>assign : Symbol(assign, Decl(genericContextualTypes3.ts, 17, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 19, 24)) + + assignment: PropertyAssigner> +>assignment : Symbol(assignment, Decl(genericContextualTypes3.ts, 19, 34)) +>PropertyAssigner : Symbol(PropertyAssigner, Decl(genericContextualTypes3.ts, 4, 20)) +>LowInfer : Symbol(LowInfer, Decl(genericContextualTypes3.ts, 0, 0)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 19, 24)) + +): AssignAction; +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes3.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 19, 24)) + +type Config = { +>Config : Symbol(Config, Decl(genericContextualTypes3.ts, 21, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 23, 12)) + + context: TContext; +>context : Symbol(context, Decl(genericContextualTypes3.ts, 23, 25)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 23, 12)) + + entry?: AssignAction; +>entry : Symbol(entry, Decl(genericContextualTypes3.ts, 24, 20)) +>AssignAction : Symbol(AssignAction, Decl(genericContextualTypes3.ts, 12, 1)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 23, 12)) + +}; + +declare function createMachine(config: Config): void; +>createMachine : Symbol(createMachine, Decl(genericContextualTypes3.ts, 26, 2)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 28, 31)) +>config : Symbol(config, Decl(genericContextualTypes3.ts, 28, 41)) +>Config : Symbol(Config, Decl(genericContextualTypes3.ts, 21, 26)) +>TContext : Symbol(TContext, Decl(genericContextualTypes3.ts, 28, 31)) + +createMachine<{ count: number }>({ +>createMachine : Symbol(createMachine, Decl(genericContextualTypes3.ts, 26, 2)) +>count : Symbol(count, Decl(genericContextualTypes3.ts, 30, 15)) + + context: { +>context : Symbol(context, Decl(genericContextualTypes3.ts, 30, 34)) + + count: 0, +>count : Symbol(count, Decl(genericContextualTypes3.ts, 31, 12)) + + }, + entry: assign({ +>entry : Symbol(entry, Decl(genericContextualTypes3.ts, 33, 4)) +>assign : Symbol(assign, Decl(genericContextualTypes3.ts, 17, 1)) + + count: (ctx: { count: number }) => ++ctx.count, +>count : Symbol(count, Decl(genericContextualTypes3.ts, 34, 17)) +>ctx : Symbol(ctx, Decl(genericContextualTypes3.ts, 35, 12)) +>count : Symbol(count, Decl(genericContextualTypes3.ts, 35, 18)) +>ctx.count : Symbol(count, Decl(genericContextualTypes3.ts, 35, 18)) +>ctx : Symbol(ctx, Decl(genericContextualTypes3.ts, 35, 12)) +>count : Symbol(count, Decl(genericContextualTypes3.ts, 35, 18)) + + }), +}); + diff --git a/tests/baselines/reference/genericContextualTypes3.types b/tests/baselines/reference/genericContextualTypes3.types new file mode 100644 index 0000000000000..3be0346c34a25 --- /dev/null +++ b/tests/baselines/reference/genericContextualTypes3.types @@ -0,0 +1,92 @@ +=== tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts === +type LowInfer = T & {}; +>LowInfer : LowInfer + +type PartialAssigner = ( +>PartialAssigner : PartialAssigner + + context: TContext +>context : TContext + +) => TContext[TKey]; + +type PropertyAssigner = { +>PropertyAssigner : PropertyAssigner + + [K in keyof TContext]?: PartialAssigner | TContext[K]; +}; + +type Meta = { +>Meta : Meta + + action: (ctx: TContext) => void +>action : (ctx: TContext) => void +>ctx : TContext +} + +interface AssignAction { + type: "xstate.assign"; +>type : "xstate.assign" + + (arg: TContext, meta: Meta): void; +>arg : TContext +>meta : Meta +} + +declare function assign( +>assign : (assignment: PropertyAssigner>) => AssignAction + + assignment: PropertyAssigner> +>assignment : PropertyAssigner> + +): AssignAction; + +type Config = { +>Config : Config + + context: TContext; +>context : TContext + + entry?: AssignAction; +>entry : AssignAction | undefined + +}; + +declare function createMachine(config: Config): void; +>createMachine : (config: Config) => void +>config : Config + +createMachine<{ count: number }>({ +>createMachine<{ count: number }>({ context: { count: 0, }, entry: assign({ count: (ctx: { count: number }) => ++ctx.count, }),}) : void +>createMachine : (config: Config) => void +>count : number +>{ context: { count: 0, }, entry: assign({ count: (ctx: { count: number }) => ++ctx.count, }),} : { context: { count: number; }; entry: AssignAction<{ count: number; }>; } + + context: { +>context : { count: number; } +>{ count: 0, } : { count: number; } + + count: 0, +>count : number +>0 : 0 + + }, + entry: assign({ +>entry : AssignAction<{ count: number; }> +>assign({ count: (ctx: { count: number }) => ++ctx.count, }) : AssignAction<{ count: number; }> +>assign : (assignment: PropertyAssigner>) => AssignAction +>{ count: (ctx: { count: number }) => ++ctx.count, } : { count: (ctx: { count: number;}) => number; } + + count: (ctx: { count: number }) => ++ctx.count, +>count : (ctx: { count: number;}) => number +>(ctx: { count: number }) => ++ctx.count : (ctx: { count: number;}) => number +>ctx : { count: number; } +>count : number +>++ctx.count : number +>ctx.count : number +>ctx : { count: number; } +>count : number + + }), +}); + diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts new file mode 100644 index 0000000000000..fb47811060ba2 --- /dev/null +++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes2.ts @@ -0,0 +1,41 @@ +// @strict: true +// @noEmit: true + +type LowInfer = T & {}; + +type PartialAssigner = ( + context: TContext +) => TContext[TKey]; + +type PropertyAssigner = { + [K in keyof TContext]?: PartialAssigner | TContext[K]; +}; + +type Meta = { + action: (ctx: TContext) => void +} + +interface AssignAction { + type: "xstate.assign"; + exec: (arg: TContext, meta: Meta) => void; +} + +declare function assign( + assignment: PropertyAssigner> +): AssignAction; + +type Config = { + context: TContext; + entry?: AssignAction; +}; + +declare function createMachine(config: Config): void; + +createMachine<{ count: number }>({ + context: { + count: 0, + }, + entry: assign({ + count: (ctx: { count: number }) => ++ctx.count, + }), +}); diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts new file mode 100644 index 0000000000000..4ad859a219743 --- /dev/null +++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericContextualTypes3.ts @@ -0,0 +1,41 @@ +// @strict: true +// @noEmit: true + +type LowInfer = T & {}; + +type PartialAssigner = ( + context: TContext +) => TContext[TKey]; + +type PropertyAssigner = { + [K in keyof TContext]?: PartialAssigner | TContext[K]; +}; + +type Meta = { + action: (ctx: TContext) => void +} + +interface AssignAction { + type: "xstate.assign"; + (arg: TContext, meta: Meta): void; +} + +declare function assign( + assignment: PropertyAssigner> +): AssignAction; + +type Config = { + context: TContext; + entry?: AssignAction; +}; + +declare function createMachine(config: Config): void; + +createMachine<{ count: number }>({ + context: { + count: 0, + }, + entry: assign({ + count: (ctx: { count: number }) => ++ctx.count, + }), +});