Skip to content

Commit 03a3847

Browse files
ahejlsbergahejlsberg
committed
Accept new baselines
1 parent 34505c1 commit 03a3847

4 files changed

Lines changed: 868 additions & 0 deletions

File tree

‎tests/baselines/reference/inferTypes1.errors.txt‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
tests/cases/conformance/types/conditional/inferTypes1.ts(34,23): error TS2344: Type 'string' does not satisfy the constraint 'Function'.
2+
tests/cases/conformance/types/conditional/inferTypes1.ts(43,25): error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'.
3+
tests/cases/conformance/types/conditional/inferTypes1.ts(44,25): error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'.
4+
Type 'Function' provides no match for the signature '(x: any): any'.
5+
6+
7+
==== tests/cases/conformance/types/conditional/inferTypes1.ts (3 errors) ====
8+
type Unpacked<T> =
9+
T extends (infer U)[] ? U :
10+
T extends (...args: any[]) => infer U ? U :
11+
T extends Promise<infer U> ? U :
12+
T;
13+
14+
type T00 = Unpacked<string>; // string
15+
type T01 = Unpacked<string[]>; // string
16+
type T02 = Unpacked<() => string>; // string
17+
type T03 = Unpacked<Promise<string>>; // string
18+
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
19+
type T05 = Unpacked<any>; // any
20+
type T06 = Unpacked<never>; // never
21+
22+
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
23+
24+
function f1(s: string) {
25+
return { a: 1, b: s };
26+
}
27+
28+
class C {
29+
x = 0;
30+
y = 0;
31+
}
32+
33+
type T10 = ReturnType<() => string>; // string
34+
type T11 = ReturnType<(s: string) => void>; // void
35+
type T12 = ReturnType<(<T>() => T)>; // {}
36+
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
37+
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
38+
type T15 = ReturnType<typeof C>; // C
39+
type T16 = ReturnType<any>; // any
40+
type T17 = ReturnType<never>; // any
41+
type T18 = ReturnType<string>; // Error
42+
~~~~~~
43+
!!! error TS2344: Type 'string' does not satisfy the constraint 'Function'.
44+
type T19 = ReturnType<Function>; // any
45+
46+
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
47+
48+
type T20 = ArgumentType<() => void>; // never
49+
type T21 = ArgumentType<(x: string) => number>; // string
50+
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
51+
type T23 = ArgumentType<(...args: string[]) => number>; // string
52+
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
53+
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
54+
!!! error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'.
55+
type T25 = ArgumentType<Function>; // Error
56+
~~~~~~~~
57+
!!! error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'.
58+
!!! error TS2344: Type 'Function' provides no match for the signature '(x: any): any'.
59+
type T26 = ArgumentType<any>; // any
60+
type T27 = ArgumentType<never>; // any
61+
62+
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
63+
64+
type T30 = X1<{ x: any, y: any }>; // [any, any]
65+
type T31 = X1<{ x: number, y: string }>; // [number, string]
66+
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
67+
68+
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
69+
70+
type T40 = X2<{}>; // never
71+
type T41 = X2<{ a: string }>; // never
72+
type T42 = X2<{ a: string, b: string }>; // string
73+
type T43 = X2<{ a: number, b: string }>; // string | number
74+
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
75+
76+
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
77+
78+
type T50 = X3<{}>; // never
79+
type T51 = X3<{ a: (x: string) => void }>; // never
80+
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
81+
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
82+
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
83+

‎tests/baselines/reference/inferTypes1.js‎

Lines changed: 183 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,183 @@
1+
//// [inferTypes1.ts]
2+
type Unpacked<T> =
3+
T extends (infer U)[] ? U :
4+
T extends (...args: any[]) => infer U ? U :
5+
T extends Promise<infer U> ? U :
6+
T;
7+
8+
type T00 = Unpacked<string>; // string
9+
type T01 = Unpacked<string[]>; // string
10+
type T02 = Unpacked<() => string>; // string
11+
type T03 = Unpacked<Promise<string>>; // string
12+
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
13+
type T05 = Unpacked<any>; // any
14+
type T06 = Unpacked<never>; // never
15+
16+
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
17+
18+
function f1(s: string) {
19+
return { a: 1, b: s };
20+
}
21+
22+
class C {
23+
x = 0;
24+
y = 0;
25+
}
26+
27+
type T10 = ReturnType<() => string>; // string
28+
type T11 = ReturnType<(s: string) => void>; // void
29+
type T12 = ReturnType<(<T>() => T)>; // {}
30+
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
31+
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
32+
type T15 = ReturnType<typeof C>; // C
33+
type T16 = ReturnType<any>; // any
34+
type T17 = ReturnType<never>; // any
35+
type T18 = ReturnType<string>; // Error
36+
type T19 = ReturnType<Function>; // any
37+
38+
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
39+
40+
type T20 = ArgumentType<() => void>; // never
41+
type T21 = ArgumentType<(x: string) => number>; // string
42+
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
43+
type T23 = ArgumentType<(...args: string[]) => number>; // string
44+
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
45+
type T25 = ArgumentType<Function>; // Error
46+
type T26 = ArgumentType<any>; // any
47+
type T27 = ArgumentType<never>; // any
48+
49+
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
50+
51+
type T30 = X1<{ x: any, y: any }>; // [any, any]
52+
type T31 = X1<{ x: number, y: string }>; // [number, string]
53+
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
54+
55+
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
56+
57+
type T40 = X2<{}>; // never
58+
type T41 = X2<{ a: string }>; // never
59+
type T42 = X2<{ a: string, b: string }>; // string
60+
type T43 = X2<{ a: number, b: string }>; // string | number
61+
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
62+
63+
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
64+
65+
type T50 = X3<{}>; // never
66+
type T51 = X3<{ a: (x: string) => void }>; // never
67+
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
68+
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
69+
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
70+
71+
72+
//// [inferTypes1.js]
73+
"use strict";
74+
function f1(s) {
75+
return { a: 1, b: s };
76+
}
77+
var C = /** @class */ (function () {
78+
function C() {
79+
this.x = 0;
80+
this.y = 0;
81+
}
82+
return C;
83+
}());
84+
85+
86+
//// [inferTypes1.d.ts]
87+
declare type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
88+
declare type T00 = Unpacked<string>;
89+
declare type T01 = Unpacked<string[]>;
90+
declare type T02 = Unpacked<() => string>;
91+
declare type T03 = Unpacked<Promise<string>>;
92+
declare type T04 = Unpacked<Unpacked<Promise<string>[]>>;
93+
declare type T05 = Unpacked<any>;
94+
declare type T06 = Unpacked<never>;
95+
declare type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
96+
declare function f1(s: string): {
97+
a: number;
98+
b: string;
99+
};
100+
declare class C {
101+
x: number;
102+
y: number;
103+
}
104+
declare type T10 = ReturnType<() => string>;
105+
declare type T11 = ReturnType<(s: string) => void>;
106+
declare type T12 = ReturnType<(<T>() => T)>;
107+
declare type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;
108+
declare type T14 = ReturnType<typeof f1>;
109+
declare type T15 = ReturnType<typeof C>;
110+
declare type T16 = ReturnType<any>;
111+
declare type T17 = ReturnType<never>;
112+
declare type T18 = ReturnType<string>;
113+
declare type T19 = ReturnType<Function>;
114+
declare type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
115+
declare type T20 = ArgumentType<() => void>;
116+
declare type T21 = ArgumentType<(x: string) => number>;
117+
declare type T22 = ArgumentType<(x?: string) => number>;
118+
declare type T23 = ArgumentType<(...args: string[]) => number>;
119+
declare type T24 = ArgumentType<(x: string, y: string) => number>;
120+
declare type T25 = ArgumentType<Function>;
121+
declare type T26 = ArgumentType<any>;
122+
declare type T27 = ArgumentType<never>;
123+
declare type X1<T extends {
124+
x: any;
125+
y: any;
126+
}> = T extends {
127+
x: infer X;
128+
y: infer Y;
129+
} ? [X, Y] : any;
130+
declare type T30 = X1<{
131+
x: any;
132+
y: any;
133+
}>;
134+
declare type T31 = X1<{
135+
x: number;
136+
y: string;
137+
}>;
138+
declare type T32 = X1<{
139+
x: number;
140+
y: string;
141+
z: boolean;
142+
}>;
143+
declare type X2<T> = T extends {
144+
a: infer U;
145+
b: infer U;
146+
} ? U : never;
147+
declare type T40 = X2<{}>;
148+
declare type T41 = X2<{
149+
a: string;
150+
}>;
151+
declare type T42 = X2<{
152+
a: string;
153+
b: string;
154+
}>;
155+
declare type T43 = X2<{
156+
a: number;
157+
b: string;
158+
}>;
159+
declare type T44 = X2<{
160+
a: number;
161+
b: string;
162+
c: boolean;
163+
}>;
164+
declare type X3<T> = T extends {
165+
a: (x: infer U) => void;
166+
b: (x: infer U) => void;
167+
} ? U : never;
168+
declare type T50 = X3<{}>;
169+
declare type T51 = X3<{
170+
a: (x: string) => void;
171+
}>;
172+
declare type T52 = X3<{
173+
a: (x: string) => void;
174+
b: (x: string) => void;
175+
}>;
176+
declare type T53 = X3<{
177+
a: (x: number) => void;
178+
b: (x: string) => void;
179+
}>;
180+
declare type T54 = X3<{
181+
a: (x: number) => void;
182+
b: () => void;
183+
}>;

0 commit comments

Comments
 (0)