maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
TypeScript/tests/baselines/reference/genericRestParameters2.types
Anders Hejlsberg 9b1718677a
Leading and middle rest elements in tuple types (#41544) 
* Support starting and middle rest elements in tuples

* Accept new baselines

* Include all rest arguments in error span

* Accept new baselines

* Fix tests

* Add new tests

* Fix lint errors
2021-01-04 15:12:51 -10:00

469 lines
12 KiB
Plaintext
Raw Permalink Blame History

=== tests/cases/conformance/types/rest/genericRestParameters2.ts ===
declare const t1: [number, string, ...boolean[]];
>t1 : [number, string, ...boolean[]]
declare const t2: [string, ...boolean[]];
>t2 : [string, ...boolean[]]
declare const t3: [...boolean[]];
>t3 : boolean[]
declare const t4: [];
>t4 : []
declare let f00: (...x: [number, string, boolean]) => void;
>f00 : (x_0: number, x_1: string, x_2: boolean) => void
>x : [number, string, boolean]
declare let f01: (a: number, ...x: [string, boolean]) => void;
>f01 : (a: number, x_0: string, x_1: boolean) => void
>a : number
>x : [string, boolean]
declare let f02: (a: number, b: string, ...x: [boolean]) => void;
>f02 : (a: number, b: string, x_0: boolean) => void
>a : number
>b : string
>x : [boolean]
declare let f03: (a: number, b: string, c: boolean) => void;
>f03 : (a: number, b: string, c: boolean) => void
>a : number
>b : string
>c : boolean
declare let f04: (a: number, b: string, c: boolean, ...x: []) => void;
>f04 : (a: number, b: string, c: boolean) => void
>a : number
>b : string
>c : boolean
>x : []
declare let f10: (...x: [number, string, ...boolean[]]) => void;
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>x : [number, string, ...boolean[]]
declare let f11: (a: number, ...x: [string, ...boolean[]]) => void;
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>a : number
>x : [string, ...boolean[]]
declare let f12: (a: number, b: string, ...x: [...boolean[]]) => void;
>f12 : (a: number, b: string, ...x: [...boolean[]]) => void
>a : number
>b : string
>x : boolean[]
declare let f13: (a: number, b: string, ...c: boolean[]) => void;
>f13 : (a: number, b: string, ...c: boolean[]) => void
>a : number
>b : string
>c : boolean[]
declare const ns: [number, string];
>ns : [number, string]
declare const sn: [string, number];
>sn : [string, number]
f10(42, "hello");
>f10(42, "hello") : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
f10(42, "hello", true);
>f10(42, "hello", true) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
f10(42, "hello", true, false);
>f10(42, "hello", true, false) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>false : false
f10(t1[0], t1[1], t1[2], t1[3]);
>f10(t1[0], t1[1], t1[2], t1[3]) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>t1[0] : number
>t1 : [number, string, ...boolean[]]
>0 : 0
>t1[1] : string
>t1 : [number, string, ...boolean[]]
>1 : 1
>t1[2] : boolean
>t1 : [number, string, ...boolean[]]
>2 : 2
>t1[3] : boolean
>t1 : [number, string, ...boolean[]]
>3 : 3
f10(...t1);
>f10(...t1) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>...t1 : string | number | boolean
>t1 : [number, string, ...boolean[]]
f10(42, ...t2);
>f10(42, ...t2) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
f10(42, "hello", ...t3);
>f10(42, "hello", ...t3) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
>...t3 : boolean
>t3 : boolean[]
f10(42, "hello", true, ...t4);
>f10(42, "hello", true, ...t4) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
f10(42, "hello", true, ...t4, false, ...t3);
>f10(42, "hello", true, ...t4, false, ...t3) : void
>f10 : (x_0: number, x_1: string, ...x_2: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
>false : false
>...t3 : boolean
>t3 : boolean[]
f11(42, "hello");
>f11(42, "hello") : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
f11(42, "hello", true);
>f11(42, "hello", true) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
f11(42, "hello", true, false);
>f11(42, "hello", true, false) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>false : false
f11(t1[0], t1[1], t1[2], t1[3]);
>f11(t1[0], t1[1], t1[2], t1[3]) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>t1[0] : number
>t1 : [number, string, ...boolean[]]
>0 : 0
>t1[1] : string
>t1 : [number, string, ...boolean[]]
>1 : 1
>t1[2] : boolean
>t1 : [number, string, ...boolean[]]
>2 : 2
>t1[3] : boolean
>t1 : [number, string, ...boolean[]]
>3 : 3
f11(...t1);
>f11(...t1) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>...t1 : string | number | boolean
>t1 : [number, string, ...boolean[]]
f11(42, ...t2);
>f11(42, ...t2) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
f11(42, "hello", ...t3);
>f11(42, "hello", ...t3) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
>...t3 : boolean
>t3 : boolean[]
f11(42, "hello", true, ...t4);
>f11(42, "hello", true, ...t4) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
f11(42, "hello", true, ...t4, false, ...t3);
>f11(42, "hello", true, ...t4, false, ...t3) : void
>f11 : (a: number, x_0: string, ...x_1: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
>false : false
>...t3 : boolean
>t3 : boolean[]
f12(42, "hello");
>f12(42, "hello") : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
f12(42, "hello", true);
>f12(42, "hello", true) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
f12(42, "hello", true, false);
>f12(42, "hello", true, false) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>false : false
f12(t1[0], t1[1], t1[2], t1[3]);
>f12(t1[0], t1[1], t1[2], t1[3]) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>t1[0] : number
>t1 : [number, string, ...boolean[]]
>0 : 0
>t1[1] : string
>t1 : [number, string, ...boolean[]]
>1 : 1
>t1[2] : boolean
>t1 : [number, string, ...boolean[]]
>2 : 2
>t1[3] : boolean
>t1 : [number, string, ...boolean[]]
>3 : 3
f12(...t1);
>f12(...t1) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>...t1 : string | number | boolean
>t1 : [number, string, ...boolean[]]
f12(42, ...t2);
>f12(42, ...t2) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
f12(42, "hello", ...t3);
>f12(42, "hello", ...t3) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
>...t3 : boolean
>t3 : boolean[]
f12(42, "hello", true, ...t4);
>f12(42, "hello", true, ...t4) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
f12(42, "hello", true, ...t4, false, ...t3);
>f12(42, "hello", true, ...t4, false, ...t3) : void
>f12 : (a: number, b: string, ...x: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
>false : false
>...t3 : boolean
>t3 : boolean[]
f13(42, "hello");
>f13(42, "hello") : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
f13(42, "hello", true);
>f13(42, "hello", true) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
f13(42, "hello", true, false);
>f13(42, "hello", true, false) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>false : false
f13(t1[0], t1[1], t1[2], t1[3]);
>f13(t1[0], t1[1], t1[2], t1[3]) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>t1[0] : number
>t1 : [number, string, ...boolean[]]
>0 : 0
>t1[1] : string
>t1 : [number, string, ...boolean[]]
>1 : 1
>t1[2] : boolean
>t1 : [number, string, ...boolean[]]
>2 : 2
>t1[3] : boolean
>t1 : [number, string, ...boolean[]]
>3 : 3
f13(...t1);
>f13(...t1) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>...t1 : string | number | boolean
>t1 : [number, string, ...boolean[]]
f13(42, ...t2);
>f13(42, ...t2) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
f13(42, "hello", ...t3);
>f13(42, "hello", ...t3) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
>...t3 : boolean
>t3 : boolean[]
f13(42, "hello", true, ...t4);
>f13(42, "hello", true, ...t4) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
f13(42, "hello", true, ...t4, false, ...t3);
>f13(42, "hello", true, ...t4, false, ...t3) : void
>f13 : (a: number, b: string, ...c: boolean[]) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t4 : never
>t4 : []
>false : false
>...t3 : boolean
>t3 : boolean[]
declare const f20: <T extends unknown[]>(...args: T) => T;
>f20 : <T extends unknown[]>(...args: T) => T
>args : T
f20(...t1);
>f20(...t1) : [number, string, ...boolean[]]
>f20 : <T extends unknown[]>(...args: T) => T
>...t1 : string | number | boolean
>t1 : [number, string, ...boolean[]]
f20(42, ...t2);
>f20(42, ...t2) : [number, string, ...boolean[]]
>f20 : <T extends unknown[]>(...args: T) => T
>42 : 42
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
f20(42, "hello", ...t3);
>f20(42, "hello", ...t3) : [number, string, ...boolean[]]
>f20 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>...t3 : boolean
>t3 : boolean[]
f20(42, "hello", ...t2, true);
>f20(42, "hello", ...t2, true) : [number, string, string, ...boolean[], boolean]
>f20 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
>true : true
type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>;
>T01 : [x: number, y: string, ...z: boolean[]]
>x : number
>y : string
>z : boolean[]
type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>;
>T02 : [number, string, ...boolean[]]
>args : [number, string, ...boolean[]]
type T03 = ConstructorParameters<new (x: number, y: string, ...z: boolean[]) => void>;
>T03 : [x: number, y: string, ...z: boolean[]]
>x : number
>y : string
>z : boolean[]
type T04 = ConstructorParameters<new (...args: [number, string, ...boolean[]]) => void>;
>T04 : [number, string, ...boolean[]]
>args : [number, string, ...boolean[]]
type T05<T extends any[]> = Parameters<(x: string, ...args: T) => void>;
>T05 : [x: string, ...args: T]
>x : string
>args : T
type T06 = T05<[number, ...boolean[]]>;
>T06 : [string, number, ...boolean[]]
type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[];
>P1 : P1<T>
>head : A
>tail : B
>head : A
>tail : B
type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
>T10 : { head: number; tail: [y: string, ...z: boolean[]]; }
>x : number
>y : string
>z : boolean[]
type T11 = P1<(...z: number[]) => void>;
>T11 : { head: number; tail: number[]; }
>z : number[]
type T12 = P1<(x: number, y: number) => void>;
>T12 : { head: number; tail: [y: number]; }
>x : number
>y : number
Reference in a new issue View git blame Copy permalink