Skip to content

Commit 1488f35

Browse files
ahejlsbergahejlsberg
committed
Accept new baselines
1 parent 096d0ae commit 1488f35

7 files changed

+2227
-0
lines changed

‎tests/baselines/reference/mappedTypeAsClauses.js

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
//// [mappedTypeAsClauses.ts]
2+
// Mapped type 'as N' clauses
3+
4+
type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
5+
type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>;
6+
7+
// Mapped type with 'as N' clause has no constraint on 'in T' clause
8+
9+
type PropDef<K extends keyof any, T> = { name: K, type: T };
10+
11+
type TypeFromDefs<T extends PropDef<keyof any, any>> = { [P in T as P['name']]: P['type'] };
12+
13+
type TP1 = TypeFromDefs<{ name: 'a', type: string } | { name: 'b', type: number } | { name: 'a', type: boolean }>;
14+
15+
// No array or tuple type mapping when 'as N' clause present
16+
17+
type TA1 = Getters<string[]>;
18+
type TA2 = Getters<[number, boolean]>;
19+
20+
// Filtering using 'as N' clause
21+
22+
type Methods<T> = { [P in keyof T as T[P] extends Function ? P : never]: T[P] };
23+
type TM1 = Methods<{ foo(): number, bar(x: string): boolean, baz: string | number }>;
24+
25+
// Mapping to multiple names using 'as N' clause
26+
27+
type DoubleProp<T> = { [P in keyof T & string as `${P}1` | `${P}2`]: T[P] }
28+
type TD1 = DoubleProp<{ a: string, b: number }>; // { a1: string, a2: string, b1: number, b2: number }
29+
type TD2 = keyof TD1; // 'a1' | 'a2' | 'b1' | 'b2'
30+
type TD3<U> = keyof DoubleProp<U>; // `${keyof U & string}1` | `${keyof U & string}2`
31+
32+
33+
//// [mappedTypeAsClauses.js]
34+
"use strict";
35+
// Mapped type 'as N' clauses
36+
37+
38+
//// [mappedTypeAsClauses.d.ts]
39+
declare type Getters<T> = {
40+
[P in keyof T & string as `get${capitalize P}`]: () => T[P];
41+
};
42+
declare type TG1 = Getters<{
43+
foo: string;
44+
bar: number;
45+
baz: {
46+
z: boolean;
47+
};
48+
}>;
49+
declare type PropDef<K extends keyof any, T> = {
50+
name: K;
51+
type: T;
52+
};
53+
declare type TypeFromDefs<T extends PropDef<keyof any, any>> = {
54+
[P in T as P['name']]: P['type'];
55+
};
56+
declare type TP1 = TypeFromDefs<{
57+
name: 'a';
58+
type: string;
59+
} | {
60+
name: 'b';
61+
type: number;
62+
} | {
63+
name: 'a';
64+
type: boolean;
65+
}>;
66+
declare type TA1 = Getters<string[]>;
67+
declare type TA2 = Getters<[number, boolean]>;
68+
declare type Methods<T> = {
69+
[P in keyof T as T[P] extends Function ? P : never]: T[P];
70+
};
71+
declare type TM1 = Methods<{
72+
foo(): number;
73+
bar(x: string): boolean;
74+
baz: string | number;
75+
}>;
76+
declare type DoubleProp<T> = {
77+
[P in keyof T & string as `${P}1` | `${P}2`]: T[P];
78+
};
79+
declare type TD1 = DoubleProp<{
80+
a: string;
81+
b: number;
82+
}>;
83+
declare type TD2 = keyof TD1;
84+
declare type TD3<U> = keyof DoubleProp<U>;

‎tests/baselines/reference/mappedTypeAsClauses.symbols

Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
=== tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts ===
2+
// Mapped type 'as N' clauses
3+
4+
type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
5+
>Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0))
6+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13))
7+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21))
8+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13))
9+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21))
10+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 2, 13))
11+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 2, 21))
12+
13+
type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>;
14+
>TG1 : Symbol(TG1, Decl(mappedTypeAsClauses.ts, 2, 82))
15+
>Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0))
16+
>foo : Symbol(foo, Decl(mappedTypeAsClauses.ts, 3, 20))
17+
>bar : Symbol(bar, Decl(mappedTypeAsClauses.ts, 3, 33))
18+
>baz : Symbol(baz, Decl(mappedTypeAsClauses.ts, 3, 46))
19+
>z : Symbol(z, Decl(mappedTypeAsClauses.ts, 3, 53))
20+
21+
// Mapped type with 'as N' clause has no constraint on 'in T' clause
22+
23+
type PropDef<K extends keyof any, T> = { name: K, type: T };
24+
>PropDef : Symbol(PropDef, Decl(mappedTypeAsClauses.ts, 3, 70))
25+
>K : Symbol(K, Decl(mappedTypeAsClauses.ts, 7, 13))
26+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 7, 33))
27+
>name : Symbol(name, Decl(mappedTypeAsClauses.ts, 7, 40))
28+
>K : Symbol(K, Decl(mappedTypeAsClauses.ts, 7, 13))
29+
>type : Symbol(type, Decl(mappedTypeAsClauses.ts, 7, 49))
30+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 7, 33))
31+
32+
type TypeFromDefs<T extends PropDef<keyof any, any>> = { [P in T as P['name']]: P['type'] };
33+
>TypeFromDefs : Symbol(TypeFromDefs, Decl(mappedTypeAsClauses.ts, 7, 60))
34+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 9, 18))
35+
>PropDef : Symbol(PropDef, Decl(mappedTypeAsClauses.ts, 3, 70))
36+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 9, 58))
37+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 9, 18))
38+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 9, 58))
39+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 9, 58))
40+
41+
type TP1 = TypeFromDefs<{ name: 'a', type: string } | { name: 'b', type: number } | { name: 'a', type: boolean }>;
42+
>TP1 : Symbol(TP1, Decl(mappedTypeAsClauses.ts, 9, 92))
43+
>TypeFromDefs : Symbol(TypeFromDefs, Decl(mappedTypeAsClauses.ts, 7, 60))
44+
>name : Symbol(name, Decl(mappedTypeAsClauses.ts, 11, 25))
45+
>type : Symbol(type, Decl(mappedTypeAsClauses.ts, 11, 36))
46+
>name : Symbol(name, Decl(mappedTypeAsClauses.ts, 11, 55))
47+
>type : Symbol(type, Decl(mappedTypeAsClauses.ts, 11, 66))
48+
>name : Symbol(name, Decl(mappedTypeAsClauses.ts, 11, 85))
49+
>type : Symbol(type, Decl(mappedTypeAsClauses.ts, 11, 96))
50+
51+
// No array or tuple type mapping when 'as N' clause present
52+
53+
type TA1 = Getters<string[]>;
54+
>TA1 : Symbol(TA1, Decl(mappedTypeAsClauses.ts, 11, 114))
55+
>Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0))
56+
57+
type TA2 = Getters<[number, boolean]>;
58+
>TA2 : Symbol(TA2, Decl(mappedTypeAsClauses.ts, 15, 29))
59+
>Getters : Symbol(Getters, Decl(mappedTypeAsClauses.ts, 0, 0))
60+
61+
// Filtering using 'as N' clause
62+
63+
type Methods<T> = { [P in keyof T as T[P] extends Function ? P : never]: T[P] };
64+
>Methods : Symbol(Methods, Decl(mappedTypeAsClauses.ts, 16, 38))
65+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 20, 13))
66+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 20, 21))
67+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 20, 13))
68+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 20, 13))
69+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 20, 21))
70+
>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
71+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 20, 21))
72+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 20, 13))
73+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 20, 21))
74+
75+
type TM1 = Methods<{ foo(): number, bar(x: string): boolean, baz: string | number }>;
76+
>TM1 : Symbol(TM1, Decl(mappedTypeAsClauses.ts, 20, 80))
77+
>Methods : Symbol(Methods, Decl(mappedTypeAsClauses.ts, 16, 38))
78+
>foo : Symbol(foo, Decl(mappedTypeAsClauses.ts, 21, 20))
79+
>bar : Symbol(bar, Decl(mappedTypeAsClauses.ts, 21, 35))
80+
>x : Symbol(x, Decl(mappedTypeAsClauses.ts, 21, 40))
81+
>baz : Symbol(baz, Decl(mappedTypeAsClauses.ts, 21, 60))
82+
83+
// Mapping to multiple names using 'as N' clause
84+
85+
type DoubleProp<T> = { [P in keyof T & string as `${P}1` | `${P}2`]: T[P] }
86+
>DoubleProp : Symbol(DoubleProp, Decl(mappedTypeAsClauses.ts, 21, 85))
87+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 25, 16))
88+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 25, 24))
89+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 25, 16))
90+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 25, 24))
91+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 25, 24))
92+
>T : Symbol(T, Decl(mappedTypeAsClauses.ts, 25, 16))
93+
>P : Symbol(P, Decl(mappedTypeAsClauses.ts, 25, 24))
94+
95+
type TD1 = DoubleProp<{ a: string, b: number }>; // { a1: string, a2: string, b1: number, b2: number }
96+
>TD1 : Symbol(TD1, Decl(mappedTypeAsClauses.ts, 25, 75))
97+
>DoubleProp : Symbol(DoubleProp, Decl(mappedTypeAsClauses.ts, 21, 85))
98+
>a : Symbol(a, Decl(mappedTypeAsClauses.ts, 26, 23))
99+
>b : Symbol(b, Decl(mappedTypeAsClauses.ts, 26, 34))
100+
101+
type TD2 = keyof TD1; // 'a1' | 'a2' | 'b1' | 'b2'
102+
>TD2 : Symbol(TD2, Decl(mappedTypeAsClauses.ts, 26, 48))
103+
>TD1 : Symbol(TD1, Decl(mappedTypeAsClauses.ts, 25, 75))
104+
105+
type TD3<U> = keyof DoubleProp<U>; // `${keyof U & string}1` | `${keyof U & string}2`
106+
>TD3 : Symbol(TD3, Decl(mappedTypeAsClauses.ts, 27, 21))
107+
>U : Symbol(U, Decl(mappedTypeAsClauses.ts, 28, 9))
108+
>DoubleProp : Symbol(DoubleProp, Decl(mappedTypeAsClauses.ts, 21, 85))
109+
>U : Symbol(U, Decl(mappedTypeAsClauses.ts, 28, 9))
110+

‎tests/baselines/reference/mappedTypeAsClauses.types

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
=== tests/cases/conformance/types/mapped/mappedTypeAsClauses.ts ===
2+
// Mapped type 'as N' clauses
3+
4+
type Getters<T> = { [P in keyof T & string as `get${capitalize P}`]: () => T[P] };
5+
>Getters : Getters<T>
6+
7+
type TG1 = Getters<{ foo: string, bar: number, baz: { z: boolean } }>;
8+
>TG1 : Getters<{ foo: string; bar: number; baz: { z: boolean;}; }>
9+
>foo : string
10+
>bar : number
11+
>baz : { z: boolean; }
12+
>z : boolean
13+
14+
// Mapped type with 'as N' clause has no constraint on 'in T' clause
15+
16+
type PropDef<K extends keyof any, T> = { name: K, type: T };
17+
>PropDef : PropDef<K, T>
18+
>name : K
19+
>type : T
20+
21+
type TypeFromDefs<T extends PropDef<keyof any, any>> = { [P in T as P['name']]: P['type'] };
22+
>TypeFromDefs : TypeFromDefs<T>
23+
24+
type TP1 = TypeFromDefs<{ name: 'a', type: string } | { name: 'b', type: number } | { name: 'a', type: boolean }>;
25+
>TP1 : TypeFromDefs<{ name: 'a'; type: string; } | { name: 'b'; type: number; } | { name: 'a'; type: boolean; }>
26+
>name : "a"
27+
>type : string
28+
>name : "b"
29+
>type : number
30+
>name : "a"
31+
>type : boolean
32+
33+
// No array or tuple type mapping when 'as N' clause present
34+
35+
type TA1 = Getters<string[]>;
36+
>TA1 : Getters<string[]>
37+
38+
type TA2 = Getters<[number, boolean]>;
39+
>TA2 : Getters<[number, boolean]>
40+
41+
// Filtering using 'as N' clause
42+
43+
type Methods<T> = { [P in keyof T as T[P] extends Function ? P : never]: T[P] };
44+
>Methods : Methods<T>
45+
46+
type TM1 = Methods<{ foo(): number, bar(x: string): boolean, baz: string | number }>;
47+
>TM1 : Methods<{ foo(): number; bar(x: string): boolean; baz: string | number; }>
48+
>foo : () => number
49+
>bar : (x: string) => boolean
50+
>x : string
51+
>baz : string | number
52+
53+
// Mapping to multiple names using 'as N' clause
54+
55+
type DoubleProp<T> = { [P in keyof T & string as `${P}1` | `${P}2`]: T[P] }
56+
>DoubleProp : DoubleProp<T>
57+
58+
type TD1 = DoubleProp<{ a: string, b: number }>; // { a1: string, a2: string, b1: number, b2: number }
59+
>TD1 : DoubleProp<{ a: string; b: number; }>
60+
>a : string
61+
>b : number
62+
63+
type TD2 = keyof TD1; // 'a1' | 'a2' | 'b1' | 'b2'
64+
>TD2 : "a1" | "b1" | "a2" | "b2"
65+
66+
type TD3<U> = keyof DoubleProp<U>; // `${keyof U & string}1` | `${keyof U & string}2`
67+
>TD3 : `${keyof U & string}1` | `${keyof U & string}2`
68+

0 commit comments

Comments
 (0)