Add tests

tests/cases/conformance/types/rest/genericRestParameters2.ts

@@ -0,0 +1,83 @@
+// @strict: true
+// @declaration: true
+
+declare const t1: [number, string, ...boolean[]];
+declare const t2: [string, ...boolean[]];
+declare const t3: [...boolean[]];
+declare const t4: [];
+
+declare let f00: (...x: [number, string, boolean]) => void;
+declare let f01: (a: number, ...x: [string, boolean]) => void;
+declare let f02: (a: number, b: string, ...x: [boolean]) => void;
+declare let f03: (a: number, b: string, c: boolean) => void;
+declare let f04: (a: number, b: string, c: boolean, ...x: []) => void;
+
+declare let f10: (...x: [number, string, ...boolean[]]) => void;
+declare let f11: (a: number, ...x: [string, ...boolean[]]) => void;
+declare let f12: (a: number, b: string, ...x: [...boolean[]]) => void;
+declare let f13: (a: number, b: string, ...c: boolean[]) => void;
+
+declare const ns: [number, string];
+declare const sn: [string, number];
+
+f10(42, "hello");
+f10(42, "hello", true);
+f10(42, "hello", true, false);
+f10(t1[0], t1[1], t1[2], t1[3]);
+f10(...t1);
+f10(42, ...t2);
+f10(42, "hello", ...t3);
+f10(42, "hello", true, ...t4);
+f10(42, "hello", true, ...t4, false, ...t3);
+
+f11(42, "hello");
+f11(42, "hello", true);
+f11(42, "hello", true, false);
+f11(t1[0], t1[1], t1[2], t1[3]);
+f11(...t1);
+f11(42, ...t2);
+f11(42, "hello", ...t3);
+f11(42, "hello", true, ...t4);
+f11(42, "hello", true, ...t4, false, ...t3);
+
+f12(42, "hello");
+f12(42, "hello", true);
+f12(42, "hello", true, false);
+f12(t1[0], t1[1], t1[2], t1[3]);
+f12(...t1);
+f12(42, ...t2);
+f12(42, "hello", ...t3);
+f12(42, "hello", true, ...t4);
+f12(42, "hello", true, ...t4, false, ...t3);
+
+f13(42, "hello");
+f13(42, "hello", true);
+f13(42, "hello", true, false);
+f13(t1[0], t1[1], t1[2], t1[3]);
+f13(...t1);
+f13(42, ...t2);
+f13(42, "hello", ...t3);
+f13(42, "hello", true, ...t4);
+f13(42, "hello", true, ...t4, false, ...t3);
+
+declare const f20: <T extends unknown[]>(...args: T) => T;
+
+f20(...t1);
+f20(42, ...t2);
+f20(42, "hello", ...t3);
+f20(42, "hello", ...t2, true);
+
+type Parameters<T extends Function> = T extends ((...args: infer U) => any) | (new(...args: infer U) => any) ? U : any[];
+
+type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>;
+type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>;
+type T03 = Parameters<new (x: number, y: string, ...z: boolean[]) => void>;
+type T04 = Parameters<new (...args: [number, string, ...boolean[]]) => void>;
+type T05<T extends any[]> = Parameters<(x: string, ...args: T) => void>;
+type T06 = T05<[number, ...boolean[]]>;
+
+type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[];
+
+type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
+type T11 = P1<(...z: number[]) => void>;
+type T12 = P1<(x: number, y: number) => void>;

tests/cases/conformance/types/tuple/optionalTupleElements1.ts

@@ -11,6 +11,8 @@ type L2 = T2["length"];
 type L3 = T3["length"];
 type L4 = T4["length"];
 
+type T5 = [number, string?, boolean];  // Error
+
 function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
     t1 = t1;
     t1 = t2;  // Error
@@ -30,26 +32,9 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
     t4 = t4;
 }
 
-type T5 = [number, string?, boolean];
-type L5 = T5["length"];
-
-function f2(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) {
-    t1 = t5;  // Error
-    t2 = t5;  // Error
-    t3 = t5;
-    t4 = t5;
-    t5 = t5;
-    t5 = t1;
-    t5 = t2;  // Error
-    t5 = t3;  // Error
-    t5 = t4;  // Error
-    t5 = t5;
-}
-
 let t2: T2;
 let t3: T3;
 let t4: T4;
-let t5: T5;
 
 t2 = [42, "hello"];
 t3 = [42, "hello"];
@@ -60,4 +45,3 @@ t4 = [42,,true];
 t4 = [,"hello", true];
 t4 = [,,true];
 t4 = [];
-t5 = [42,,true];

tests/cases/conformance/types/tuple/restTupleElements1.ts

@@ -0,0 +1,71 @@
+// @strict: true
+// @declaration: true
+
+type T00 = [string?];
+type T01 = [string, string?];
+type T02 = [string?, string];  // Error
+type T03 = [...string[]];
+type T04 = [...[...string[]]];
+type T05 = [...[...[...string[]]]];
+type T06 = [string, ...string[]];
+type T07 = [...string[], string];  // Error
+type T08 = [...string];  // Error
+type T09 = [...string?];  // Error
+type T10 = [string, ...[...string[]]];
+type T11 = [string, ...[...[...string[]]]];
+
+type T15 = [boolean, number, ...string[]];
+type L15 = T15["length"];  // number
+
+declare function assign<T, S extends T>(): void;
+
+assign<number[], [...number[]]>();
+assign<number[], [number, ...number[]]>();
+assign<[...number[]], number[]>();
+
+assign<[number, ...number[]], number[]>();  // Error
+assign<[number, ...number[]], []>();  // Error
+assign<[number, ...number[]], [number]>();
+assign<[number, ...number[]], [number, number]>();
+assign<[number, ...number[]], [number, number, ...number[]]>();
+
+assign<[number], [...number[]]>();  // Error
+assign<[number], [number, ...number[]]>();  // Error
+
+assign<[number, ...number[]], [number, ...string[]]>();  // Error
+assign<[number, ...number[]], [string, ...number[]]>();  // Error
+assign<[number, ...number[]], [number, number, string]>();  // Error
+assign<[number, ...number[]], [number, number, number, string]>();  // Error
+
+type T20 = [number, string, ...boolean[]];
+
+type T21 = T20[0];
+type T22 = T20[0 | 1];
+type T23 = T20[0 | 1 | 2];
+type T24 = T20[0 | 1 | 2 | 3];
+type T25 = T20[1 | 2 | 3];
+type T26 = T20[2 | 3];
+type T27 = T20[3];
+type T28 = T20[number];
+
+declare const t: T20;
+declare const x: number;
+
+let e0 = t[0];  // number
+let e1 = t[1];  // string
+let e2 = t[2];  // boolean
+let e3 = t[3];  // boolean
+let ex = t[x];  // number | string | boolean
+
+declare function f0<T, U>(x: [T, ...U[]]): [T, U];
+
+f0([]);  // Error
+f0([1]);
+f0([1, 2, 3]);
+f0([1, "hello", true]);
+
+declare function f1(a: [(x: number) => number, ...((x: string) => number)[]]): void;
+declare function f2(...a: [(x: number) => number, ...((x: string) => number)[]]): void;
+
+f1([x => x * 2, x => x.length, x => x.charCodeAt(0)]);
+f2(x => x * 2, x => x.length, x => x.charCodeAt(0));