microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-17 01:55:50 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Accept new baselines

Browse Source
This commit is contained in:
Anders Hejlsberg 2018-06-14 13:06:48 -07:00
parent 0cc0fad381
commit 09f17bcf57
8 changed files with 2750 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
tests/baselines/reference/genericRestParameters1.errors.txt Normal file
View File

@ -0,0 +1,164 @@
tests/cases/conformance/types/rest/genericRestParameters1.ts(22,1): error TS2556: Expected 3 arguments, but got 1 or more.
tests/cases/conformance/types/rest/genericRestParameters1.ts(31,1): error TS2556: Expected 3 arguments, but got 1 or more.
==== tests/cases/conformance/types/rest/genericRestParameters1.ts (2 errors) ====
declare let f1: (...x: [number, string, boolean]) => void;
declare let f2: (x0: number, x1: string, x2: boolean) => void;
f1 = f2;
f2 = f1;
declare const t3: [number, string, boolean];
declare const t2: [string, boolean];
declare const t1: [boolean];
declare const t0: [];
declare const ns: [number, string];
declare const sn: [string, number];
f1(42, "hello", true);
f1(t3[0], t3[1], t3[2]);
f1(...t3);
f1(42, ...t2);
f1(42, "hello", ...t1);
f1(42, "hello", true, ...t0);
f1(ns[0], ns[1], true);
f1(...ns, true); // Error, tuple spread only expanded when last
~~~~~~~~~~~~~~~
!!! error TS2556: Expected 3 arguments, but got 1 or more.
f2(42, "hello", true);
f2(t3[0], t3[1], t3[2]);
f2(...t3);
f2(42, ...t2);
f2(42, "hello", ...t1);
f2(42, "hello", true, ...t0);
f2(ns[0], ns[1], true);
f2(...ns, true); // Error, tuple spread only expanded when last
~~~~~~~~~~~~~~~
!!! error TS2556: Expected 3 arguments, but got 1 or more.
declare function f10<T extends unknown[]>(...args: T): T;
const x10 = f10(42, "hello", true); // [number, string, boolean]
const x11 = f10(42, "hello"); // [number, string]
const x12 = f10(42); // [number]
const x13 = f10(); // []
const x14 = f10(...t3); // [number, string, boolean]
const x15 = f10(42, ...t2); // [number, string, boolean]
const x16 = f10(42, "hello", ...t1); // [number, string, boolean]
const x17 = f10(42, "hello", true, ...t0); // [number, string, boolean]
const x18 = f10(...ns, true); // (string | number | boolean)[]
function g10<U extends string[], V extends [number, number]>(u: U, v: V) {
let x1 = f10(...u); // U
let x2 = f10(...v); // V
let x3 = f10(1, ...u); // (string | number)[]
let x4 = f10(...u, ...v); // (string | number)[]
}
declare function f11<T extends (string | number | boolean)[]>(...args: T): T;
const z10 = f11(42, "hello", true); // [42, "hello", true]
const z11 = f11(42, "hello"); // [42, "hello"]
const z12 = f11(42); // [42]
const z13 = f11(); // []
const z14 = f11(...t3); // [number, string, boolean]
const z15 = f11(42, ...t2); // [42, string, boolean]
const z16 = f11(42, "hello", ...t1); // [42, "hello", boolean]
const z17 = f11(42, "hello", true, ...t0); // [42, "hello", true]
const z18 = f11(...ns, true); // (string | number | true)[]
function g11<U extends string[], V extends [number, number]>(u: U, v: V) {
let x1 = f11(...u); // U
let x2 = f11(...v); // V
let x3 = f11(1, ...u); // (string | 1)[]
let x4 = f11(...u, ...v); // (string | number)[]
}
function call<T extends unknown[], U>(f: (...args: T) => U, ...args: T) {
return f(...args);
}
function callr<T extends unknown[], U>(args: T, f: (...args: T) => U) {
return f(...args);
}
declare function f15(a: string, b: number): string | number;
declare function f16<A, B>(a: A, b: B): A | B;
let x20 = call((x, y) => x + y, 10, 20); // number
let x21 = call((x, y) => x + y, 10, "hello"); // string
let x22 = call(f15, "hello", 42); // string | number
let x23 = call(f16, "hello", 42); // unknown
let x24 = call<[string, number], string | number>(f16, "hello", 42); // string | number
let x30 = callr(sn, (x, y) => x + y); // string
let x31 = callr(sn, f15); // string | number
let x32 = callr(sn, f16); // string | number
function bind<T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) {
return (...rest: U) => f(x, ...rest);
}
declare const f20: (x: number, y: string, z: boolean) => string[];
const f21 = bind(f20, 42); // (y: string, z: boolean) => string[]
const f22 = bind(f21, "hello"); // (z: boolean) => string[]
const f23 = bind(f22, true); // () => string[]
f20(42, "hello", true);
f21("hello", true);
f22(true);
f23();
declare const g20: (x: number, y?: string, z?: boolean) => string[];
const g21 = bind(g20, 42); // (y: string, z: boolean) => string[]
const g22 = bind(g21, "hello"); // (z: boolean) => string[]
const g23 = bind(g22, true); // () => string[]
g20(42, "hello", true);
g20(42, "hello");
g20(42);
g21("hello", true);
g21("hello");
g21();
g22(true);
g22();
g23();
declare function f30<T, U extends ((x: T) => any)[]>(x: T, ...args: U): U;
const c30 = f30(42, x => "" + x, x => x + 1); // [(x: number) => string, (x: number) => number]
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> = Parameters<(...args: T[]) => void>;
type T06<T> = Parameters<new (...args: []) => void>;
type T07<T extends any[]> = Parameters<(...args: T) => void>;
type T08<T extends any[]> = Parameters<new (...args: T) => void>;
type T09 = Parameters<Function>;
type Record1 = {
move: [number, 'left' | 'right'];
jump: [number, 'up' | 'down'];
stop: string;
done: [];
}
type EventType<T> = {
emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void;
}
declare var events: EventType<Record1>;
events.emit('move', 10, 'left');
events.emit('jump', 20, 'up');
events.emit('stop', 'Bye!');
events.emit('done');

334
tests/baselines/reference/genericRestParameters1.js Normal file
View File

@ -0,0 +1,334 @@
//// [genericRestParameters1.ts]
declare let f1: (...x: [number, string, boolean]) => void;
declare let f2: (x0: number, x1: string, x2: boolean) => void;
f1 = f2;
f2 = f1;
declare const t3: [number, string, boolean];
declare const t2: [string, boolean];
declare const t1: [boolean];
declare const t0: [];
declare const ns: [number, string];
declare const sn: [string, number];
f1(42, "hello", true);
f1(t3[0], t3[1], t3[2]);
f1(...t3);
f1(42, ...t2);
f1(42, "hello", ...t1);
f1(42, "hello", true, ...t0);
f1(ns[0], ns[1], true);
f1(...ns, true); // Error, tuple spread only expanded when last
f2(42, "hello", true);
f2(t3[0], t3[1], t3[2]);
f2(...t3);
f2(42, ...t2);
f2(42, "hello", ...t1);
f2(42, "hello", true, ...t0);
f2(ns[0], ns[1], true);
f2(...ns, true); // Error, tuple spread only expanded when last
declare function f10<T extends unknown[]>(...args: T): T;
const x10 = f10(42, "hello", true); // [number, string, boolean]
const x11 = f10(42, "hello"); // [number, string]
const x12 = f10(42); // [number]
const x13 = f10(); // []
const x14 = f10(...t3); // [number, string, boolean]
const x15 = f10(42, ...t2); // [number, string, boolean]
const x16 = f10(42, "hello", ...t1); // [number, string, boolean]
const x17 = f10(42, "hello", true, ...t0); // [number, string, boolean]
const x18 = f10(...ns, true); // (string | number | boolean)[]
function g10<U extends string[], V extends [number, number]>(u: U, v: V) {
let x1 = f10(...u); // U
let x2 = f10(...v); // V
let x3 = f10(1, ...u); // (string | number)[]
let x4 = f10(...u, ...v); // (string | number)[]
}
declare function f11<T extends (string | number | boolean)[]>(...args: T): T;
const z10 = f11(42, "hello", true); // [42, "hello", true]
const z11 = f11(42, "hello"); // [42, "hello"]
const z12 = f11(42); // [42]
const z13 = f11(); // []
const z14 = f11(...t3); // [number, string, boolean]
const z15 = f11(42, ...t2); // [42, string, boolean]
const z16 = f11(42, "hello", ...t1); // [42, "hello", boolean]
const z17 = f11(42, "hello", true, ...t0); // [42, "hello", true]
const z18 = f11(...ns, true); // (string | number | true)[]
function g11<U extends string[], V extends [number, number]>(u: U, v: V) {
let x1 = f11(...u); // U
let x2 = f11(...v); // V
let x3 = f11(1, ...u); // (string | 1)[]
let x4 = f11(...u, ...v); // (string | number)[]
}
function call<T extends unknown[], U>(f: (...args: T) => U, ...args: T) {
return f(...args);
}
function callr<T extends unknown[], U>(args: T, f: (...args: T) => U) {
return f(...args);
}
declare function f15(a: string, b: number): string | number;
declare function f16<A, B>(a: A, b: B): A | B;
let x20 = call((x, y) => x + y, 10, 20); // number
let x21 = call((x, y) => x + y, 10, "hello"); // string
let x22 = call(f15, "hello", 42); // string | number
let x23 = call(f16, "hello", 42); // unknown
let x24 = call<[string, number], string | number>(f16, "hello", 42); // string | number
let x30 = callr(sn, (x, y) => x + y); // string
let x31 = callr(sn, f15); // string | number
let x32 = callr(sn, f16); // string | number
function bind<T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) {
return (...rest: U) => f(x, ...rest);
}
declare const f20: (x: number, y: string, z: boolean) => string[];
const f21 = bind(f20, 42); // (y: string, z: boolean) => string[]
const f22 = bind(f21, "hello"); // (z: boolean) => string[]
const f23 = bind(f22, true); // () => string[]
f20(42, "hello", true);
f21("hello", true);
f22(true);
f23();
declare const g20: (x: number, y?: string, z?: boolean) => string[];
const g21 = bind(g20, 42); // (y: string, z: boolean) => string[]
const g22 = bind(g21, "hello"); // (z: boolean) => string[]
const g23 = bind(g22, true); // () => string[]
g20(42, "hello", true);
g20(42, "hello");
g20(42);
g21("hello", true);
g21("hello");
g21();
g22(true);
g22();
g23();
declare function f30<T, U extends ((x: T) => any)[]>(x: T, ...args: U): U;
const c30 = f30(42, x => "" + x, x => x + 1); // [(x: number) => string, (x: number) => number]
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> = Parameters<(...args: T[]) => void>;
type T06<T> = Parameters<new (...args: []) => void>;
type T07<T extends any[]> = Parameters<(...args: T) => void>;
type T08<T extends any[]> = Parameters<new (...args: T) => void>;
type T09 = Parameters<Function>;
type Record1 = {
move: [number, 'left' | 'right'];
jump: [number, 'up' | 'down'];
stop: string;
done: [];
}
type EventType<T> = {
emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void;
}
declare var events: EventType<Record1>;
events.emit('move', 10, 'left');
events.emit('jump', 20, 'up');
events.emit('stop', 'Bye!');
events.emit('done');
//// [genericRestParameters1.js]
"use strict";
f1 = f2;
f2 = f1;
f1(42, "hello", true);
f1(t3[0], t3[1], t3[2]);
f1.apply(void 0, t3);
f1.apply(void 0, [42].concat(t2));
f1.apply(void 0, [42, "hello"].concat(t1));
f1.apply(void 0, [42, "hello", true].concat(t0));
f1(ns[0], ns[1], true);
f1.apply(void 0, ns.concat([true])); // Error, tuple spread only expanded when last
f2(42, "hello", true);
f2(t3[0], t3[1], t3[2]);
f2.apply(void 0, t3);
f2.apply(void 0, [42].concat(t2));
f2.apply(void 0, [42, "hello"].concat(t1));
f2.apply(void 0, [42, "hello", true].concat(t0));
f2(ns[0], ns[1], true);
f2.apply(void 0, ns.concat([true])); // Error, tuple spread only expanded when last
var x10 = f10(42, "hello", true); // [number, string, boolean]
var x11 = f10(42, "hello"); // [number, string]
var x12 = f10(42); // [number]
var x13 = f10(); // []
var x14 = f10.apply(void 0, t3); // [number, string, boolean]
var x15 = f10.apply(void 0, [42].concat(t2)); // [number, string, boolean]
var x16 = f10.apply(void 0, [42, "hello"].concat(t1)); // [number, string, boolean]
var x17 = f10.apply(void 0, [42, "hello", true].concat(t0)); // [number, string, boolean]
var x18 = f10.apply(void 0, ns.concat([true])); // (string | number | boolean)[]
function g10(u, v) {
var x1 = f10.apply(void 0, u); // U
var x2 = f10.apply(void 0, v); // V
var x3 = f10.apply(void 0, [1].concat(u)); // (string | number)[]
var x4 = f10.apply(void 0, u.concat(v)); // (string | number)[]
}
var z10 = f11(42, "hello", true); // [42, "hello", true]
var z11 = f11(42, "hello"); // [42, "hello"]
var z12 = f11(42); // [42]
var z13 = f11(); // []
var z14 = f11.apply(void 0, t3); // [number, string, boolean]
var z15 = f11.apply(void 0, [42].concat(t2)); // [42, string, boolean]
var z16 = f11.apply(void 0, [42, "hello"].concat(t1)); // [42, "hello", boolean]
var z17 = f11.apply(void 0, [42, "hello", true].concat(t0)); // [42, "hello", true]
var z18 = f11.apply(void 0, ns.concat([true])); // (string | number | true)[]
function g11(u, v) {
var x1 = f11.apply(void 0, u); // U
var x2 = f11.apply(void 0, v); // V
var x3 = f11.apply(void 0, [1].concat(u)); // (string | 1)[]
var x4 = f11.apply(void 0, u.concat(v)); // (string | number)[]
}
function call(f) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
return f.apply(void 0, args);
}
function callr(args, f) {
return f.apply(void 0, args);
}
var x20 = call(function (x, y) { return x + y; }, 10, 20); // number
var x21 = call(function (x, y) { return x + y; }, 10, "hello"); // string
var x22 = call(f15, "hello", 42); // string | number
var x23 = call(f16, "hello", 42); // unknown
var x24 = call(f16, "hello", 42); // string | number
var x30 = callr(sn, function (x, y) { return x + y; }); // string
var x31 = callr(sn, f15); // string | number
var x32 = callr(sn, f16); // string | number
function bind(f, x) {
return function () {
var rest = [];
for (var _i = 0; _i < arguments.length; _i++) {
rest[_i] = arguments[_i];
}
return f.apply(void 0, [x].concat(rest));
};
}
var f21 = bind(f20, 42); // (y: string, z: boolean) => string[]
var f22 = bind(f21, "hello"); // (z: boolean) => string[]
var f23 = bind(f22, true); // () => string[]
f20(42, "hello", true);
f21("hello", true);
f22(true);
f23();
var g21 = bind(g20, 42); // (y: string, z: boolean) => string[]
var g22 = bind(g21, "hello"); // (z: boolean) => string[]
var g23 = bind(g22, true); // () => string[]
g20(42, "hello", true);
g20(42, "hello");
g20(42);
g21("hello", true);
g21("hello");
g21();
g22(true);
g22();
g23();
var c30 = f30(42, function (x) { return "" + x; }, function (x) { return x + 1; }); // [(x: number) => string, (x: number) => number]
events.emit('move', 10, 'left');
events.emit('jump', 20, 'up');
events.emit('stop', 'Bye!');
events.emit('done');
//// [genericRestParameters1.d.ts]
declare let f1: (...x: [number, string, boolean]) => void;
declare let f2: (x0: number, x1: string, x2: boolean) => void;
declare const t3: [number, string, boolean];
declare const t2: [string, boolean];
declare const t1: [boolean];
declare const t0: [];
declare const ns: [number, string];
declare const sn: [string, number];
declare function f10<T extends unknown[]>(...args: T): T;
declare const x10: [number, string, boolean];
declare const x11: [number, string];
declare const x12: [number];
declare const x13: [];
declare const x14: [number, string, boolean];
declare const x15: [number, string, boolean];
declare const x16: [number, string, boolean];
declare const x17: [number, string, boolean];
declare const x18: (string | number | boolean)[];
declare function g10<U extends string[], V extends [number, number]>(u: U, v: V): void;
declare function f11<T extends (string | number | boolean)[]>(...args: T): T;
declare const z10: [42, "hello", true];
declare const z11: [42, "hello"];
declare const z12: [42];
declare const z13: [];
declare const z14: [number, string, boolean];
declare const z15: [42, string, boolean];
declare const z16: [42, "hello", boolean];
declare const z17: [42, "hello", true];
declare const z18: (string | number | true)[];
declare function g11<U extends string[], V extends [number, number]>(u: U, v: V): void;
declare function call<T extends unknown[], U>(f: (...args: T) => U, ...args: T): U;
declare function callr<T extends unknown[], U>(args: T, f: (...args: T) => U): U;
declare function f15(a: string, b: number): string | number;
declare function f16<A, B>(a: A, b: B): A | B;
declare let x20: number;
declare let x21: string;
declare let x22: string | number;
declare let x23: unknown;
declare let x24: string | number;
declare let x30: string;
declare let x31: string | number;
declare let x32: string | number;
declare function bind<T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T): (...rest: U) => V;
declare const f20: (x: number, y: string, z: boolean) => string[];
declare const f21: (y: string, z: boolean) => string[];
declare const f22: (z: boolean) => string[];
declare const f23: () => string[];
declare const g20: (x: number, y?: string, z?: boolean) => string[];
declare const g21: (y?: string | undefined, z?: boolean | undefined) => string[];
declare const g22: (z?: boolean | undefined) => string[];
declare const g23: () => string[];
declare function f30<T, U extends ((x: T) => any)[]>(x: T, ...args: U): U;
declare const c30: [(x: number) => string, (x: number) => number];
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> = Parameters<(...args: T[]) => void>;
declare type T06<T> = Parameters<new (...args: []) => void>;
declare type T07<T extends any[]> = Parameters<(...args: T) => void>;
declare type T08<T extends any[]> = Parameters<new (...args: T) => void>;
declare type T09 = Parameters<Function>;
declare type Record1 = {
move: [number, 'left' | 'right'];
jump: [number, 'up' | 'down'];
stop: string;
done: [];
};
declare type EventType<T> = {
emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void;
};
declare var events: EventType<Record1>;

624
tests/baselines/reference/genericRestParameters1.symbols Normal file
View File

@ -0,0 +1,624 @@
=== tests/cases/conformance/types/rest/genericRestParameters1.ts ===
declare let f1: (...x: [number, string, boolean]) => void;
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>x : Symbol(x, Decl(genericRestParameters1.ts, 0, 17))
declare let f2: (x0: number, x1: string, x2: boolean) => void;
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>x0 : Symbol(x0, Decl(genericRestParameters1.ts, 1, 17))
>x1 : Symbol(x1, Decl(genericRestParameters1.ts, 1, 28))
>x2 : Symbol(x2, Decl(genericRestParameters1.ts, 1, 40))
f1 = f2;
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
f2 = f1;
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
declare const t3: [number, string, boolean];
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
declare const t2: [string, boolean];
>t2 : Symbol(t2, Decl(genericRestParameters1.ts, 7, 13))
declare const t1: [boolean];
>t1 : Symbol(t1, Decl(genericRestParameters1.ts, 8, 13))
declare const t0: [];
>t0 : Symbol(t0, Decl(genericRestParameters1.ts, 9, 13))
declare const ns: [number, string];
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
declare const sn: [string, number];
>sn : Symbol(sn, Decl(genericRestParameters1.ts, 12, 13))
f1(42, "hello", true);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
f1(t3[0], t3[1], t3[2]);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>0 : Symbol(0)
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>1 : Symbol(1)
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>2 : Symbol(2)
f1(...t3);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
f1(42, ...t2);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>t2 : Symbol(t2, Decl(genericRestParameters1.ts, 7, 13))
f1(42, "hello", ...t1);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>t1 : Symbol(t1, Decl(genericRestParameters1.ts, 8, 13))
f1(42, "hello", true, ...t0);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>t0 : Symbol(t0, Decl(genericRestParameters1.ts, 9, 13))
f1(ns[0], ns[1], true);
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
>0 : Symbol(0)
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
>1 : Symbol(1)
f1(...ns, true); // Error, tuple spread only expanded when last
>f1 : Symbol(f1, Decl(genericRestParameters1.ts, 0, 11))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
f2(42, "hello", true);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
f2(t3[0], t3[1], t3[2]);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>0 : Symbol(0)
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>1 : Symbol(1)
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
>2 : Symbol(2)
f2(...t3);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
f2(42, ...t2);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>t2 : Symbol(t2, Decl(genericRestParameters1.ts, 7, 13))
f2(42, "hello", ...t1);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>t1 : Symbol(t1, Decl(genericRestParameters1.ts, 8, 13))
f2(42, "hello", true, ...t0);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>t0 : Symbol(t0, Decl(genericRestParameters1.ts, 9, 13))
f2(ns[0], ns[1], true);
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
>0 : Symbol(0)
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
>1 : Symbol(1)
f2(...ns, true); // Error, tuple spread only expanded when last
>f2 : Symbol(f2, Decl(genericRestParameters1.ts, 1, 11))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
declare function f10<T extends unknown[]>(...args: T): T;
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>T : Symbol(T, Decl(genericRestParameters1.ts, 32, 21))
>args : Symbol(args, Decl(genericRestParameters1.ts, 32, 42))
>T : Symbol(T, Decl(genericRestParameters1.ts, 32, 21))
>T : Symbol(T, Decl(genericRestParameters1.ts, 32, 21))
const x10 = f10(42, "hello", true); // [number, string, boolean]
>x10 : Symbol(x10, Decl(genericRestParameters1.ts, 34, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
const x11 = f10(42, "hello"); // [number, string]
>x11 : Symbol(x11, Decl(genericRestParameters1.ts, 35, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
const x12 = f10(42); // [number]
>x12 : Symbol(x12, Decl(genericRestParameters1.ts, 36, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
const x13 = f10(); // []
>x13 : Symbol(x13, Decl(genericRestParameters1.ts, 37, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
const x14 = f10(...t3); // [number, string, boolean]
>x14 : Symbol(x14, Decl(genericRestParameters1.ts, 38, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
const x15 = f10(42, ...t2); // [number, string, boolean]
>x15 : Symbol(x15, Decl(genericRestParameters1.ts, 39, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>t2 : Symbol(t2, Decl(genericRestParameters1.ts, 7, 13))
const x16 = f10(42, "hello", ...t1); // [number, string, boolean]
>x16 : Symbol(x16, Decl(genericRestParameters1.ts, 40, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>t1 : Symbol(t1, Decl(genericRestParameters1.ts, 8, 13))
const x17 = f10(42, "hello", true, ...t0); // [number, string, boolean]
>x17 : Symbol(x17, Decl(genericRestParameters1.ts, 41, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>t0 : Symbol(t0, Decl(genericRestParameters1.ts, 9, 13))
const x18 = f10(...ns, true); // (string | number | boolean)[]
>x18 : Symbol(x18, Decl(genericRestParameters1.ts, 42, 5))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
function g10<U extends string[], V extends [number, number]>(u: U, v: V) {
>g10 : Symbol(g10, Decl(genericRestParameters1.ts, 42, 29))
>U : Symbol(U, Decl(genericRestParameters1.ts, 44, 13))
>V : Symbol(V, Decl(genericRestParameters1.ts, 44, 32))
>u : Symbol(u, Decl(genericRestParameters1.ts, 44, 61))
>U : Symbol(U, Decl(genericRestParameters1.ts, 44, 13))
>v : Symbol(v, Decl(genericRestParameters1.ts, 44, 66))
>V : Symbol(V, Decl(genericRestParameters1.ts, 44, 32))
let x1 = f10(...u); // U
>x1 : Symbol(x1, Decl(genericRestParameters1.ts, 45, 7))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>u : Symbol(u, Decl(genericRestParameters1.ts, 44, 61))
let x2 = f10(...v); // V
>x2 : Symbol(x2, Decl(genericRestParameters1.ts, 46, 7))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>v : Symbol(v, Decl(genericRestParameters1.ts, 44, 66))
let x3 = f10(1, ...u); // (string | number)[]
>x3 : Symbol(x3, Decl(genericRestParameters1.ts, 47, 7))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>u : Symbol(u, Decl(genericRestParameters1.ts, 44, 61))
let x4 = f10(...u, ...v); // (string | number)[]
>x4 : Symbol(x4, Decl(genericRestParameters1.ts, 48, 7))
>f10 : Symbol(f10, Decl(genericRestParameters1.ts, 30, 16))
>u : Symbol(u, Decl(genericRestParameters1.ts, 44, 61))
>v : Symbol(v, Decl(genericRestParameters1.ts, 44, 66))
}
declare function f11<T extends (string | number | boolean)[]>(...args: T): T;
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>T : Symbol(T, Decl(genericRestParameters1.ts, 51, 21))
>args : Symbol(args, Decl(genericRestParameters1.ts, 51, 62))
>T : Symbol(T, Decl(genericRestParameters1.ts, 51, 21))
>T : Symbol(T, Decl(genericRestParameters1.ts, 51, 21))
const z10 = f11(42, "hello", true); // [42, "hello", true]
>z10 : Symbol(z10, Decl(genericRestParameters1.ts, 53, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
const z11 = f11(42, "hello"); // [42, "hello"]
>z11 : Symbol(z11, Decl(genericRestParameters1.ts, 54, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
const z12 = f11(42); // [42]
>z12 : Symbol(z12, Decl(genericRestParameters1.ts, 55, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
const z13 = f11(); // []
>z13 : Symbol(z13, Decl(genericRestParameters1.ts, 56, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
const z14 = f11(...t3); // [number, string, boolean]
>z14 : Symbol(z14, Decl(genericRestParameters1.ts, 57, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>t3 : Symbol(t3, Decl(genericRestParameters1.ts, 6, 13))
const z15 = f11(42, ...t2); // [42, string, boolean]
>z15 : Symbol(z15, Decl(genericRestParameters1.ts, 58, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>t2 : Symbol(t2, Decl(genericRestParameters1.ts, 7, 13))
const z16 = f11(42, "hello", ...t1); // [42, "hello", boolean]
>z16 : Symbol(z16, Decl(genericRestParameters1.ts, 59, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>t1 : Symbol(t1, Decl(genericRestParameters1.ts, 8, 13))
const z17 = f11(42, "hello", true, ...t0); // [42, "hello", true]
>z17 : Symbol(z17, Decl(genericRestParameters1.ts, 60, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>t0 : Symbol(t0, Decl(genericRestParameters1.ts, 9, 13))
const z18 = f11(...ns, true); // (string | number | true)[]
>z18 : Symbol(z18, Decl(genericRestParameters1.ts, 61, 5))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>ns : Symbol(ns, Decl(genericRestParameters1.ts, 11, 13))
function g11<U extends string[], V extends [number, number]>(u: U, v: V) {
>g11 : Symbol(g11, Decl(genericRestParameters1.ts, 61, 29))
>U : Symbol(U, Decl(genericRestParameters1.ts, 63, 13))
>V : Symbol(V, Decl(genericRestParameters1.ts, 63, 32))
>u : Symbol(u, Decl(genericRestParameters1.ts, 63, 61))
>U : Symbol(U, Decl(genericRestParameters1.ts, 63, 13))
>v : Symbol(v, Decl(genericRestParameters1.ts, 63, 66))
>V : Symbol(V, Decl(genericRestParameters1.ts, 63, 32))
let x1 = f11(...u); // U
>x1 : Symbol(x1, Decl(genericRestParameters1.ts, 64, 7))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>u : Symbol(u, Decl(genericRestParameters1.ts, 63, 61))
let x2 = f11(...v); // V
>x2 : Symbol(x2, Decl(genericRestParameters1.ts, 65, 7))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>v : Symbol(v, Decl(genericRestParameters1.ts, 63, 66))
let x3 = f11(1, ...u); // (string | 1)[]
>x3 : Symbol(x3, Decl(genericRestParameters1.ts, 66, 7))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>u : Symbol(u, Decl(genericRestParameters1.ts, 63, 61))
let x4 = f11(...u, ...v); // (string | number)[]
>x4 : Symbol(x4, Decl(genericRestParameters1.ts, 67, 7))
>f11 : Symbol(f11, Decl(genericRestParameters1.ts, 49, 1))
>u : Symbol(u, Decl(genericRestParameters1.ts, 63, 61))
>v : Symbol(v, Decl(genericRestParameters1.ts, 63, 66))
}
function call<T extends unknown[], U>(f: (...args: T) => U, ...args: T) {
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>T : Symbol(T, Decl(genericRestParameters1.ts, 70, 14))
>U : Symbol(U, Decl(genericRestParameters1.ts, 70, 34))
>f : Symbol(f, Decl(genericRestParameters1.ts, 70, 38))
>args : Symbol(args, Decl(genericRestParameters1.ts, 70, 42))
>T : Symbol(T, Decl(genericRestParameters1.ts, 70, 14))
>U : Symbol(U, Decl(genericRestParameters1.ts, 70, 34))
>args : Symbol(args, Decl(genericRestParameters1.ts, 70, 59))
>T : Symbol(T, Decl(genericRestParameters1.ts, 70, 14))
return f(...args);
>f : Symbol(f, Decl(genericRestParameters1.ts, 70, 38))
>args : Symbol(args, Decl(genericRestParameters1.ts, 70, 59))
}
function callr<T extends unknown[], U>(args: T, f: (...args: T) => U) {
>callr : Symbol(callr, Decl(genericRestParameters1.ts, 72, 1))
>T : Symbol(T, Decl(genericRestParameters1.ts, 74, 15))
>U : Symbol(U, Decl(genericRestParameters1.ts, 74, 35))
>args : Symbol(args, Decl(genericRestParameters1.ts, 74, 39))
>T : Symbol(T, Decl(genericRestParameters1.ts, 74, 15))
>f : Symbol(f, Decl(genericRestParameters1.ts, 74, 47))
>args : Symbol(args, Decl(genericRestParameters1.ts, 74, 52))
>T : Symbol(T, Decl(genericRestParameters1.ts, 74, 15))
>U : Symbol(U, Decl(genericRestParameters1.ts, 74, 35))
return f(...args);
>f : Symbol(f, Decl(genericRestParameters1.ts, 74, 47))
>args : Symbol(args, Decl(genericRestParameters1.ts, 74, 39))
}
declare function f15(a: string, b: number): string | number;
>f15 : Symbol(f15, Decl(genericRestParameters1.ts, 76, 1))
>a : Symbol(a, Decl(genericRestParameters1.ts, 78, 21))
>b : Symbol(b, Decl(genericRestParameters1.ts, 78, 31))
declare function f16<A, B>(a: A, b: B): A | B;
>f16 : Symbol(f16, Decl(genericRestParameters1.ts, 78, 60))
>A : Symbol(A, Decl(genericRestParameters1.ts, 79, 21))
>B : Symbol(B, Decl(genericRestParameters1.ts, 79, 23))
>a : Symbol(a, Decl(genericRestParameters1.ts, 79, 27))
>A : Symbol(A, Decl(genericRestParameters1.ts, 79, 21))
>b : Symbol(b, Decl(genericRestParameters1.ts, 79, 32))
>B : Symbol(B, Decl(genericRestParameters1.ts, 79, 23))
>A : Symbol(A, Decl(genericRestParameters1.ts, 79, 21))
>B : Symbol(B, Decl(genericRestParameters1.ts, 79, 23))
let x20 = call((x, y) => x + y, 10, 20); // number
>x20 : Symbol(x20, Decl(genericRestParameters1.ts, 81, 3))
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>x : Symbol(x, Decl(genericRestParameters1.ts, 81, 16))
>y : Symbol(y, Decl(genericRestParameters1.ts, 81, 18))
>x : Symbol(x, Decl(genericRestParameters1.ts, 81, 16))
>y : Symbol(y, Decl(genericRestParameters1.ts, 81, 18))
let x21 = call((x, y) => x + y, 10, "hello"); // string
>x21 : Symbol(x21, Decl(genericRestParameters1.ts, 82, 3))
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>x : Symbol(x, Decl(genericRestParameters1.ts, 82, 16))
>y : Symbol(y, Decl(genericRestParameters1.ts, 82, 18))
>x : Symbol(x, Decl(genericRestParameters1.ts, 82, 16))
>y : Symbol(y, Decl(genericRestParameters1.ts, 82, 18))
let x22 = call(f15, "hello", 42); // string | number
>x22 : Symbol(x22, Decl(genericRestParameters1.ts, 83, 3))
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>f15 : Symbol(f15, Decl(genericRestParameters1.ts, 76, 1))
let x23 = call(f16, "hello", 42); // unknown
>x23 : Symbol(x23, Decl(genericRestParameters1.ts, 84, 3))
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>f16 : Symbol(f16, Decl(genericRestParameters1.ts, 78, 60))
let x24 = call<[string, number], string | number>(f16, "hello", 42); // string | number
>x24 : Symbol(x24, Decl(genericRestParameters1.ts, 85, 3))
>call : Symbol(call, Decl(genericRestParameters1.ts, 68, 1))
>f16 : Symbol(f16, Decl(genericRestParameters1.ts, 78, 60))
let x30 = callr(sn, (x, y) => x + y); // string
>x30 : Symbol(x30, Decl(genericRestParameters1.ts, 87, 3))
>callr : Symbol(callr, Decl(genericRestParameters1.ts, 72, 1))
>sn : Symbol(sn, Decl(genericRestParameters1.ts, 12, 13))
>x : Symbol(x, Decl(genericRestParameters1.ts, 87, 21))
>y : Symbol(y, Decl(genericRestParameters1.ts, 87, 23))
>x : Symbol(x, Decl(genericRestParameters1.ts, 87, 21))
>y : Symbol(y, Decl(genericRestParameters1.ts, 87, 23))
let x31 = callr(sn, f15); // string | number
>x31 : Symbol(x31, Decl(genericRestParameters1.ts, 88, 3))
>callr : Symbol(callr, Decl(genericRestParameters1.ts, 72, 1))
>sn : Symbol(sn, Decl(genericRestParameters1.ts, 12, 13))
>f15 : Symbol(f15, Decl(genericRestParameters1.ts, 76, 1))
let x32 = callr(sn, f16); // string | number
>x32 : Symbol(x32, Decl(genericRestParameters1.ts, 89, 3))
>callr : Symbol(callr, Decl(genericRestParameters1.ts, 72, 1))
>sn : Symbol(sn, Decl(genericRestParameters1.ts, 12, 13))
>f16 : Symbol(f16, Decl(genericRestParameters1.ts, 78, 60))
function bind<T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) {
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>T : Symbol(T, Decl(genericRestParameters1.ts, 91, 14))
>U : Symbol(U, Decl(genericRestParameters1.ts, 91, 16))
>V : Symbol(V, Decl(genericRestParameters1.ts, 91, 37))
>f : Symbol(f, Decl(genericRestParameters1.ts, 91, 41))
>x : Symbol(x, Decl(genericRestParameters1.ts, 91, 45))
>T : Symbol(T, Decl(genericRestParameters1.ts, 91, 14))
>rest : Symbol(rest, Decl(genericRestParameters1.ts, 91, 50))
>U : Symbol(U, Decl(genericRestParameters1.ts, 91, 16))
>V : Symbol(V, Decl(genericRestParameters1.ts, 91, 37))
>x : Symbol(x, Decl(genericRestParameters1.ts, 91, 68))
>T : Symbol(T, Decl(genericRestParameters1.ts, 91, 14))
return (...rest: U) => f(x, ...rest);
>rest : Symbol(rest, Decl(genericRestParameters1.ts, 92, 12))
>U : Symbol(U, Decl(genericRestParameters1.ts, 91, 16))
>f : Symbol(f, Decl(genericRestParameters1.ts, 91, 41))
>x : Symbol(x, Decl(genericRestParameters1.ts, 91, 68))
>rest : Symbol(rest, Decl(genericRestParameters1.ts, 92, 12))
}
declare const f20: (x: number, y: string, z: boolean) => string[];
>f20 : Symbol(f20, Decl(genericRestParameters1.ts, 95, 13))
>x : Symbol(x, Decl(genericRestParameters1.ts, 95, 20))
>y : Symbol(y, Decl(genericRestParameters1.ts, 95, 30))
>z : Symbol(z, Decl(genericRestParameters1.ts, 95, 41))
const f21 = bind(f20, 42); // (y: string, z: boolean) => string[]
>f21 : Symbol(f21, Decl(genericRestParameters1.ts, 97, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>f20 : Symbol(f20, Decl(genericRestParameters1.ts, 95, 13))
const f22 = bind(f21, "hello"); // (z: boolean) => string[]
>f22 : Symbol(f22, Decl(genericRestParameters1.ts, 98, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>f21 : Symbol(f21, Decl(genericRestParameters1.ts, 97, 5))
const f23 = bind(f22, true); // () => string[]
>f23 : Symbol(f23, Decl(genericRestParameters1.ts, 99, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>f22 : Symbol(f22, Decl(genericRestParameters1.ts, 98, 5))
f20(42, "hello", true);
>f20 : Symbol(f20, Decl(genericRestParameters1.ts, 95, 13))
f21("hello", true);
>f21 : Symbol(f21, Decl(genericRestParameters1.ts, 97, 5))
f22(true);
>f22 : Symbol(f22, Decl(genericRestParameters1.ts, 98, 5))
f23();
>f23 : Symbol(f23, Decl(genericRestParameters1.ts, 99, 5))
declare const g20: (x: number, y?: string, z?: boolean) => string[];
>g20 : Symbol(g20, Decl(genericRestParameters1.ts, 106, 13))
>x : Symbol(x, Decl(genericRestParameters1.ts, 106, 20))
>y : Symbol(y, Decl(genericRestParameters1.ts, 106, 30))
>z : Symbol(z, Decl(genericRestParameters1.ts, 106, 42))
const g21 = bind(g20, 42); // (y: string, z: boolean) => string[]
>g21 : Symbol(g21, Decl(genericRestParameters1.ts, 108, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>g20 : Symbol(g20, Decl(genericRestParameters1.ts, 106, 13))
const g22 = bind(g21, "hello"); // (z: boolean) => string[]
>g22 : Symbol(g22, Decl(genericRestParameters1.ts, 109, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>g21 : Symbol(g21, Decl(genericRestParameters1.ts, 108, 5))
const g23 = bind(g22, true); // () => string[]
>g23 : Symbol(g23, Decl(genericRestParameters1.ts, 110, 5))
>bind : Symbol(bind, Decl(genericRestParameters1.ts, 89, 25))
>g22 : Symbol(g22, Decl(genericRestParameters1.ts, 109, 5))
g20(42, "hello", true);
>g20 : Symbol(g20, Decl(genericRestParameters1.ts, 106, 13))
g20(42, "hello");
>g20 : Symbol(g20, Decl(genericRestParameters1.ts, 106, 13))
g20(42);
>g20 : Symbol(g20, Decl(genericRestParameters1.ts, 106, 13))
g21("hello", true);
>g21 : Symbol(g21, Decl(genericRestParameters1.ts, 108, 5))
g21("hello");
>g21 : Symbol(g21, Decl(genericRestParameters1.ts, 108, 5))
g21();
>g21 : Symbol(g21, Decl(genericRestParameters1.ts, 108, 5))
g22(true);
>g22 : Symbol(g22, Decl(genericRestParameters1.ts, 109, 5))
g22();
>g22 : Symbol(g22, Decl(genericRestParameters1.ts, 109, 5))
g23();
>g23 : Symbol(g23, Decl(genericRestParameters1.ts, 110, 5))
declare function f30<T, U extends ((x: T) => any)[]>(x: T, ...args: U): U;
>f30 : Symbol(f30, Decl(genericRestParameters1.ts, 120, 6))
>T : Symbol(T, Decl(genericRestParameters1.ts, 122, 21))
>U : Symbol(U, Decl(genericRestParameters1.ts, 122, 23))
>x : Symbol(x, Decl(genericRestParameters1.ts, 122, 36))
>T : Symbol(T, Decl(genericRestParameters1.ts, 122, 21))
>x : Symbol(x, Decl(genericRestParameters1.ts, 122, 53))
>T : Symbol(T, Decl(genericRestParameters1.ts, 122, 21))
>args : Symbol(args, Decl(genericRestParameters1.ts, 122, 58))
>U : Symbol(U, Decl(genericRestParameters1.ts, 122, 23))
>U : Symbol(U, Decl(genericRestParameters1.ts, 122, 23))
const c30 = f30(42, x => "" + x, x => x + 1); // [(x: number) => string, (x: number) => number]
>c30 : Symbol(c30, Decl(genericRestParameters1.ts, 124, 5))
>f30 : Symbol(f30, Decl(genericRestParameters1.ts, 120, 6))
>x : Symbol(x, Decl(genericRestParameters1.ts, 124, 19))
>x : Symbol(x, Decl(genericRestParameters1.ts, 124, 19))
>x : Symbol(x, Decl(genericRestParameters1.ts, 124, 32))
>x : Symbol(x, Decl(genericRestParameters1.ts, 124, 32))
type Parameters<T extends Function> = T extends ((...args: infer U) => any) | (new(...args: infer U) => any) ? U : any[];
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>T : Symbol(T, Decl(genericRestParameters1.ts, 126, 16))
>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
>T : Symbol(T, Decl(genericRestParameters1.ts, 126, 16))
>args : Symbol(args, Decl(genericRestParameters1.ts, 126, 50))
>U : Symbol(U, Decl(genericRestParameters1.ts, 126, 64), Decl(genericRestParameters1.ts, 126, 97))
>args : Symbol(args, Decl(genericRestParameters1.ts, 126, 83))
>U : Symbol(U, Decl(genericRestParameters1.ts, 126, 64), Decl(genericRestParameters1.ts, 126, 97))
>U : Symbol(U, Decl(genericRestParameters1.ts, 126, 64), Decl(genericRestParameters1.ts, 126, 97))
type T01 = Parameters<(x: number, y: string, z: boolean) => void>;
>T01 : Symbol(T01, Decl(genericRestParameters1.ts, 126, 121))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>x : Symbol(x, Decl(genericRestParameters1.ts, 128, 23))
>y : Symbol(y, Decl(genericRestParameters1.ts, 128, 33))
>z : Symbol(z, Decl(genericRestParameters1.ts, 128, 44))
type T02 = Parameters<(...args: [number, string, boolean]) => void>;
>T02 : Symbol(T02, Decl(genericRestParameters1.ts, 128, 66))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 129, 23))
type T03 = Parameters<new (x: number, y: string, z: boolean) => void>;
>T03 : Symbol(T03, Decl(genericRestParameters1.ts, 129, 68))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>x : Symbol(x, Decl(genericRestParameters1.ts, 130, 27))
>y : Symbol(y, Decl(genericRestParameters1.ts, 130, 37))
>z : Symbol(z, Decl(genericRestParameters1.ts, 130, 48))
type T04 = Parameters<new (...args: [number, string, boolean]) => void>;
>T04 : Symbol(T04, Decl(genericRestParameters1.ts, 130, 70))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 131, 27))
type T05<T> = Parameters<(...args: T[]) => void>;
>T05 : Symbol(T05, Decl(genericRestParameters1.ts, 131, 72))
>T : Symbol(T, Decl(genericRestParameters1.ts, 132, 9))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 132, 26))
>T : Symbol(T, Decl(genericRestParameters1.ts, 132, 9))
type T06<T> = Parameters<new (...args: []) => void>;
>T06 : Symbol(T06, Decl(genericRestParameters1.ts, 132, 49))
>T : Symbol(T, Decl(genericRestParameters1.ts, 133, 9))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 133, 30))
type T07<T extends any[]> = Parameters<(...args: T) => void>;
>T07 : Symbol(T07, Decl(genericRestParameters1.ts, 133, 52))
>T : Symbol(T, Decl(genericRestParameters1.ts, 134, 9))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 134, 40))
>T : Symbol(T, Decl(genericRestParameters1.ts, 134, 9))
type T08<T extends any[]> = Parameters<new (...args: T) => void>;
>T08 : Symbol(T08, Decl(genericRestParameters1.ts, 134, 61))
>T : Symbol(T, Decl(genericRestParameters1.ts, 135, 9))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>args : Symbol(args, Decl(genericRestParameters1.ts, 135, 44))
>T : Symbol(T, Decl(genericRestParameters1.ts, 135, 9))
type T09 = Parameters<Function>;
>T09 : Symbol(T09, Decl(genericRestParameters1.ts, 135, 65))
>Parameters : Symbol(Parameters, Decl(genericRestParameters1.ts, 124, 45))
>Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
type Record1 = {
>Record1 : Symbol(Record1, Decl(genericRestParameters1.ts, 136, 32))
move: [number, 'left' | 'right'];
>move : Symbol(move, Decl(genericRestParameters1.ts, 138, 16))
jump: [number, 'up' | 'down'];
>jump : Symbol(jump, Decl(genericRestParameters1.ts, 139, 35))
stop: string;
>stop : Symbol(stop, Decl(genericRestParameters1.ts, 140, 32))
done: [];
>done : Symbol(done, Decl(genericRestParameters1.ts, 141, 15))
}
type EventType<T> = {
>EventType : Symbol(EventType, Decl(genericRestParameters1.ts, 143, 1))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void;
>emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
>K : Symbol(K, Decl(genericRestParameters1.ts, 146, 7))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
>e : Symbol(e, Decl(genericRestParameters1.ts, 146, 36))
>K : Symbol(K, Decl(genericRestParameters1.ts, 146, 7))
>payload : Symbol(payload, Decl(genericRestParameters1.ts, 146, 41))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
>K : Symbol(K, Decl(genericRestParameters1.ts, 146, 7))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
>K : Symbol(K, Decl(genericRestParameters1.ts, 146, 7))
>T : Symbol(T, Decl(genericRestParameters1.ts, 145, 15))
>K : Symbol(K, Decl(genericRestParameters1.ts, 146, 7))
}
declare var events: EventType<Record1>;
>events : Symbol(events, Decl(genericRestParameters1.ts, 149, 11))
>EventType : Symbol(EventType, Decl(genericRestParameters1.ts, 143, 1))
>Record1 : Symbol(Record1, Decl(genericRestParameters1.ts, 136, 32))
events.emit('move', 10, 'left');
>events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
>events : Symbol(events, Decl(genericRestParameters1.ts, 149, 11))
>emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
events.emit('jump', 20, 'up');
>events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
>events : Symbol(events, Decl(genericRestParameters1.ts, 149, 11))
>emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
events.emit('stop', 'Bye!');
>events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
>events : Symbol(events, Decl(genericRestParameters1.ts, 149, 11))
>emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
events.emit('done');
>events.emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))
>events : Symbol(events, Decl(genericRestParameters1.ts, 149, 11))
>emit : Symbol(emit, Decl(genericRestParameters1.ts, 145, 21))

851
tests/baselines/reference/genericRestParameters1.types Normal file
View File

@ -0,0 +1,851 @@
=== tests/cases/conformance/types/rest/genericRestParameters1.ts ===
declare let f1: (...x: [number, string, boolean]) => void;
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>x : [number, string, boolean]
declare let f2: (x0: number, x1: string, x2: boolean) => void;
>f2 : (x0: number, x1: string, x2: boolean) => void
>x0 : number
>x1 : string
>x2 : boolean
f1 = f2;
>f1 = f2 : (x0: number, x1: string, x2: boolean) => void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>f2 : (x0: number, x1: string, x2: boolean) => void
f2 = f1;
>f2 = f1 : (x_0: number, x_1: string, x_2: boolean) => void
>f2 : (x0: number, x1: string, x2: boolean) => void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
declare const t3: [number, string, boolean];
>t3 : [number, string, boolean]
declare const t2: [string, boolean];
>t2 : [string, boolean]
declare const t1: [boolean];
>t1 : [boolean]
declare const t0: [];
>t0 : []
declare const ns: [number, string];
>ns : [number, string]
declare const sn: [string, number];
>sn : [string, number]
f1(42, "hello", true);
>f1(42, "hello", true) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>42 : 42
>"hello" : "hello"
>true : true
f1(t3[0], t3[1], t3[2]);
>f1(t3[0], t3[1], t3[2]) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>t3[0] : number
>t3 : [number, string, boolean]
>0 : 0
>t3[1] : string
>t3 : [number, string, boolean]
>1 : 1
>t3[2] : boolean
>t3 : [number, string, boolean]
>2 : 2
f1(...t3);
>f1(...t3) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>...t3 : string | number | boolean
>t3 : [number, string, boolean]
f1(42, ...t2);
>f1(42, ...t2) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, boolean]
f1(42, "hello", ...t1);
>f1(42, "hello", ...t1) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>42 : 42
>"hello" : "hello"
>...t1 : boolean
>t1 : [boolean]
f1(42, "hello", true, ...t0);
>f1(42, "hello", true, ...t0) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t0 : never
>t0 : []
f1(ns[0], ns[1], true);
>f1(ns[0], ns[1], true) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>ns[0] : number
>ns : [number, string]
>0 : 0
>ns[1] : string
>ns : [number, string]
>1 : 1
>true : true
f1(...ns, true); // Error, tuple spread only expanded when last
>f1(...ns, true) : void
>f1 : (x_0: number, x_1: string, x_2: boolean) => void
>...ns : string | number
>ns : [number, string]
>true : true
f2(42, "hello", true);
>f2(42, "hello", true) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>42 : 42
>"hello" : "hello"
>true : true
f2(t3[0], t3[1], t3[2]);
>f2(t3[0], t3[1], t3[2]) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>t3[0] : number
>t3 : [number, string, boolean]
>0 : 0
>t3[1] : string
>t3 : [number, string, boolean]
>1 : 1
>t3[2] : boolean
>t3 : [number, string, boolean]
>2 : 2
f2(...t3);
>f2(...t3) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>...t3 : string | number | boolean
>t3 : [number, string, boolean]
f2(42, ...t2);
>f2(42, ...t2) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>42 : 42
>...t2 : string | boolean
>t2 : [string, boolean]
f2(42, "hello", ...t1);
>f2(42, "hello", ...t1) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>42 : 42
>"hello" : "hello"
>...t1 : boolean
>t1 : [boolean]
f2(42, "hello", true, ...t0);
>f2(42, "hello", true, ...t0) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>42 : 42
>"hello" : "hello"
>true : true
>...t0 : never
>t0 : []
f2(ns[0], ns[1], true);
>f2(ns[0], ns[1], true) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>ns[0] : number
>ns : [number, string]
>0 : 0
>ns[1] : string
>ns : [number, string]
>1 : 1
>true : true
f2(...ns, true); // Error, tuple spread only expanded when last
>f2(...ns, true) : void
>f2 : (x0: number, x1: string, x2: boolean) => void
>...ns : string | number
>ns : [number, string]
>true : true
declare function f10<T extends unknown[]>(...args: T): T;
>f10 : <T extends unknown[]>(...args: T) => T
>T : T
>args : T
>T : T
>T : T
const x10 = f10(42, "hello", true); // [number, string, boolean]
>x10 : [number, string, boolean]
>f10(42, "hello", true) : [number, string, boolean]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>true : true
const x11 = f10(42, "hello"); // [number, string]
>x11 : [number, string]
>f10(42, "hello") : [number, string]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
const x12 = f10(42); // [number]
>x12 : [number]
>f10(42) : [number]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
const x13 = f10(); // []
>x13 : []
>f10() : []
>f10 : <T extends unknown[]>(...args: T) => T
const x14 = f10(...t3); // [number, string, boolean]
>x14 : [number, string, boolean]
>f10(...t3) : [number, string, boolean]
>f10 : <T extends unknown[]>(...args: T) => T
>...t3 : string | number | boolean
>t3 : [number, string, boolean]
const x15 = f10(42, ...t2); // [number, string, boolean]
>x15 : [number, string, boolean]
>f10(42, ...t2) : [number, string, boolean]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
>...t2 : string | boolean
>t2 : [string, boolean]
const x16 = f10(42, "hello", ...t1); // [number, string, boolean]
>x16 : [number, string, boolean]
>f10(42, "hello", ...t1) : [number, string, boolean]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>...t1 : boolean
>t1 : [boolean]
const x17 = f10(42, "hello", true, ...t0); // [number, string, boolean]
>x17 : [number, string, boolean]
>f10(42, "hello", true, ...t0) : [number, string, boolean]
>f10 : <T extends unknown[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>true : true
>...t0 : never
>t0 : []
const x18 = f10(...ns, true); // (string | number | boolean)[]
>x18 : (string | number | boolean)[]
>f10(...ns, true) : (string | number | boolean)[]
>f10 : <T extends unknown[]>(...args: T) => T
>...ns : string | number
>ns : [number, string]
>true : true
function g10<U extends string[], V extends [number, number]>(u: U, v: V) {
>g10 : <U extends string[], V extends [number, number]>(u: U, v: V) => void
>U : U
>V : V
>u : U
>U : U
>v : V
>V : V
let x1 = f10(...u); // U
>x1 : U
>f10(...u) : U
>f10 : <T extends unknown[]>(...args: T) => T
>...u : string
>u : U
let x2 = f10(...v); // V
>x2 : V
>f10(...v) : V
>f10 : <T extends unknown[]>(...args: T) => T
>...v : number
>v : V
let x3 = f10(1, ...u); // (string | number)[]
>x3 : (string | number)[]
>f10(1, ...u) : (string | number)[]
>f10 : <T extends unknown[]>(...args: T) => T
>1 : 1
>...u : string
>u : U
let x4 = f10(...u, ...v); // (string | number)[]
>x4 : (string | number)[]
>f10(...u, ...v) : (string | number)[]
>f10 : <T extends unknown[]>(...args: T) => T
>...u : string
>u : U
>...v : number
>v : V
}
declare function f11<T extends (string | number | boolean)[]>(...args: T): T;
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>T : T
>args : T
>T : T
>T : T
const z10 = f11(42, "hello", true); // [42, "hello", true]
>z10 : [42, "hello", true]
>f11(42, "hello", true) : [42, "hello", true]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>true : true
const z11 = f11(42, "hello"); // [42, "hello"]
>z11 : [42, "hello"]
>f11(42, "hello") : [42, "hello"]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
const z12 = f11(42); // [42]
>z12 : [42]
>f11(42) : [42]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
const z13 = f11(); // []
>z13 : []
>f11() : []
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
const z14 = f11(...t3); // [number, string, boolean]
>z14 : [number, string, boolean]
>f11(...t3) : [number, string, boolean]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>...t3 : string | number | boolean
>t3 : [number, string, boolean]
const z15 = f11(42, ...t2); // [42, string, boolean]
>z15 : [42, string, boolean]
>f11(42, ...t2) : [42, string, boolean]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
>...t2 : string | boolean
>t2 : [string, boolean]
const z16 = f11(42, "hello", ...t1); // [42, "hello", boolean]
>z16 : [42, "hello", boolean]
>f11(42, "hello", ...t1) : [42, "hello", boolean]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>...t1 : boolean
>t1 : [boolean]
const z17 = f11(42, "hello", true, ...t0); // [42, "hello", true]
>z17 : [42, "hello", true]
>f11(42, "hello", true, ...t0) : [42, "hello", true]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>42 : 42
>"hello" : "hello"
>true : true
>...t0 : never
>t0 : []
const z18 = f11(...ns, true); // (string | number | true)[]
>z18 : (string | number | true)[]
>f11(...ns, true) : (string | number | true)[]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>...ns : string | number
>ns : [number, string]
>true : true
function g11<U extends string[], V extends [number, number]>(u: U, v: V) {
>g11 : <U extends string[], V extends [number, number]>(u: U, v: V) => void
>U : U
>V : V
>u : U
>U : U
>v : V
>V : V
let x1 = f11(...u); // U
>x1 : U
>f11(...u) : U
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>...u : string
>u : U
let x2 = f11(...v); // V
>x2 : V
>f11(...v) : V
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>...v : number
>v : V
let x3 = f11(1, ...u); // (string | 1)[]
>x3 : (string | 1)[]
>f11(1, ...u) : (string | 1)[]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>1 : 1
>...u : string
>u : U
let x4 = f11(...u, ...v); // (string | number)[]
>x4 : (string | number)[]
>f11(...u, ...v) : (string | number)[]
>f11 : <T extends (string | number | boolean)[]>(...args: T) => T
>...u : string
>u : U
>...v : number
>v : V
}
function call<T extends unknown[], U>(f: (...args: T) => U, ...args: T) {
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>T : T
>U : U
>f : (...args: T) => U
>args : T
>T : T
>U : U
>args : T
>T : T
return f(...args);
>f(...args) : U
>f : (...args: T) => U
>...args : unknown
>args : T
}
function callr<T extends unknown[], U>(args: T, f: (...args: T) => U) {
>callr : <T extends unknown[], U>(args: T, f: (...args: T) => U) => U
>T : T
>U : U
>args : T
>T : T
>f : (...args: T) => U
>args : T
>T : T
>U : U
return f(...args);
>f(...args) : U
>f : (...args: T) => U
>...args : unknown
>args : T
}
declare function f15(a: string, b: number): string | number;
>f15 : (a: string, b: number) => string | number
>a : string
>b : number
declare function f16<A, B>(a: A, b: B): A | B;
>f16 : <A, B>(a: A, b: B) => A | B
>A : A
>B : B
>a : A
>A : A
>b : B
>B : B
>A : A
>B : B
let x20 = call((x, y) => x + y, 10, 20); // number
>x20 : number
>call((x, y) => x + y, 10, 20) : number
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>(x, y) => x + y : (x: number, y: number) => number
>x : number
>y : number
>x + y : number
>x : number
>y : number
>10 : 10
>20 : 20
let x21 = call((x, y) => x + y, 10, "hello"); // string
>x21 : string
>call((x, y) => x + y, 10, "hello") : string
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>(x, y) => x + y : (x: number, y: string) => string
>x : number
>y : string
>x + y : string
>x : number
>y : string
>10 : 10
>"hello" : "hello"
let x22 = call(f15, "hello", 42); // string | number
>x22 : string | number
>call(f15, "hello", 42) : string | number
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>f15 : (a: string, b: number) => string | number
>"hello" : "hello"
>42 : 42
let x23 = call(f16, "hello", 42); // unknown
>x23 : unknown
>call(f16, "hello", 42) : unknown
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>f16 : <A, B>(a: A, b: B) => A | B
>"hello" : "hello"
>42 : 42
let x24 = call<[string, number], string | number>(f16, "hello", 42); // string | number
>x24 : string | number
>call<[string, number], string | number>(f16, "hello", 42) : string | number
>call : <T extends unknown[], U>(f: (...args: T) => U, ...args: T) => U
>f16 : <A, B>(a: A, b: B) => A | B
>"hello" : "hello"
>42 : 42
let x30 = callr(sn, (x, y) => x + y); // string
>x30 : string
>callr(sn, (x, y) => x + y) : string
>callr : <T extends unknown[], U>(args: T, f: (...args: T) => U) => U
>sn : [string, number]
>(x, y) => x + y : (x: string, y: number) => string
>x : string
>y : number
>x + y : string
>x : string
>y : number
let x31 = callr(sn, f15); // string | number
>x31 : string | number
>callr(sn, f15) : string | number
>callr : <T extends unknown[], U>(args: T, f: (...args: T) => U) => U
>sn : [string, number]
>f15 : (a: string, b: number) => string | number
let x32 = callr(sn, f16); // string | number
>x32 : string | number
>callr(sn, f16) : string | number
>callr : <T extends unknown[], U>(args: T, f: (...args: T) => U) => U
>sn : [string, number]
>f16 : <A, B>(a: A, b: B) => A | B
function bind<T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) {
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>T : T
>U : U
>V : V
>f : (x: T, ...rest: U) => V
>x : T
>T : T
>rest : U
>U : U
>V : V
>x : T
>T : T
return (...rest: U) => f(x, ...rest);
>(...rest: U) => f(x, ...rest) : (...rest: U) => V
>rest : U
>U : U
>f(x, ...rest) : V
>f : (x: T, ...rest: U) => V
>x : T
>...rest : unknown
>rest : U
}
declare const f20: (x: number, y: string, z: boolean) => string[];
>f20 : (x: number, y: string, z: boolean) => string[]
>x : number
>y : string
>z : boolean
const f21 = bind(f20, 42); // (y: string, z: boolean) => string[]
>f21 : (y: string, z: boolean) => string[]
>bind(f20, 42) : (y: string, z: boolean) => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>f20 : (x: number, y: string, z: boolean) => string[]
>42 : 42
const f22 = bind(f21, "hello"); // (z: boolean) => string[]
>f22 : (z: boolean) => string[]
>bind(f21, "hello") : (z: boolean) => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>f21 : (y: string, z: boolean) => string[]
>"hello" : "hello"
const f23 = bind(f22, true); // () => string[]
>f23 : () => string[]
>bind(f22, true) : () => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>f22 : (z: boolean) => string[]
>true : true
f20(42, "hello", true);
>f20(42, "hello", true) : string[]
>f20 : (x: number, y: string, z: boolean) => string[]
>42 : 42
>"hello" : "hello"
>true : true
f21("hello", true);
>f21("hello", true) : string[]
>f21 : (y: string, z: boolean) => string[]
>"hello" : "hello"
>true : true
f22(true);
>f22(true) : string[]
>f22 : (z: boolean) => string[]
>true : true
f23();
>f23() : string[]
>f23 : () => string[]
declare const g20: (x: number, y?: string, z?: boolean) => string[];
>g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
>x : number
>y : string | undefined
>z : boolean | undefined
const g21 = bind(g20, 42); // (y: string, z: boolean) => string[]
>g21 : (y?: string | undefined, z?: boolean | undefined) => string[]
>bind(g20, 42) : (y?: string | undefined, z?: boolean | undefined) => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
>42 : 42
const g22 = bind(g21, "hello"); // (z: boolean) => string[]
>g22 : (z?: boolean | undefined) => string[]
>bind(g21, "hello") : (z?: boolean | undefined) => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>g21 : (y?: string | undefined, z?: boolean | undefined) => string[]
>"hello" : "hello"
const g23 = bind(g22, true); // () => string[]
>g23 : () => string[]
>bind(g22, true) : () => string[]
>bind : <T, U extends unknown[], V>(f: (x: T, ...rest: U) => V, x: T) => (...rest: U) => V
>g22 : (z?: boolean | undefined) => string[]
>true : true
g20(42, "hello", true);
>g20(42, "hello", true) : string[]
>g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
>42 : 42
>"hello" : "hello"
>true : true
g20(42, "hello");
>g20(42, "hello") : string[]
>g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
>42 : 42
>"hello" : "hello"
g20(42);
>g20(42) : string[]
>g20 : (x: number, y?: string | undefined, z?: boolean | undefined) => string[]
>42 : 42
g21("hello", true);
>g21("hello", true) : string[]
>g21 : (y?: string | undefined, z?: boolean | undefined) => string[]
>"hello" : "hello"
>true : true
g21("hello");
>g21("hello") : string[]
>g21 : (y?: string | undefined, z?: boolean | undefined) => string[]
>"hello" : "hello"
g21();
>g21() : string[]
>g21 : (y?: string | undefined, z?: boolean | undefined) => string[]
g22(true);
>g22(true) : string[]
>g22 : (z?: boolean | undefined) => string[]
>true : true
g22();
>g22() : string[]
>g22 : (z?: boolean | undefined) => string[]
g23();
>g23() : string[]
>g23 : () => string[]
declare function f30<T, U extends ((x: T) => any)[]>(x: T, ...args: U): U;
>f30 : <T, U extends ((x: T) => any)[]>(x: T, ...args: U) => U
>T : T
>U : U
>x : T
>T : T
>x : T
>T : T
>args : U
>U : U
>U : U
const c30 = f30(42, x => "" + x, x => x + 1); // [(x: number) => string, (x: number) => number]
>c30 : [(x: number) => string, (x: number) => number]
>f30(42, x => "" + x, x => x + 1) : [(x: number) => string, (x: number) => number]
>f30 : <T, U extends ((x: T) => any)[]>(x: T, ...args: U) => U
>42 : 42
>x => "" + x : (x: number) => string
>x : number
>"" + x : string
>"" : ""
>x : number
>x => x + 1 : (x: number) => number
>x : number
>x + 1 : number
>x : number
>1 : 1
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> = Parameters<(...args: T[]) => void>;
>T05 : T[]
>T : T
>Parameters : Parameters<T>
>args : T[]
>T : T
type T06<T> = Parameters<new (...args: []) => void>;
>T06 : []
>T : T
>Parameters : Parameters<T>
>args : []
type T07<T extends any[]> = Parameters<(...args: T) => void>;
>T07 : T
>T : T
>Parameters : Parameters<T>
>args : T
>T : T
type T08<T extends any[]> = Parameters<new (...args: T) => void>;
>T08 : T
>T : T
>Parameters : Parameters<T>
>args : T
>T : T
type T09 = Parameters<Function>;
>T09 : any[]
>Parameters : Parameters<T>
>Function : Function
type Record1 = {
>Record1 : Record1
move: [number, 'left' | 'right'];
>move : [number, "left" | "right"]
jump: [number, 'up' | 'down'];
>jump : [number, "up" | "down"]
stop: string;
>stop : string
done: [];
>done : []
}
type EventType<T> = {
>EventType : EventType<T>
>T : T
emit<K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]): void;
>emit : <K extends keyof T = keyof T>(e: K, ...payload: T[K] extends any[] ? T[K] : [T[K]]) => void
>K : K
>T : T
>T : T
>e : K
>K : K
>payload : T[K] extends any[] ? T[K] : [T[K]]
>T : T
>K : K
>T : T
>K : K
>T : T
>K : K
}
declare var events: EventType<Record1>;
>events : EventType<Record1>
>EventType : EventType<T>
>Record1 : Record1
events.emit('move', 10, 'left');
>events.emit('move', 10, 'left') : void
>events.emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>events : EventType<Record1>
>emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>'move' : "move"
>10 : 10
>'left' : "left"
events.emit('jump', 20, 'up');
>events.emit('jump', 20, 'up') : void
>events.emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>events : EventType<Record1>
>emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>'jump' : "jump"
>20 : 20
>'up' : "up"
events.emit('stop', 'Bye!');
>events.emit('stop', 'Bye!') : void
>events.emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>events : EventType<Record1>
>emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>'stop' : "stop"
>'Bye!' : "Bye!"
events.emit('done');
>events.emit('done') : void
>events.emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>events : EventType<Record1>
>emit : <K extends "move" | "jump" | "stop" | "done" = "move" | "jump" | "stop" | "done">(e: K, ...payload: Record1[K] extends any[] ? Record1[K] : [Record1[K]]) => void
>'done' : "done"

157
tests/baselines/reference/optionalTupleElements1.errors.txt Normal file
View File

@ -0,0 +1,157 @@
tests/cases/conformance/types/tuple/optionalTupleElements1.ts(13,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]'.
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]'.
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)?]'.
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)?]'.
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(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]'.
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 (11 errors) ====
type T1 = [number, string, boolean];
type T2 = [number, string, boolean?];
type T3 = [number, string?, boolean?];
type T4 = [number?, string?, boolean?];
type L1 = T1["length"];
type L2 = T2["length"];
type L3 = T3["length"];
type L4 = T4["length"];
function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
t1 = t1;
t1 = t2; // Error
~~
!!! error TS2322: Type '[number, string, (boolean | undefined)?]' is not assignable to type '[number, string, 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'.
t1 = t3; // Error
~~
!!! error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, boolean]'.
!!! 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'.
t1 = t4; // Error
~~
!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, 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'.
t2 = t1;
t2 = t2;
t2 = t3; // Error
~~
!!! error TS2322: Type '[number, (string | undefined)?, (boolean | undefined)?]' 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'.
t2 = t4; // Error
~~
!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, string, (boolean | undefined)?]'.
!!! 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'.
t3 = t1;
t3 = t2;
t3 = t3;
t3 = t4; // Error
~~
!!! error TS2322: Type '[(number | undefined)?, (string | undefined)?, (boolean | undefined)?]' is not assignable to type '[number, (string | undefined)?, (boolean | undefined)?]'.
!!! 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'.
t4 = t1;
t4 = t2;
t4 = t3;
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
~~
!!! 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"];
t3 = [42,,true]
t3 = [42];
t4 = [42, "hello"];
t4 = [42,,true];
t4 = [,"hello", true];
t4 = [,,true];
t4 = [];
t5 = [42,,true];

128
tests/baselines/reference/optionalTupleElements1.js Normal file
View File

@ -0,0 +1,128 @@
//// [optionalTupleElements1.ts]
type T1 = [number, string, boolean];
type T2 = [number, string, boolean?];
type T3 = [number, string?, boolean?];
type T4 = [number?, string?, boolean?];
type L1 = T1["length"];
type L2 = T2["length"];
type L3 = T3["length"];
type L4 = T4["length"];
function f1(t1: T1, t2: T2, t3: T3, t4: T4) {
t1 = t1;
t1 = t2; // Error
t1 = t3; // Error
t1 = t4; // Error
t2 = t1;
t2 = t2;
t2 = t3; // Error
t2 = t4; // Error
t3 = t1;
t3 = t2;
t3 = t3;
t3 = t4; // Error
t4 = t1;
t4 = t2;
t4 = t3;
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"];
t3 = [42,,true]
t3 = [42];
t4 = [42, "hello"];
t4 = [42,,true];
t4 = [,"hello", true];
t4 = [,,true];
t4 = [];
t5 = [42,,true];
//// [optionalTupleElements1.js]
"use strict";
function f1(t1, t2, t3, t4) {
t1 = t1;
t1 = t2; // Error
t1 = t3; // Error
t1 = t4; // Error
t2 = t1;
t2 = t2;
t2 = t3; // Error
t2 = t4; // Error
t3 = t1;
t3 = t2;
t3 = t3;
t3 = t4; // Error
t4 = t1;
t4 = t2;
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];
t3 = [42];
t4 = [42, "hello"];
t4 = [42, , true];
t4 = [, "hello", true];
t4 = [, , true];
t4 = [];
t5 = [42, , true];
//// [optionalTupleElements1.d.ts]
declare type T1 = [number, string, boolean];
declare type T2 = [number, string, boolean?];
declare type T3 = [number, string?, boolean?];
declare type T4 = [number?, string?, boolean?];
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 let t2: T2;
declare let t3: T3;
declare let t4: T4;
declare let t5: T5;

212
tests/baselines/reference/optionalTupleElements1.symbols Normal file
View File

@ -0,0 +1,212 @@
=== tests/cases/conformance/types/tuple/optionalTupleElements1.ts ===
type T1 = [number, string, boolean];
>T1 : Symbol(T1, Decl(optionalTupleElements1.ts, 0, 0))
type T2 = [number, string, boolean?];
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
type T3 = [number, string?, boolean?];
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
type T4 = [number?, string?, boolean?];
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
type L1 = T1["length"];
>L1 : Symbol(L1, Decl(optionalTupleElements1.ts, 3, 39))
>T1 : Symbol(T1, Decl(optionalTupleElements1.ts, 0, 0))
type L2 = T2["length"];
>L2 : Symbol(L2, Decl(optionalTupleElements1.ts, 5, 23))
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
type L3 = T3["length"];
>L3 : Symbol(L3, Decl(optionalTupleElements1.ts, 6, 23))
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
type L4 = T4["length"];
>L4 : Symbol(L4, Decl(optionalTupleElements1.ts, 7, 23))
>T4 : Symbol(T4, Decl(optionalTupleElements1.ts, 2, 38))
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))
>T1 : Symbol(T1, Decl(optionalTupleElements1.ts, 0, 0))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>T2 : Symbol(T2, Decl(optionalTupleElements1.ts, 0, 36))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>T3 : Symbol(T3, Decl(optionalTupleElements1.ts, 1, 37))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 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 = t2; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
t1 = t3; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
t1 = t4; // Error
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
t2 = t1;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
t2 = t2;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
t2 = t3; // Error
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
t2 = t4; // Error
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
t3 = t1;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
t3 = t2;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
t3 = t3;
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
t3 = t4; // Error
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 27))
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
t4 = t1;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t1 : Symbol(t1, Decl(optionalTupleElements1.ts, 10, 12))
t4 = t2;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 10, 19))
t4 = t3;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 10, 35))
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 10, 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))
}
let t2: T2;
>t2 : Symbol(t2, Decl(optionalTupleElements1.ts, 45, 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, 1, 37))
let t4: T4;
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 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))
t3 = [42, "hello"];
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
t3 = [42,,true]
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
t3 = [42];
>t3 : Symbol(t3, Decl(optionalTupleElements1.ts, 46, 3))
t4 = [42, "hello"];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t4 = [42,,true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t4 = [,"hello", true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t4 = [,,true];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t4 = [];
>t4 : Symbol(t4, Decl(optionalTupleElements1.ts, 47, 3))
t5 = [42,,true];
>t5 : Symbol(t5, Decl(optionalTupleElements1.ts, 48, 3))

280
tests/baselines/reference/optionalTupleElements1.types Normal file
View File

@ -0,0 +1,280 @@
=== tests/cases/conformance/types/tuple/optionalTupleElements1.ts ===
type T1 = [number, string, boolean];
>T1 : [number, string, boolean]
type T2 = [number, string, boolean?];
>T2 : [number, string, (boolean | undefined)?]
type T3 = [number, string?, boolean?];
>T3 : [number, (string | undefined)?, (boolean | undefined)?]
type T4 = [number?, string?, boolean?];
>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
type L1 = T1["length"];
>L1 : 3
>T1 : [number, string, boolean]
type L2 = T2["length"];
>L2 : 3 | 2
>T2 : [number, string, (boolean | undefined)?]
type L3 = T3["length"];
>L3 : 3 | 2 | 1
>T3 : [number, (string | undefined)?, (boolean | undefined)?]
type L4 = T4["length"];
>L4 : 0 | 3 | 2 | 1
>T4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
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]
>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)?]
t1 = t1;
>t1 = t1 : [number, string, boolean]
>t1 : [number, string, boolean]
>t1 : [number, string, boolean]
t1 = t2; // Error
>t1 = t2 : [number, string, (boolean | undefined)?]
>t1 : [number, string, boolean]
>t2 : [number, string, (boolean | undefined)?]
t1 = t3; // Error
>t1 = t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t1 : [number, string, boolean]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
t1 = t4; // Error
>t1 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t1 : [number, string, boolean]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
t2 = t1;
>t2 = t1 : [number, string, boolean]
>t2 : [number, string, (boolean | undefined)?]
>t1 : [number, string, boolean]
t2 = t2;
>t2 = t2 : [number, string, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
t2 = t3; // Error
>t2 = t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
t2 = t4; // Error
>t2 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
t3 = t1;
>t3 = t1 : [number, string, boolean]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t1 : [number, string, boolean]
t3 = t2;
>t3 = t2 : [number, string, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
t3 = t3;
>t3 = t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
t3 = t4; // Error
>t3 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
t4 = t1;
>t4 = t1 : [number, string, boolean]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t1 : [number, string, boolean]
t4 = t2;
>t4 = t2 : [number, string, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t2 : [number, string, (boolean | undefined)?]
t4 = t3;
>t4 = t3 : [number, (string | undefined)?, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
t4 = t4;
>t4 = t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>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)?]
let t3: T3;
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>T3 : [number, (string | undefined)?, (boolean | undefined)?]
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)?]
>[42, "hello"] : [number, string]
>42 : 42
>"hello" : "hello"
t3 = [42, "hello"];
>t3 = [42, "hello"] : [number, string]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>[42, "hello"] : [number, string]
>42 : 42
>"hello" : "hello"
t3 = [42,,true]
>t3 = [42,,true] : [number, undefined, true]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>[42,,true] : [number, undefined, true]
>42 : 42
> : undefined
>true : true
t3 = [42];
>t3 = [42] : [number]
>t3 : [number, (string | undefined)?, (boolean | undefined)?]
>[42] : [number]
>42 : 42
t4 = [42, "hello"];
>t4 = [42, "hello"] : [number, string]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>[42, "hello"] : [number, string]
>42 : 42
>"hello" : "hello"
t4 = [42,,true];
>t4 = [42,,true] : [number, undefined, true]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>[42,,true] : [number, undefined, true]
>42 : 42
> : undefined
>true : true
t4 = [,"hello", true];
>t4 = [,"hello", true] : [undefined, string, true]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>[,"hello", true] : [undefined, string, true]
> : undefined
>"hello" : "hello"
>true : true
t4 = [,,true];
>t4 = [,,true] : [undefined, undefined, true]
>t4 : [(number | undefined)?, (string | undefined)?, (boolean | undefined)?]
>[,,true] : [undefined, undefined, true]
> : undefined
> : undefined
>true : true
t4 = [];
>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