From 5ef7e9ff34e7b27d9dd1cef370dd02e17327a624 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Mon, 25 Jun 2018 10:45:48 -1000 Subject: [PATCH] Accept new baselines --- .../reference/genericRestParameters2.js | 158 ++++++ .../reference/genericRestParameters2.symbols | 326 ++++++++++++ .../reference/genericRestParameters2.types | 500 ++++++++++++++++++ .../optionalTupleElements1.errors.txt | 79 +-- .../reference/optionalTupleElements1.js | 39 +- .../reference/optionalTupleElements1.symbols | 169 ++---- .../reference/optionalTupleElements1.types | 86 +-- .../reference/restTupleElements1.errors.txt | 138 +++++ .../baselines/reference/restTupleElements1.js | 135 +++++ .../reference/restTupleElements1.symbols | 217 ++++++++ .../reference/restTupleElements1.types | 270 ++++++++++ 11 files changed, 1814 insertions(+), 303 deletions(-) create mode 100644 tests/baselines/reference/genericRestParameters2.js create mode 100644 tests/baselines/reference/genericRestParameters2.symbols create mode 100644 tests/baselines/reference/genericRestParameters2.types create mode 100644 tests/baselines/reference/restTupleElements1.errors.txt create mode 100644 tests/baselines/reference/restTupleElements1.js create mode 100644 tests/baselines/reference/restTupleElements1.symbols create mode 100644 tests/baselines/reference/restTupleElements1.types diff --git a/tests/baselines/reference/genericRestParameters2.js b/tests/baselines/reference/genericRestParameters2.js new file mode 100644 index 00000000000..143a4a62f52 --- /dev/null +++ b/tests/baselines/reference/genericRestParameters2.js @@ -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: (...args: T) => T; + +f20(...t1); +f20(42, ...t2); +f20(42, "hello", ...t3); +f20(42, "hello", ...t2, true); + +type Parameters = 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 void>; +type T04 = Parameters void>; +type T05 = Parameters<(x: string, ...args: T) => void>; +type T06 = T05<[number, ...boolean[]]>; + +type P1 = 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: (...args: T) => T; +declare type Parameters = 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 void>; +declare type T04 = Parameters void>; +declare type T05 = Parameters<(x: string, ...args: T) => void>; +declare type T06 = T05<[number, ...boolean[]]>; +declare type P1 = 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>; diff --git a/tests/baselines/reference/genericRestParameters2.symbols b/tests/baselines/reference/genericRestParameters2.symbols new file mode 100644 index 00000000000..164d08d132e --- /dev/null +++ b/tests/baselines/reference/genericRestParameters2.symbols @@ -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: (...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 ((...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 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 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 = 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 (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)) + diff --git a/tests/baselines/reference/genericRestParameters2.types b/tests/baselines/reference/genericRestParameters2.types new file mode 100644 index 00000000000..4b7904ce1d5 --- /dev/null +++ b/tests/baselines/reference/genericRestParameters2.types @@ -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: (...args: T) => T; +>f20 : (...args: T) => T +>T : T +>args : T +>T : T +>T : T + +f20(...t1); +>f20(...t1) : [number, string, ...boolean[]] +>f20 : (...args: T) => T +>...t1 : string | number | boolean +>t1 : [number, string, ...boolean[]] + +f20(42, ...t2); +>f20(42, ...t2) : [number, string, ...boolean[]] +>f20 : (...args: T) => T +>42 : 42 +>...t2 : string | boolean +>t2 : [string, ...boolean[]] + +f20(42, "hello", ...t3); +>f20(42, "hello", ...t3) : [number, string, ...boolean[]] +>f20 : (...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 : (...args: T) => T +>42 : 42 +>"hello" : "hello" +>...t2 : string | boolean +>t2 : [string, ...boolean[]] +>true : true + +type Parameters = T extends ((...args: infer U) => any) | (new(...args: infer U) => any) ? U : any[]; +>Parameters : Parameters +>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 +>x : number +>y : string +>z : boolean[] + +type T02 = Parameters<(...args: [number, string, ...boolean[]]) => void>; +>T02 : [number, string, ...boolean[]] +>Parameters : Parameters +>args : [number, string, ...boolean[]] + +type T03 = Parameters void>; +>T03 : [number, string, ...boolean[]] +>Parameters : Parameters +>x : number +>y : string +>z : boolean[] + +type T04 = Parameters void>; +>T04 : [number, string, ...boolean[]] +>Parameters : Parameters +>args : [number, string, ...boolean[]] + +type T05 = Parameters<(x: string, ...args: T) => void>; +>T05 : Parameters<(x: string, ...args: T) => void> +>T : T +>Parameters : Parameters +>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 (head: infer A, ...tail: infer B) => any ? { head: A, tail: B } : any[]; +>P1 : P1 +>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 +>x : number +>y : string +>z : boolean[] + +type T11 = P1<(...z: number[]) => void>; +>T11 : { head: number; tail: number[]; } +>P1 : P1 +>z : number[] + +type T12 = P1<(x: number, y: number) => void>; +>T12 : { head: number; tail: [number]; } +>P1 : P1 +>x : number +>y : number + diff --git a/tests/baselines/reference/optionalTupleElements1.errors.txt b/tests/baselines/reference/optionalTupleElements1.errors.txt index e6d7b332c18..ac9f5f244da 100644 --- a/tests/baselines/reference/optionalTupleElements1.errors.txt +++ b/tests/baselines/reference/optionalTupleElements1.errors.txt @@ -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]; \ No newline at end of file diff --git a/tests/baselines/reference/optionalTupleElements1.js b/tests/baselines/reference/optionalTupleElements1.js index 118b3fb1845..73d3f616aa7 100644 --- a/tests/baselines/reference/optionalTupleElements1.js +++ b/tests/baselines/reference/optionalTupleElements1.js @@ -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; diff --git a/tests/baselines/reference/optionalTupleElements1.symbols b/tests/baselines/reference/optionalTupleElements1.symbols index 8148ccffef9..e70d69b768a 100644 --- a/tests/baselines/reference/optionalTupleElements1.symbols +++ b/tests/baselines/reference/optionalTupleElements1.symbols @@ -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)) diff --git a/tests/baselines/reference/optionalTupleElements1.types b/tests/baselines/reference/optionalTupleElements1.types index 5cbe036b052..fa09afab3f0 100644 --- a/tests/baselines/reference/optionalTupleElements1.types +++ b/tests/baselines/reference/optionalTupleElements1.types @@ -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 - diff --git a/tests/baselines/reference/restTupleElements1.errors.txt b/tests/baselines/reference/restTupleElements1.errors.txt new file mode 100644 index 00000000000..dbabfbe640e --- /dev/null +++ b/tests/baselines/reference/restTupleElements1.errors.txt @@ -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(): void; + + assign(); + assign(); + 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(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)); + \ No newline at end of file diff --git a/tests/baselines/reference/restTupleElements1.js b/tests/baselines/reference/restTupleElements1.js new file mode 100644 index 00000000000..a15c7fd4dd1 --- /dev/null +++ b/tests/baselines/reference/restTupleElements1.js @@ -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(): void; + +assign(); +assign(); +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(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(): 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(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; diff --git a/tests/baselines/reference/restTupleElements1.symbols b/tests/baselines/reference/restTupleElements1.symbols new file mode 100644 index 00000000000..5880ffbc92c --- /dev/null +++ b/tests/baselines/reference/restTupleElements1.symbols @@ -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(): 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(); +>assign : Symbol(assign, Decl(restTupleElements1.ts, 14, 25)) + +assign(); +>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(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, --, --)) + diff --git a/tests/baselines/reference/restTupleElements1.types b/tests/baselines/reference/restTupleElements1.types new file mode 100644 index 00000000000..bf749b14740 --- /dev/null +++ b/tests/baselines/reference/restTupleElements1.types @@ -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(): void; +>assign : () => void +>T : T +>S : S +>T : T + +assign(); +>assign() : void +>assign : () => void + +assign(); +>assign() : void +>assign : () => void + +assign<[...number[]], number[]>(); +>assign<[...number[]], number[]>() : void +>assign : () => void + +assign<[number, ...number[]], number[]>(); // Error +>assign<[number, ...number[]], number[]>() : any +>assign : () => void + +assign<[number, ...number[]], []>(); // Error +>assign<[number, ...number[]], []>() : any +>assign : () => void + +assign<[number, ...number[]], [number]>(); +>assign<[number, ...number[]], [number]>() : void +>assign : () => void + +assign<[number, ...number[]], [number, number]>(); +>assign<[number, ...number[]], [number, number]>() : void +>assign : () => void + +assign<[number, ...number[]], [number, number, ...number[]]>(); +>assign<[number, ...number[]], [number, number, ...number[]]>() : void +>assign : () => void + +assign<[number], [...number[]]>(); // Error +>assign<[number], [...number[]]>() : any +>assign : () => void + +assign<[number], [number, ...number[]]>(); // Error +>assign<[number], [number, ...number[]]>() : any +>assign : () => void + +assign<[number, ...number[]], [number, ...string[]]>(); // Error +>assign<[number, ...number[]], [number, ...string[]]>() : any +>assign : () => void + +assign<[number, ...number[]], [string, ...number[]]>(); // Error +>assign<[number, ...number[]], [string, ...number[]]>() : any +>assign : () => void + +assign<[number, ...number[]], [number, number, string]>(); // Error +>assign<[number, ...number[]], [number, number, string]>() : any +>assign : () => void + +assign<[number, ...number[]], [number, number, number, string]>(); // Error +>assign<[number, ...number[]], [number, number, number, string]>() : any +>assign : () => 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(x: [T, ...U[]]): [T, U]; +>f0 : (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 : (x: [T, ...U[]]) => [T, U] +>[] : never[] + +f0([1]); +>f0([1]) : [number, {}] +>f0 : (x: [T, ...U[]]) => [T, U] +>[1] : [number] +>1 : 1 + +f0([1, 2, 3]); +>f0([1, 2, 3]) : [number, number] +>f0 : (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 : (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 +