diff --git a/tests/baselines/reference/genericRestParameters1.errors.txt b/tests/baselines/reference/genericRestParameters1.errors.txt
new file mode 100644
index 00000000000..13828435b5a
--- /dev/null
+++ b/tests/baselines/reference/genericRestParameters1.errors.txt
@@ -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');
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/genericRestParameters1.js b/tests/baselines/reference/genericRestParameters1.js
new file mode 100644
index 00000000000..6817bb43e51
--- /dev/null
+++ b/tests/baselines/reference/genericRestParameters1.js
@@ -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>;
diff --git a/tests/baselines/reference/genericRestParameters1.symbols b/tests/baselines/reference/genericRestParameters1.symbols
new file mode 100644
index 00000000000..dc37a211543
--- /dev/null
+++ b/tests/baselines/reference/genericRestParameters1.symbols
@@ -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))
+
diff --git a/tests/baselines/reference/genericRestParameters1.types b/tests/baselines/reference/genericRestParameters1.types
new file mode 100644
index 00000000000..1f2e1b1f03d
--- /dev/null
+++ b/tests/baselines/reference/genericRestParameters1.types
@@ -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"
+
diff --git a/tests/baselines/reference/optionalTupleElements1.errors.txt b/tests/baselines/reference/optionalTupleElements1.errors.txt
new file mode 100644
index 00000000000..b9c520c483c
--- /dev/null
+++ b/tests/baselines/reference/optionalTupleElements1.errors.txt
@@ -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];
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/optionalTupleElements1.js b/tests/baselines/reference/optionalTupleElements1.js
new file mode 100644
index 00000000000..118b3fb1845
--- /dev/null
+++ b/tests/baselines/reference/optionalTupleElements1.js
@@ -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;
diff --git a/tests/baselines/reference/optionalTupleElements1.symbols b/tests/baselines/reference/optionalTupleElements1.symbols
new file mode 100644
index 00000000000..8148ccffef9
--- /dev/null
+++ b/tests/baselines/reference/optionalTupleElements1.symbols
@@ -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))
+
diff --git a/tests/baselines/reference/optionalTupleElements1.types b/tests/baselines/reference/optionalTupleElements1.types
new file mode 100644
index 00000000000..5cbe036b052
--- /dev/null
+++ b/tests/baselines/reference/optionalTupleElements1.types
@@ -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
+