TypeScript/tests/baselines/reference/genericFunctionParametersConditionalType1.types at 80ad2530a42f43b3a35d5944f2c1742d8ac5f67a · microsoft/TypeScript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
//// [tests/cases/compiler/genericFunctionParametersConditionalType1.ts] ////

=== genericFunctionParametersConditionalType1.ts ===
// https://github.com/microsoft/TypeScript/issues/62079

export {};

interface _Map {
  foo: { a: 123 }
>foo : { a: 123; }
>    : ^^^^^   ^^^
>a : 123
>  : ^^^
}

type ModuleSubType = "bar" & { brand: true };
>ModuleSubType : ModuleSubType
>              : ^^^^^^^^^^^^^
>brand : true
>      : ^^^^
>true : true
>     : ^^^^

type Map = _Map & Record<ModuleSubType, { blah: string }>
>Map : Map
>    : ^^^
>blah : string
>     : ^^^^^^

type SubTypeGet<
>SubTypeGet : SubTypeGet<SubType, Map>
>           : ^^^^^^^^^^^^^^^^^^^^^^^^

  SubType extends string,
  Map extends Record<SubType, unknown>,
> = SubType extends unknown
? { type?: SubType } & Map[SubType]
>type : SubType | undefined
>     : ^^^^^^^^^^^^^^^^^^^

: never;

type TestParameters = Parameters<<T extends "foo" | ModuleSubType>(arg: SubTypeGet<T, Map>) => void>
>TestParameters : [arg: { type?: ModuleSubType | undefined; } | ({ type?: "foo" | undefined; } & { a: 123; })]
>               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^
>arg : SubTypeGet<T, Map>
>    : ^^^^^^^^^^^^^^^^^^

declare class Test<T extends "foo" | ModuleSubType> {
>Test : Test<T>
>     : ^^^^^^^

  constructor(arg: SubTypeGet<T, Map>);
>arg : SubTypeGet<T, Map>
>    : ^^^^^^^^^^^^^^^^^^
}

type TestConstructorParameters = ConstructorParameters<typeof Test>;
>TestConstructorParameters : [arg: { type?: ModuleSubType | undefined; } | ({ type?: "foo" | undefined; } & { a: 123; })]
>                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^
>Test : typeof Test
>     : ^^^^^^^^^^^

declare class Animal { eat(): void; }
>Animal : Animal
>       : ^^^^^^
>eat : () => void
>    : ^^^^^^

declare class Cat extends Animal { meow(): void; }
>Cat : Cat
>    : ^^^
>Animal : Animal
>       : ^^^^^^
>meow : () => void
>     : ^^^^^^

declare class Dog extends Animal { bark(): void; }
>Dog : Dog
>    : ^^^
>Animal : Animal
>       : ^^^^^^
>bark : () => void
>     : ^^^^^^

type WithDistributiveConditionalDirectlyInParam = <T extends Cat | Dog>(
>WithDistributiveConditionalDirectlyInParam : WithDistributiveConditionalDirectlyInParam
>                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  arg: T extends unknown ? T : never,
>arg : T extends unknown ? T : never
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

) => void;

type Result1 = Parameters<WithDistributiveConditionalDirectlyInParam>;
>Result1 : [arg: Cat | Dog]
>        : ^^^^^^^^^^^^^^^^

type WithDistributiveConditionalNested = <T extends Cat | Dog>(
>WithDistributiveConditionalNested : WithDistributiveConditionalNested
>                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  arg: T extends unknown ? { animal: T } : never,
>arg : T extends unknown ? { animal: T; } : never
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^
>animal : T
>       : ^

) => void;

type Result2 = Parameters<WithDistributiveConditionalNested>;
>Result2 : [arg: { animal: Cat; } | { animal: Dog; }]
>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

type WithNonDistributiveConditionalNested = <T extends Cat | Dog>(
>WithNonDistributiveConditionalNested : WithNonDistributiveConditionalNested
>                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  arg: [T] extends [unknown] ? { animal: T } : never,
>arg : [T] extends [unknown] ? { animal: T; } : never
>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^
>animal : T
>       : ^

) => void;

type Result3 = Parameters<WithNonDistributiveConditionalNested>;
>Result3 : [arg: { animal: Cat | Dog; }]
>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^