microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-15 12:51:30 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Accept new baselines

Browse Source
This commit is contained in:
Anders Hejlsberg
2018-06-25 10:45:48 -10:00
parent d869e56d33
commit 5ef7e9ff34
11 changed files with 1814 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
tests/baselines/reference/genericRestParameters2.js Normal file
View File

@@ -0,0 +1,158 @@
//// [genericRestParameters2.ts]
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>;
//// [genericRestParameters2.js]
"use strict";
f10(42, "hello");
f10(42, "hello", true);
f10(42, "hello", true, false);
f10(t1[0], t1[1], t1[2], t1[3]);
f10.apply(void 0, t1);
f10.apply(void 0, [42].concat(t2));
f10.apply(void 0, [42, "hello"].concat(t3));
f10.apply(void 0, [42, "hello", true].concat(t4));
f10.apply(void 0, [42, "hello", true].concat(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.apply(void 0, t1);
f11.apply(void 0, [42].concat(t2));
f11.apply(void 0, [42, "hello"].concat(t3));
f11.apply(void 0, [42, "hello", true].concat(t4));
f11.apply(void 0, [42, "hello", true].concat(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.apply(void 0, t1);
f12.apply(void 0, [42].concat(t2));
f12.apply(void 0, [42, "hello"].concat(t3));
f12.apply(void 0, [42, "hello", true].concat(t4));
f12.apply(void 0, [42, "hello", true].concat(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.apply(void 0, t1);
f13.apply(void 0, [42].concat(t2));
f13.apply(void 0, [42, "hello"].concat(t3));
f13.apply(void 0, [42, "hello", true].concat(t4));
f13.apply(void 0, [42, "hello", true].concat(t4, [false], t3));
f20.apply(void 0, t1);
f20.apply(void 0, [42].concat(t2));
f20.apply(void 0, [42, "hello"].concat(t3));
f20.apply(void 0, [42, "hello"].concat(t2, [true]));
//// [genericRestParameters2.d.ts]
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];
declare const f20: <T extends unknown[]>(...args: T) => T;
declare type Parameters<T extends Function> = T extends ((...args: infer U) => any) | (new (...args: infer U) => any) ? U : any[];
declare type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>;
declare type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>;
declare type T03 = Parameters<new (x: number, y: string, ...z: boolean[]) => void>;
declare type T04 = Parameters<new (...args: [number, string, ...boolean[]]) => void>;
declare type T05<T extends any[]> = Parameters<(x: string, ...args: T) => void>;
declare type T06 = T05<[number, ...boolean[]]>;
declare type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? {
head: A;
tail: B;
} : any[];
declare type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
declare type T11 = P1<(...z: number[]) => void>;
declare type T12 = P1<(x: number, y: number) => void>;

326
tests/baselines/reference/genericRestParameters2.symbols Normal file
View File

@@ -0,0 +1,326 @@
=== tests/cases/conformance/types/rest/genericRestParameters2.ts ===
declare const t1: [number, string, ...boolean[]];
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
declare const t2: [string, ...boolean[]];
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
declare const t3: [...boolean[]];
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
declare const t4: [];
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
declare let f00: (...x: [number, string, boolean]) => void;
>f00 : Symbol(f00, Decl(genericRestParameters2.ts, 5, 11))
>x : Symbol(x, Decl(genericRestParameters2.ts, 5, 18))
declare let f01: (a: number, ...x: [string, boolean]) => void;
>f01 : Symbol(f01, Decl(genericRestParameters2.ts, 6, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 6, 18))
>x : Symbol(x, Decl(genericRestParameters2.ts, 6, 28))
declare let f02: (a: number, b: string, ...x: [boolean]) => void;
>f02 : Symbol(f02, Decl(genericRestParameters2.ts, 7, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 7, 18))
>b : Symbol(b, Decl(genericRestParameters2.ts, 7, 28))
>x : Symbol(x, Decl(genericRestParameters2.ts, 7, 39))
declare let f03: (a: number, b: string, c: boolean) => void;
>f03 : Symbol(f03, Decl(genericRestParameters2.ts, 8, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 8, 18))
>b : Symbol(b, Decl(genericRestParameters2.ts, 8, 28))
>c : Symbol(c, Decl(genericRestParameters2.ts, 8, 39))
declare let f04: (a: number, b: string, c: boolean, ...x: []) => void;
>f04 : Symbol(f04, Decl(genericRestParameters2.ts, 9, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 9, 18))
>b : Symbol(b, Decl(genericRestParameters2.ts, 9, 28))
>c : Symbol(c, Decl(genericRestParameters2.ts, 9, 39))
>x : Symbol(x, Decl(genericRestParameters2.ts, 9, 51))
declare let f10: (...x: [number, string, ...boolean[]]) => void;
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>x : Symbol(x, Decl(genericRestParameters2.ts, 11, 18))
declare let f11: (a: number, ...x: [string, ...boolean[]]) => void;
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 12, 18))
>x : Symbol(x, Decl(genericRestParameters2.ts, 12, 28))
declare let f12: (a: number, b: string, ...x: [...boolean[]]) => void;
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 13, 18))
>b : Symbol(b, Decl(genericRestParameters2.ts, 13, 28))
>x : Symbol(x, Decl(genericRestParameters2.ts, 13, 39))
declare let f13: (a: number, b: string, ...c: boolean[]) => void;
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>a : Symbol(a, Decl(genericRestParameters2.ts, 14, 18))
>b : Symbol(b, Decl(genericRestParameters2.ts, 14, 28))
>c : Symbol(c, Decl(genericRestParameters2.ts, 14, 39))
declare const ns: [number, string];
>ns : Symbol(ns, Decl(genericRestParameters2.ts, 16, 13))
declare const sn: [string, number];
>sn : Symbol(sn, Decl(genericRestParameters2.ts, 17, 13))
f10(42, "hello");
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
f10(42, "hello", true);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
f10(42, "hello", true, false);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
f10(t1[0], t1[1], t1[2], t1[3]);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>0 : Symbol(0)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>1 : Symbol(1)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f10(...t1);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f10(42, ...t2);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
f10(42, "hello", ...t3);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f10(42, "hello", true, ...t4);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
f10(42, "hello", true, ...t4, false, ...t3);
>f10 : Symbol(f10, Decl(genericRestParameters2.ts, 11, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f11(42, "hello");
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
f11(42, "hello", true);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
f11(42, "hello", true, false);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
f11(t1[0], t1[1], t1[2], t1[3]);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>0 : Symbol(0)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>1 : Symbol(1)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f11(...t1);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f11(42, ...t2);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
f11(42, "hello", ...t3);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f11(42, "hello", true, ...t4);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
f11(42, "hello", true, ...t4, false, ...t3);
>f11 : Symbol(f11, Decl(genericRestParameters2.ts, 12, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f12(42, "hello");
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
f12(42, "hello", true);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
f12(42, "hello", true, false);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
f12(t1[0], t1[1], t1[2], t1[3]);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>0 : Symbol(0)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>1 : Symbol(1)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f12(...t1);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f12(42, ...t2);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
f12(42, "hello", ...t3);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f12(42, "hello", true, ...t4);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
f12(42, "hello", true, ...t4, false, ...t3);
>f12 : Symbol(f12, Decl(genericRestParameters2.ts, 13, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f13(42, "hello");
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
f13(42, "hello", true);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
f13(42, "hello", true, false);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
f13(t1[0], t1[1], t1[2], t1[3]);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>0 : Symbol(0)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>1 : Symbol(1)
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f13(...t1);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f13(42, ...t2);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
f13(42, "hello", ...t3);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f13(42, "hello", true, ...t4);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
f13(42, "hello", true, ...t4, false, ...t3);
>f13 : Symbol(f13, Decl(genericRestParameters2.ts, 14, 11))
>t4 : Symbol(t4, Decl(genericRestParameters2.ts, 3, 13))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
declare const f20: <T extends unknown[]>(...args: T) => T;
>f20 : Symbol(f20, Decl(genericRestParameters2.ts, 59, 13))
>T : Symbol(T, Decl(genericRestParameters2.ts, 59, 20))
>args : Symbol(args, Decl(genericRestParameters2.ts, 59, 41))
>T : Symbol(T, Decl(genericRestParameters2.ts, 59, 20))
>T : Symbol(T, Decl(genericRestParameters2.ts, 59, 20))
f20(...t1);
>f20 : Symbol(f20, Decl(genericRestParameters2.ts, 59, 13))
>t1 : Symbol(t1, Decl(genericRestParameters2.ts, 0, 13))
f20(42, ...t2);
>f20 : Symbol(f20, Decl(genericRestParameters2.ts, 59, 13))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
f20(42, "hello", ...t3);
>f20 : Symbol(f20, Decl(genericRestParameters2.ts, 59, 13))
>t3 : Symbol(t3, Decl(genericRestParameters2.ts, 2, 13))
f20(42, "hello", ...t2, true);
>f20 : Symbol(f20, Decl(genericRestParameters2.ts, 59, 13))
>t2 : Symbol(t2, Decl(genericRestParameters2.ts, 1, 13))
type Parameters<T extends Function> = T extends ((...args: infer U) => any) | (new(...args: infer U) => any) ? U : any[];
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>T : Symbol(T, Decl(genericRestParameters2.ts, 66, 16))
>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(genericRestParameters2.ts, 66, 16))
>args : Symbol(args, Decl(genericRestParameters2.ts, 66, 50))
>U : Symbol(U, Decl(genericRestParameters2.ts, 66, 64), Decl(genericRestParameters2.ts, 66, 97))
>args : Symbol(args, Decl(genericRestParameters2.ts, 66, 83))
>U : Symbol(U, Decl(genericRestParameters2.ts, 66, 64), Decl(genericRestParameters2.ts, 66, 97))
>U : Symbol(U, Decl(genericRestParameters2.ts, 66, 64), Decl(genericRestParameters2.ts, 66, 97))
type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>;
>T01 : Symbol(T01, Decl(genericRestParameters2.ts, 66, 121))
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>x : Symbol(x, Decl(genericRestParameters2.ts, 68, 23))
>y : Symbol(y, Decl(genericRestParameters2.ts, 68, 33))
>z : Symbol(z, Decl(genericRestParameters2.ts, 68, 44))
type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>;
>T02 : Symbol(T02, Decl(genericRestParameters2.ts, 68, 71))
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>args : Symbol(args, Decl(genericRestParameters2.ts, 69, 23))
type T03 = Parameters<new (x: number, y: string, ...z: boolean[]) => void>;
>T03 : Symbol(T03, Decl(genericRestParameters2.ts, 69, 73))
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>x : Symbol(x, Decl(genericRestParameters2.ts, 70, 27))
>y : Symbol(y, Decl(genericRestParameters2.ts, 70, 37))
>z : Symbol(z, Decl(genericRestParameters2.ts, 70, 48))
type T04 = Parameters<new (...args: [number, string, ...boolean[]]) => void>;
>T04 : Symbol(T04, Decl(genericRestParameters2.ts, 70, 75))
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>args : Symbol(args, Decl(genericRestParameters2.ts, 71, 27))
type T05<T extends any[]> = Parameters<(x: string, ...args: T) => void>;
>T05 : Symbol(T05, Decl(genericRestParameters2.ts, 71, 77))
>T : Symbol(T, Decl(genericRestParameters2.ts, 72, 9))
>Parameters : Symbol(Parameters, Decl(genericRestParameters2.ts, 64, 30))
>x : Symbol(x, Decl(genericRestParameters2.ts, 72, 40))
>args : Symbol(args, Decl(genericRestParameters2.ts, 72, 50))
>T : Symbol(T, Decl(genericRestParameters2.ts, 72, 9))
type T06 = T05<[number, ...boolean[]]>;
>T06 : Symbol(T06, Decl(genericRestParameters2.ts, 72, 72))
>T05 : Symbol(T05, Decl(genericRestParameters2.ts, 71, 77))
type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[];
>P1 : Symbol(P1, Decl(genericRestParameters2.ts, 73, 39))
>T : Symbol(T, Decl(genericRestParameters2.ts, 75, 8))
>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(genericRestParameters2.ts, 75, 8))
>head : Symbol(head, Decl(genericRestParameters2.ts, 75, 41))
>A : Symbol(A, Decl(genericRestParameters2.ts, 75, 52))
>tail : Symbol(tail, Decl(genericRestParameters2.ts, 75, 55))
>B : Symbol(B, Decl(genericRestParameters2.ts, 75, 70))
>head : Symbol(head, Decl(genericRestParameters2.ts, 75, 84))
>A : Symbol(A, Decl(genericRestParameters2.ts, 75, 52))
>tail : Symbol(tail, Decl(genericRestParameters2.ts, 75, 93))
>B : Symbol(B, Decl(genericRestParameters2.ts, 75, 70))
type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
>T10 : Symbol(T10, Decl(genericRestParameters2.ts, 75, 112))
>P1 : Symbol(P1, Decl(genericRestParameters2.ts, 73, 39))
>x : Symbol(x, Decl(genericRestParameters2.ts, 77, 15))
>y : Symbol(y, Decl(genericRestParameters2.ts, 77, 25))
>z : Symbol(z, Decl(genericRestParameters2.ts, 77, 36))
type T11 = P1<(...z: number[]) => void>;
>T11 : Symbol(T11, Decl(genericRestParameters2.ts, 77, 63))
>P1 : Symbol(P1, Decl(genericRestParameters2.ts, 73, 39))
>z : Symbol(z, Decl(genericRestParameters2.ts, 78, 15))
type T12 = P1<(x: number, y: number) => void>;
>T12 : Symbol(T12, Decl(genericRestParameters2.ts, 78, 40))
>P1 : Symbol(P1, Decl(genericRestParameters2.ts, 73, 39))
>x : Symbol(x, Decl(genericRestParameters2.ts, 79, 15))
>y : Symbol(y, Decl(genericRestParameters2.ts, 79, 25))

500
tests/baselines/reference/genericRestParameters2.types Normal file
View File

@@ -0,0 +1,500 @@
=== 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
>T : T
>args : T
>T : T
>T : 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)[]]
>f20 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>...t2 : string | boolean
>t2 : [string, ...boolean[]]
>true : true
type Parameters<T extends Function> = T extends ((...args: infer U) => any) | (new(...args: infer U) => any) ? U : any[];
>Parameters : Parameters<T>
>T : T
>Function : Function
>T : T
>args : U
>U : U
>args : U
>U : U
>U : U
type T01 = Parameters<(x: number, y: string, ...z: boolean[]) => void>;
>T01 : [number, string, ...boolean[]]
>Parameters : Parameters<T>
>x : number
>y : string
>z : boolean[]
type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>;
>T02 : [number, string, ...boolean[]]
>Parameters : Parameters<T>
>args : [number, string, ...boolean[]]
type T03 = Parameters<new (x: number, y: string, ...z: boolean[]) => void>;
>T03 : [number, string, ...boolean[]]
>Parameters : Parameters<T>
>x : number
>y : string
>z : boolean[]
type T04 = Parameters<new (...args: [number, string, ...boolean[]]) => void>;
>T04 : [number, string, ...boolean[]]
>Parameters : Parameters<T>
>args : [number, string, ...boolean[]]
type T05<T extends any[]> = Parameters<(x: string, ...args: T) => void>;
>T05 : Parameters<(x: string, ...args: T) => void>
>T : T
>Parameters : Parameters<T>
>x : string
>args : T
>T : T
type T06 = T05<[number, ...boolean[]]>;
>T06 : [string, number, ...boolean[]]
>T05 : Parameters<(x: string, ...args: T) => void>
type P1<T extends Function> = T extends (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[];
>P1 : P1<T>
>T : T
>Function : Function
>T : T
>head : A
>A : A
>tail : B
>B : B
>head : A
>A : A
>tail : B
>B : B
type T10 = P1<(x: number, y: string, ...z: boolean[]) => void>;
>T10 : { head: number; tail: [string, ...boolean[]]; }
>P1 : P1<T>
>x : number
>y : string
>z : boolean[]
type T11 = P1<(...z: number[]) => void>;
>T11 : { head: number; tail: number[]; }
>P1 : P1<T>
>z : number[]
type T12 = P1<(x: number, y: number) => void>;
>T12 : { head: number; tail: [number]; }
>P1 : P1<T>
>x : number
>y : number

79
tests/baselines/reference/optionalTupleElements1.errors.txt
View File

@@ -1,48 +1,31 @@
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(13,5): error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(11,29): error TS1257: A required element cannot follow an optional element.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(15,5): error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
Types of property '2' are incompatible.
Type 'boolean | undefined' is not assignable to type 'boolean'.
Type 'undefined' is not assignable to type 'boolean'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(14,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(16,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
Types of property '1' are incompatible.
Type 'string | undefined' is not assignable to type 'string'.
Type 'undefined' is not assignable to type 'string'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(15,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(17,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
Types of property '0' are incompatible.
Type 'number | undefined' is not assignable to type 'number'.
Type 'undefined' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(18,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(20,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'.
Types of property '1' are incompatible.
Type 'string | undefined' is not assignable to type 'string'.
Type 'undefined' is not assignable to type 'string'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(19,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(21,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'.
Types of property '0' are incompatible.
Type 'number | undefined' is not assignable to type 'number'.
Type 'undefined' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(23,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, (string | undefined)?, (boolean | undefined)?]'.
Types of property '0' are incompatible.
Type 'number | undefined' is not assignable to type 'number'.
Type 'undefined' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(30,29): error TS1257: A required element cannot follow an optional element.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(34,5): error TS2322: Type '[number, string | undefined, boolean]' is not assignable to type '[number, string, boolean]'.
Type 'string | undefined' is not assignable to type 'string'.
Type 'undefined' is not assignable to type 'string'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(35,5): error TS2322: Type '[number, string | undefined, boolean]' is not assignable to type '[number, string, (boolean | undefined)?]'.
Types of property '1' are incompatible.
Type 'string | undefined' is not assignable to type 'string'.
Type 'undefined' is not assignable to type 'string'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(40,5): error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
Types of property '2' are incompatible.
Type 'boolean | undefined' is not assignable to type 'boolean'.
Type 'undefined' is not assignable to type 'boolean'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(41,5): error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
Property '1' is optional in type '[number, (string | undefined)?, (boolean | undefined)?]' but required in type '[number, string | undefined, boolean]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(42,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(25,5): error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, (string | undefined)?, (boolean | undefined)?]'.
Types of property '0' are incompatible.
Type 'number | undefined' is not assignable to type 'number'.
Type 'undefined' is not assignable to type 'number'.
==== tests/cases/conformance/types/tuple/optionalTupleElements1.ts (12 errors) ====
==== tests/cases/conformance/types/tuple/optionalTupleElements1.ts (7 errors) ====
type T1 = [number, string, boolean];
type T2 = [number, string, boolean?];
type T3 = [number, string?, boolean?];
@@ -53,6 +36,10 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(42,5): error TS232
type L3 = T3["length"];
type L4 = T4["length"];
type T5 = [number, string?, boolean]; // Error
~~~~~~~
!!! error TS1257: A required element cannot follow an optional element.
function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
t1 = t1;
t1 = t2; // Error
@@ -102,50 +89,9 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(42,5): error TS232
t4 = t4;
}
type T5 = [number, string?, boolean];
~~~~~~~
!!! error TS1257: A required element cannot follow an optional element.
type L5 = T5["length"];
function f2(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) {
t1 = t5; // Error
~~
!!! error TS2322: Type '[number, string | undefined, boolean]' is not assignable to type '[number, string, boolean]'.
!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'.
!!! error TS2322: Type 'undefined' is not assignable to type 'string'.
t2 = t5; // Error
~~
!!! error TS2322: Type '[number, string | undefined, boolean]' is not assignable to type '[number, string, (boolean | undefined)?]'.
!!! error TS2322: Types of property '1' are incompatible.
!!! error TS2322: Type 'string | undefined' is not assignable to type 'string'.
!!! error TS2322: Type 'undefined' is not assignable to type 'string'.
t3 = t5;
t4 = t5;
t5 = t5;
t5 = t1;
t5 = t2; // Error
~~
!!! error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
!!! error TS2322: Types of property '2' are incompatible.
!!! error TS2322: Type 'boolean | undefined' is not assignable to type 'boolean'.
!!! error TS2322: Type 'undefined' is not assignable to type 'boolean'.
t5 = t3; // Error
~~
!!! error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
!!! error TS2322: Property '1' is optional in type '[number, (string | undefined)?, (boolean | undefined)?]' but required in type '[number, string | undefined, boolean]'.
t5 = t4; // Error
~~
!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string | undefined, boolean]'.
!!! error TS2322: Types of property '0' are incompatible.
!!! error TS2322: Type 'number | undefined' is not assignable to type 'number'.
!!! error TS2322: Type 'undefined' is not assignable to type 'number'.
t5 = t5;
}
let t2: T2;
let t3: T3;
let t4: T4;
let t5: T5;
t2 = [42, "hello"];
t3 = [42, "hello"];
@@ -156,5 +102,4 @@ tests/cases/conformance/types/tuple/optionalTupleElements1.ts(42,5): error TS232
t4 = [,"hello", true];
t4 = [,,true];
t4 = [];
t5 = [42,,true];

39
tests/baselines/reference/optionalTupleElements1.js
View File

@@ -9,6 +9,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
@@ -28,26 +30,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"];
@@ -58,7 +43,6 @@ t4 = [42,,true];
t4 = [,"hello", true];
t4 = [,,true];
t4 = [];
t5 = [42,,true];
//// [optionalTupleElements1.js]
@@ -81,22 +65,9 @@ function f1(t1, t2, t3, t4) {
t4 = t3;
t4 = t4;
}
function f2(t1, t2, t3, t4, 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;
}
var t2;
var t3;
var t4;
var t5;
t2 = [42, "hello"];
t3 = [42, "hello"];
t3 = [42, , true];
@@ -106,7 +77,6 @@ t4 = [42, , true];
t4 = [, "hello", true];
t4 = [, , true];
t4 = [];
t5 = [42, , true];
//// [optionalTupleElements1.d.ts]
@@ -118,11 +88,8 @@ declare type L1 = T1["length"];
declare type L2 = T2["length"];
declare type L3 = T3["length"];
declare type L4 = T4["length"];
declare function f1(t1: T1, t2: T2, t3: T3, t4: T4): void;
declare type T5 = [number, string?, boolean];
declare type L5 = T5["length"];
declare function f2(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): void;
declare function f1(t1: T1, t2: T2, t3: T3, t4: T4): void;
declare let t2: T2;
declare let t3: T3;
declare let t4: T4;
declare let t5: T5;

169
tests/baselines/reference/optionalTupleElements1.symbols
View File

@@ -27,186 +27,121 @@ type L4 = T4["length"];
>L4 : Symbol(L4, Decl(optionalTupleElements1.ts, 7, 23))
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
type T5 = [number, string?, boolean]; // Error
>T5 : Symbol(T5, Decl(optionalTupleElements1.ts, 8, 23))
function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
>f1 : Symbol(f1, Decl(optionalTupleElements1.ts, 8, 23))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>f1 : Symbol(f1, Decl(optionalTupleElements1.ts, 10, 37))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
>T1 : Symbol(T1, Decl(optionalTupleElements1.ts, 0, 0))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
t1 = t1;
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
t1 = t2; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
t1 = t3; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
t1 = t4; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
t2 = t1;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
t2 = t2;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
t2 = t3; // Error
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
t2 = t4; // Error
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
t3 = t1;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
t3 = t2;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
t3 = t3;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
t3 = t4; // Error
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
t4 = t1;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 12, 12))
t4 = t2;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 12, 19))
t4 = t3;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 12, 27))
t4 = t4;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
}
type T5 = [number, string?, boolean];
>T5 : Symbol(T5, Decl(optionalTupleElements1.ts, 27, 1))
type L5 = T5["length"];
>L5 : Symbol(L5, Decl(optionalTupleElements1.ts, 29, 37))
>T5 : Symbol(T5, Decl(optionalTupleElements1.ts, 27, 1))
function f2(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) {
>f2 : Symbol(f2, Decl(optionalTupleElements1.ts, 30, 23))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 32, 12))
>T1 : Symbol(T1, Decl(optionalTupleElements1.ts, 0, 0))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 32, 19))
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 27))
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 32, 35))
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>T5 : Symbol(T5, Decl(optionalTupleElements1.ts, 27, 1))
t1 = t5; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 32, 12))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
t2 = t5; // Error
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 32, 19))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
t3 = t5;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 27))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
t4 = t5;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 32, 35))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
t5 = t5;
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
t5 = t1;
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 32, 12))
t5 = t2; // Error
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 32, 19))
t5 = t3; // Error
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 27))
t5 = t4; // Error
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 32, 35))
t5 = t5;
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 32, 43))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 12, 35))
}
let t2: T2;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 45, 3))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 31, 3))
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
let t3: T3;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 3))
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
let t4: T4;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
let t5: T5;
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 48, 3))
>T5 : Symbol(T5, Decl(optionalTupleElements1.ts, 27, 1))
t2 = [42, "hello"];
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 45, 3))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 31, 3))
t3 = [42, "hello"];
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 3))
t3 = [42,,true]
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 3))
t3 = [42];
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 32, 3))
t4 = [42, "hello"];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))
t4 = [42,,true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))
t4 = [,"hello", true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))
t4 = [,,true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))
t4 = [];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t5 = [42,,true];
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 48, 3))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 33, 3))

86
tests/baselines/reference/optionalTupleElements1.types
View File

@@ -27,6 +27,9 @@ type L4 = T4["length"];
>L4 : 0 | 3 | 2 | 1
>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
type T5 = [number, string?, boolean]; // Error
>T5 : [number, string | undefined, boolean]
function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
>f1 : (t1: [number, string, boolean], t2: [number, string, (boolean | undefined)?], t3: [number, (string | undefined)?, (boolean | undefined)?], t4: [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]) => void
>t1 : [number, string, boolean]
@@ -119,77 +122,6 @@ function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
}
type T5 = [number, string?, boolean];
>T5 : [number, string | undefined, boolean]
type L5 = T5["length"];
>L5 : 3
>T5 : [number, string | undefined, boolean]
function f2(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) {
>f2 : (t1: [number, string, boolean], t2: [number, string, (boolean | undefined)?], t3: [number, (string | undefined)?, (boolean | undefined)?], t4: [(number | undefined)?, (string | undefined)?, (boolean | undefined)?], t5: [number, string | undefined, boolean]) => void
>t1 : [number, string, boolean]
>T1 : [number, string, boolean]
>t2 : [number, string, (boolean | undefined)?]
>T2 : [number, string, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>T3 : [number, (string | undefined)?, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
>T5 : [number, string | undefined, boolean]
t1 = t5; // Error
>t1 = t5 : [number, string | undefined, boolean]
>t1 : [number, string, boolean]
>t5 : [number, string | undefined, boolean]
t2 = t5; // Error
>t2 = t5 : [number, string | undefined, boolean]
>t2 : [number, string, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
t3 = t5;
>t3 = t5 : [number, string | undefined, boolean]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
t4 = t5;
>t4 = t5 : [number, string | undefined, boolean]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
t5 = t5;
>t5 = t5 : [number, string | undefined, boolean]
>t5 : [number, string | undefined, boolean]
>t5 : [number, string | undefined, boolean]
t5 = t1;
>t5 = t1 : [number, string, boolean]
>t5 : [number, string | undefined, boolean]
>t1 : [number, string, boolean]
t5 = t2; // Error
>t5 = t2 : [number, string, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
>t2 : [number, string, (boolean | undefined)?]
t5 = t3; // Error
>t5 = t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
t5 = t4; // Error
>t5 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t5 : [number, string | undefined, boolean]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
t5 = t5;
>t5 = t5 : [number, string | undefined, boolean]
>t5 : [number, string | undefined, boolean]
>t5 : [number, string | undefined, boolean]
}
let t2: T2;
>t2 : [number, string, (boolean | undefined)?]
>T2 : [number, string, (boolean | undefined)?]
@@ -202,10 +134,6 @@ let t4: T4;
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
let t5: T5;
>t5 : [number, string | undefined, boolean]
>T5 : [number, string | undefined, boolean]
t2 = [42, "hello"];
>t2 = [42, "hello"] : [number, string]
>t2 : [number, string, (boolean | undefined)?]
@@ -270,11 +198,3 @@ t4 = [];
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>[] : []
t5 = [42,,true];
>t5 = [42,,true] : [number, undefined, true]
>t5 : [number, string | undefined, boolean]
>[42,,true] : [number, undefined, true]
>42 : 42
> : undefined
>true : true

138
tests/baselines/reference/restTupleElements1.errors.txt Normal file
View File

@@ -0,0 +1,138 @@
tests/cases/conformance/types/tuple/restTupleElements1.ts(3,22): error TS1257: A required element cannot follow an optional element.
tests/cases/conformance/types/tuple/restTupleElements1.ts(8,13): error TS1256: A rest element must be last in a tuple type.
tests/cases/conformance/types/tuple/restTupleElements1.ts(9,13): error TS2574: A rest element type must be an array type.
tests/cases/conformance/types/tuple/restTupleElements1.ts(10,13): error TS2574: A rest element type must be an array type.
tests/cases/conformance/types/tuple/restTupleElements1.ts(10,16): error TS8020: JSDoc types can only be used inside documentation comments.
tests/cases/conformance/types/tuple/restTupleElements1.ts(23,31): error TS2344: Type 'number[]' does not satisfy the constraint '[number, ...number[]]'.
Property '0' is missing in type 'number[]'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(24,31): error TS2344: Type '[]' does not satisfy the constraint '[number, ...number[]]'.
Property '0' is missing in type '[]'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(29,18): error TS2344: Type 'number[]' does not satisfy the constraint '[number]'.
Property '0' is missing in type 'number[]'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(30,18): error TS2344: Type '[number, ...number[]]' does not satisfy the constraint '[number]'.
Types of property 'length' are incompatible.
Type 'number' is not assignable to type '1'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(32,31): error TS2344: Type '[number, ...string[]]' does not satisfy the constraint '[number, ...number[]]'.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(33,31): error TS2344: Type '[string, ...number[]]' does not satisfy the constraint '[number, ...number[]]'.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(34,31): error TS2344: Type '[number, number, string]' does not satisfy the constraint '[number, ...number[]]'.
Property '2' is incompatible with rest element type.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(35,31): error TS2344: Type '[number, number, number, string]' does not satisfy the constraint '[number, ...number[]]'.
Property '3' is incompatible with rest element type.
Type 'string' is not assignable to type 'number'.
tests/cases/conformance/types/tuple/restTupleElements1.ts(59,4): error TS2345: Argument of type '[]' is not assignable to parameter of type '[{}, ...{}[]]'.
Property '0' is missing in type '[]'.
==== tests/cases/conformance/types/tuple/restTupleElements1.ts (14 errors) ====
type T00 = [string?];
type T01 = [string, string?];
type T02 = [string?, string]; // Error
~~~~~~
!!! error TS1257: A required element cannot follow an optional element.
type T03 = [...string[]];
type T04 = [...[...string[]]];
type T05 = [...[...[...string[]]]];
type T06 = [string, ...string[]];
type T07 = [...string[], string]; // Error
~~~~~~~~~~~
!!! error TS1256: A rest element must be last in a tuple type.
type T08 = [...string]; // Error
~~~~~~~~~
!!! error TS2574: A rest element type must be an array type.
type T09 = [...string?]; // Error
~~~~~~~~~~
!!! error TS2574: A rest element type must be an array type.
~~~~~~~
!!! error TS8020: JSDoc types can only be used inside documentation comments.
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
~~~~~~~~
!!! error TS2344: Type 'number[]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Property '0' is missing in type 'number[]'.
assign<[number, ...number[]], []>(); // Error
~~
!!! error TS2344: Type '[]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Property '0' is missing in type '[]'.
assign<[number, ...number[]], [number]>();
assign<[number, ...number[]], [number, number]>();
assign<[number, ...number[]], [number, number, ...number[]]>();
assign<[number], [...number[]]>(); // Error
~~~~~~~~~~~~~
!!! error TS2344: Type 'number[]' does not satisfy the constraint '[number]'.
!!! error TS2344: Property '0' is missing in type 'number[]'.
assign<[number], [number, ...number[]]>(); // Error
~~~~~~~~~~~~~~~~~~~~~
!!! error TS2344: Type '[number, ...number[]]' does not satisfy the constraint '[number]'.
!!! error TS2344: Types of property 'length' are incompatible.
!!! error TS2344: Type 'number' is not assignable to type '1'.
assign<[number, ...number[]], [number, ...string[]]>(); // Error
~~~~~~~~~~~~~~~~~~~~~
!!! error TS2344: Type '[number, ...string[]]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Type 'string' is not assignable to type 'number'.
assign<[number, ...number[]], [string, ...number[]]>(); // Error
~~~~~~~~~~~~~~~~~~~~~
!!! error TS2344: Type '[string, ...number[]]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Type 'string' is not assignable to type 'number'.
assign<[number, ...number[]], [number, number, string]>(); // Error
~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2344: Type '[number, number, string]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Property '2' is incompatible with rest element type.
!!! error TS2344: Type 'string' is not assignable to type 'number'.
assign<[number, ...number[]], [number, number, number, string]>(); // Error
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2344: Type '[number, number, number, string]' does not satisfy the constraint '[number, ...number[]]'.
!!! error TS2344: Property '3' is incompatible with rest element type.
!!! error TS2344: Type 'string' is not assignable to type 'number'.
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
~~
!!! error TS2345: Argument of type '[]' is not assignable to parameter of type '[{}, ...{}[]]'.
!!! error TS2345: Property '0' is missing in type '[]'.
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));

135
tests/baselines/reference/restTupleElements1.js Normal file
View File

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

217
tests/baselines/reference/restTupleElements1.symbols Normal file
View File

@@ -0,0 +1,217 @@
=== tests/cases/conformance/types/tuple/restTupleElements1.ts ===
type T00 = [string?];
>T00 : Symbol(T00, Decl(restTupleElements1.ts, 0, 0))
type T01 = [string, string?];
>T01 : Symbol(T01, Decl(restTupleElements1.ts, 0, 21))
type T02 = [string?, string]; // Error
>T02 : Symbol(T02, Decl(restTupleElements1.ts, 1, 29))
type T03 = [...string[]];
>T03 : Symbol(T03, Decl(restTupleElements1.ts, 2, 29))
type T04 = [...[...string[]]];
>T04 : Symbol(T04, Decl(restTupleElements1.ts, 3, 25))
type T05 = [...[...[...string[]]]];
>T05 : Symbol(T05, Decl(restTupleElements1.ts, 4, 30))
type T06 = [string, ...string[]];
>T06 : Symbol(T06, Decl(restTupleElements1.ts, 5, 35))
type T07 = [...string[], string]; // Error
>T07 : Symbol(T07, Decl(restTupleElements1.ts, 6, 33))
type T08 = [...string]; // Error
>T08 : Symbol(T08, Decl(restTupleElements1.ts, 7, 33))
type T09 = [...string?]; // Error
>T09 : Symbol(T09, Decl(restTupleElements1.ts, 8, 23))
type T10 = [string, ...[...string[]]];
>T10 : Symbol(T10, Decl(restTupleElements1.ts, 9, 24))
type T11 = [string, ...[...[...string[]]]];
>T11 : Symbol(T11, Decl(restTupleElements1.ts, 10, 38))
type T15 = [boolean, number, ...string[]];
>T15 : Symbol(T15, Decl(restTupleElements1.ts, 11, 43))
type L15 = T15["length"]; // number
>L15 : Symbol(L15, Decl(restTupleElements1.ts, 13, 42))
>T15 : Symbol(T15, Decl(restTupleElements1.ts, 11, 43))
declare function assign<T, S extends T>(): void;
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
>T : Symbol(T, Decl(restTupleElements1.ts, 16, 24))
>S : Symbol(S, Decl(restTupleElements1.ts, 16, 26))
>T : Symbol(T, Decl(restTupleElements1.ts, 16, 24))
assign<number[], [...number[]]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<number[], [number, ...number[]]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[...number[]], number[]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], number[]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], []>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number, number]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number, number, ...number[]]>();
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number], [...number[]]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number], [number, ...number[]]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number, ...string[]]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [string, ...number[]]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number, number, string]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
assign<[number, ...number[]], [number, number, number, string]>(); // Error
>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25))
type T20 = [number, string, ...boolean[]];
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T21 = T20[0];
>T21 : Symbol(T21, Decl(restTupleElements1.ts, 36, 42))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T22 = T20[0 | 1];
>T22 : Symbol(T22, Decl(restTupleElements1.ts, 38, 18))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T23 = T20[0 | 1 | 2];
>T23 : Symbol(T23, Decl(restTupleElements1.ts, 39, 22))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T24 = T20[0 | 1 | 2 | 3];
>T24 : Symbol(T24, Decl(restTupleElements1.ts, 40, 26))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T25 = T20[1 | 2 | 3];
>T25 : Symbol(T25, Decl(restTupleElements1.ts, 41, 30))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T26 = T20[2 | 3];
>T26 : Symbol(T26, Decl(restTupleElements1.ts, 42, 26))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T27 = T20[3];
>T27 : Symbol(T27, Decl(restTupleElements1.ts, 43, 22))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
type T28 = T20[number];
>T28 : Symbol(T28, Decl(restTupleElements1.ts, 44, 18))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
declare const t: T20;
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
>T20 : Symbol(T20, Decl(restTupleElements1.ts, 34, 66))
declare const x: number;
>x : Symbol(x, Decl(restTupleElements1.ts, 48, 13))
let e0 = t[0]; // number
>e0 : Symbol(e0, Decl(restTupleElements1.ts, 50, 3))
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
>0 : Symbol(0)
let e1 = t[1]; // string
>e1 : Symbol(e1, Decl(restTupleElements1.ts, 51, 3))
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
>1 : Symbol(1)
let e2 = t[2]; // boolean
>e2 : Symbol(e2, Decl(restTupleElements1.ts, 52, 3))
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
let e3 = t[3]; // boolean
>e3 : Symbol(e3, Decl(restTupleElements1.ts, 53, 3))
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
let ex = t[x]; // number | string | boolean
>ex : Symbol(ex, Decl(restTupleElements1.ts, 54, 3))
>t : Symbol(t, Decl(restTupleElements1.ts, 47, 13))
>x : Symbol(x, Decl(restTupleElements1.ts, 48, 13))
declare function f0<T, U>(x: [T, ...U[]]): [T, U];
>f0 : Symbol(f0, Decl(restTupleElements1.ts, 54, 14))
>T : Symbol(T, Decl(restTupleElements1.ts, 56, 20))
>U : Symbol(U, Decl(restTupleElements1.ts, 56, 22))
>x : Symbol(x, Decl(restTupleElements1.ts, 56, 26))
>T : Symbol(T, Decl(restTupleElements1.ts, 56, 20))
>U : Symbol(U, Decl(restTupleElements1.ts, 56, 22))
>T : Symbol(T, Decl(restTupleElements1.ts, 56, 20))
>U : Symbol(U, Decl(restTupleElements1.ts, 56, 22))
f0([]); // Error
>f0 : Symbol(f0, Decl(restTupleElements1.ts, 54, 14))
f0([1]);
>f0 : Symbol(f0, Decl(restTupleElements1.ts, 54, 14))
f0([1, 2, 3]);
>f0 : Symbol(f0, Decl(restTupleElements1.ts, 54, 14))
f0([1, "hello", true]);
>f0 : Symbol(f0, Decl(restTupleElements1.ts, 54, 14))
declare function f1(a: [(x: number) => number, ...((x: string) => number)[]]): void;
>f1 : Symbol(f1, Decl(restTupleElements1.ts, 61, 23))
>a : Symbol(a, Decl(restTupleElements1.ts, 63, 20))
>x : Symbol(x, Decl(restTupleElements1.ts, 63, 25))
>x : Symbol(x, Decl(restTupleElements1.ts, 63, 52))
declare function f2(...a: [(x: number) => number, ...((x: string) => number)[]]): void;
>f2 : Symbol(f2, Decl(restTupleElements1.ts, 63, 84))
>a : Symbol(a, Decl(restTupleElements1.ts, 64, 20))
>x : Symbol(x, Decl(restTupleElements1.ts, 64, 28))
>x : Symbol(x, Decl(restTupleElements1.ts, 64, 55))
f1([x => x * 2, x => x.length, x => x.charCodeAt(0)]);
>f1 : Symbol(f1, Decl(restTupleElements1.ts, 61, 23))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 4))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 4))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 15))
>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 15))
>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 30))
>x.charCodeAt : Symbol(String.charCodeAt, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 66, 30))
>charCodeAt : Symbol(String.charCodeAt, Decl(lib.es5.d.ts, --, --))
f2(x => x * 2, x => x.length, x => x.charCodeAt(0));
>f2 : Symbol(f2, Decl(restTupleElements1.ts, 63, 84))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 3))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 3))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 14))
>x.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 14))
>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 29))
>x.charCodeAt : Symbol(String.charCodeAt, Decl(lib.es5.d.ts, --, --))
>x : Symbol(x, Decl(restTupleElements1.ts, 67, 29))
>charCodeAt : Symbol(String.charCodeAt, Decl(lib.es5.d.ts, --, --))

270
tests/baselines/reference/restTupleElements1.types Normal file
View File

@@ -0,0 +1,270 @@
=== tests/cases/conformance/types/tuple/restTupleElements1.ts ===
type T00 = [string?];
>T00 : [(string | undefined)?]
type T01 = [string, string?];
>T01 : [string, (string | undefined)?]
type T02 = [string?, string]; // Error
>T02 : [string | undefined, string]
type T03 = [...string[]];
>T03 : string[]
type T04 = [...[...string[]]];
>T04 : string[]
type T05 = [...[...[...string[]]]];
>T05 : string[]
type T06 = [string, ...string[]];
>T06 : [string, ...string[]]
type T07 = [...string[], string]; // Error
>T07 : [string[], string]
type T08 = [...string]; // Error
>T08 : string[]
type T09 = [...string?]; // Error
>T09 : (string | null)[]
type T10 = [string, ...[...string[]]];
>T10 : [string, ...string[]]
type T11 = [string, ...[...[...string[]]]];
>T11 : [string, ...string[]]
type T15 = [boolean, number, ...string[]];
>T15 : [boolean, number, ...string[]]
type L15 = T15["length"]; // number
>L15 : number
>T15 : [boolean, number, ...string[]]
declare function assign<T, S extends T>(): void;
>assign : <T, S extends T>() => void
>T : T
>S : S
>T : T
assign<number[], [...number[]]>();
>assign<number[], [...number[]]>() : void
>assign : <T, S extends T>() => void
assign<number[], [number, ...number[]]>();
>assign<number[], [number, ...number[]]>() : void
>assign : <T, S extends T>() => void
assign<[...number[]], number[]>();
>assign<[...number[]], number[]>() : void
>assign : <T, S extends T>() => void
assign<[number, ...number[]], number[]>(); // Error
>assign<[number, ...number[]], number[]>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], []>(); // Error
>assign<[number, ...number[]], []>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number]>();
>assign<[number, ...number[]], [number]>() : void
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number, number]>();
>assign<[number, ...number[]], [number, number]>() : void
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number, number, ...number[]]>();
>assign<[number, ...number[]], [number, number, ...number[]]>() : void
>assign : <T, S extends T>() => void
assign<[number], [...number[]]>(); // Error
>assign<[number], [...number[]]>() : any
>assign : <T, S extends T>() => void
assign<[number], [number, ...number[]]>(); // Error
>assign<[number], [number, ...number[]]>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number, ...string[]]>(); // Error
>assign<[number, ...number[]], [number, ...string[]]>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [string, ...number[]]>(); // Error
>assign<[number, ...number[]], [string, ...number[]]>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number, number, string]>(); // Error
>assign<[number, ...number[]], [number, number, string]>() : any
>assign : <T, S extends T>() => void
assign<[number, ...number[]], [number, number, number, string]>(); // Error
>assign<[number, ...number[]], [number, number, number, string]>() : any
>assign : <T, S extends T>() => void
type T20 = [number, string, ...boolean[]];
>T20 : [number, string, ...boolean[]]
type T21 = T20[0];
>T21 : number
>T20 : [number, string, ...boolean[]]
type T22 = T20[0 | 1];
>T22 : string | number
>T20 : [number, string, ...boolean[]]
type T23 = T20[0 | 1 | 2];
>T23 : string | number | boolean
>T20 : [number, string, ...boolean[]]
type T24 = T20[0 | 1 | 2 | 3];
>T24 : string | number | boolean
>T20 : [number, string, ...boolean[]]
type T25 = T20[1 | 2 | 3];
>T25 : string | boolean
>T20 : [number, string, ...boolean[]]
type T26 = T20[2 | 3];
>T26 : boolean
>T20 : [number, string, ...boolean[]]
type T27 = T20[3];
>T27 : boolean
>T20 : [number, string, ...boolean[]]
type T28 = T20[number];
>T28 : string | number | boolean
>T20 : [number, string, ...boolean[]]
declare const t: T20;
>t : [number, string, ...boolean[]]
>T20 : [number, string, ...boolean[]]
declare const x: number;
>x : number
let e0 = t[0]; // number
>e0 : number
>t[0] : number
>t : [number, string, ...boolean[]]
>0 : 0
let e1 = t[1]; // string
>e1 : string
>t[1] : string
>t : [number, string, ...boolean[]]
>1 : 1
let e2 = t[2]; // boolean
>e2 : boolean
>t[2] : boolean
>t : [number, string, ...boolean[]]
>2 : 2
let e3 = t[3]; // boolean
>e3 : boolean
>t[3] : boolean
>t : [number, string, ...boolean[]]
>3 : 3
let ex = t[x]; // number | string | boolean
>ex : string | number | boolean
>t[x] : string | number | boolean
>t : [number, string, ...boolean[]]
>x : number
declare function f0<T, U>(x: [T, ...U[]]): [T, U];
>f0 : <T, U>(x: [T, ...U[]]) => [T, U]
>T : T
>U : U
>x : [T, ...U[]]
>T : T
>U : U
>T : T
>U : U
f0([]); // Error
>f0([]) : any
>f0 : <T, U>(x: [T, ...U[]]) => [T, U]
>[] : never[]
f0([1]);
>f0([1]) : [number, {}]
>f0 : <T, U>(x: [T, ...U[]]) => [T, U]
>[1] : [number]
>1 : 1
f0([1, 2, 3]);
>f0([1, 2, 3]) : [number, number]
>f0 : <T, U>(x: [T, ...U[]]) => [T, U]
>[1, 2, 3] : [number, number, number]
>1 : 1
>2 : 2
>3 : 3
f0([1, "hello", true]);
>f0([1, "hello", true]) : [number, string | boolean]
>f0 : <T, U>(x: [T, ...U[]]) => [T, U]
>[1, "hello", true] : [number, string, true]
>1 : 1
>"hello" : "hello"
>true : true
declare function f1(a: [(x: number) => number, ...((x: string) => number)[]]): void;
>f1 : (a: [(x: number) => number, ...((x: string) => number)[]]) => void
>a : [(x: number) => number, ...((x: string) => number)[]]
>x : number
>x : string
declare function f2(...a: [(x: number) => number, ...((x: string) => number)[]]): void;
>f2 : (a_0: (x: number) => number, ...a_1: ((x: string) => number)[]) => void
>a : [(x: number) => number, ...((x: string) => number)[]]
>x : number
>x : string
f1([x => x * 2, x => x.length, x => x.charCodeAt(0)]);
>f1([x => x * 2, x => x.length, x => x.charCodeAt(0)]) : void
>f1 : (a: [(x: number) => number, ...((x: string) => number)[]]) => void
>[x => x * 2, x => x.length, x => x.charCodeAt(0)] : [(x: number) => number, (x: string) => number, (x: string) => number]
>x => x * 2 : (x: number) => number
>x : number
>x * 2 : number
>x : number
>2 : 2
>x => x.length : (x: string) => number
>x : string
>x.length : number
>x : string
>length : number
>x => x.charCodeAt(0) : (x: string) => number
>x : string
>x.charCodeAt(0) : number
>x.charCodeAt : (index: number) => number
>x : string
>charCodeAt : (index: number) => number
>0 : 0
f2(x => x * 2, x => x.length, x => x.charCodeAt(0));
>f2(x => x * 2, x => x.length, x => x.charCodeAt(0)) : void
>f2 : (a_0: (x: number) => number, ...a_1: ((x: string) => number)[]) => void
>x => x * 2 : (x: number) => number
>x : number
>x * 2 : number
>x : number
>2 : 2
>x => x.length : (x: string) => number
>x : string
>x.length : number
>x : string
>length : number
>x => x.charCodeAt(0) : (x: string) => number
>x : string
>x.charCodeAt(0) : number
>x.charCodeAt : (index: number) => number
>x : string
>charCodeAt : (index: number) => number
>0 : 0