diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 61fa4d1c69e2f..cd9dccdec2799 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -16873,7 +16873,7 @@ namespace ts {
                 else if (target.flags & TypeFlags.IndexedAccess) {
                     // A type S is related to a type T[K] if S is related to C, where C is the base
                     // constraint of T[K] for writing.
-                    if (relation !== identityRelation) {
+                    if (relation === assignableRelation || relation === comparableRelation) {
                         const objectType = (<IndexedAccessType>target).objectType;
                         const indexType = (<IndexedAccessType>target).indexType;
                         const baseObjectType = getBaseConstraintOfType(objectType) || objectType;
diff --git a/tests/baselines/reference/variadicTuples1.errors.txt b/tests/baselines/reference/variadicTuples1.errors.txt
index 2cb9d46a207c1..251c81aadf1db 100644
--- a/tests/baselines/reference/variadicTuples1.errors.txt
+++ b/tests/baselines/reference/variadicTuples1.errors.txt
@@ -1,26 +1,26 @@
 tests/cases/conformance/types/tuple/variadicTuples1.ts(6,48): error TS1256: A rest element must be last in a tuple type.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(46,5): error TS2555: Expected at least 3 arguments, but got 2.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(47,17): error TS2345: Argument of type '45' is not assignable to parameter of type 'boolean'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(125,9): error TS2344: Type 'V' does not satisfy the constraint 'unknown[]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(52,5): error TS2555: Expected at least 3 arguments, but got 2.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(53,17): error TS2345: Argument of type '45' is not assignable to parameter of type 'boolean'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(131,9): error TS2344: Type 'V' does not satisfy the constraint 'unknown[]'.
   The type 'readonly unknown[]' is 'readonly' and cannot be assigned to the mutable type 'unknown[]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(143,5): error TS2322: Type '[string, ...unknown[]]' is not assignable to type '[string, ...T]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(149,5): error TS2322: Type '[string, ...unknown[]]' is not assignable to type '[string, ...T]'.
   Target requires 2 element(s) but source may have fewer.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(145,5): error TS2322: Type '[string, ...unknown[]]' is not assignable to type '[string, ...U]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(151,5): error TS2322: Type '[string, ...unknown[]]' is not assignable to type '[string, ...U]'.
   Target requires 2 element(s) but source may have fewer.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(146,5): error TS2322: Type '[string, ...T]' is not assignable to type '[string, ...U]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(152,5): error TS2322: Type '[string, ...T]' is not assignable to type '[string, ...U]'.
   Type 'T' is not assignable to type 'U'.
     'T' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint 'string[]'.
       Type 'string[]' is not assignable to type 'U'.
         'U' could be instantiated with an arbitrary type which could be unrelated to 'string[]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(154,5): error TS2322: Type 'readonly [...T]' is not assignable to type 'T'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(160,5): error TS2322: Type 'readonly [...T]' is not assignable to type 'T'.
   'T' could be instantiated with an arbitrary type which could be unrelated to 'readonly [...T]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(156,5): error TS4104: The type 'readonly [...T]' is 'readonly' and cannot be assigned to the mutable type '[...T]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(163,5): error TS2322: Type 'readonly [...T]' is not assignable to type 'T'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(162,5): error TS4104: The type 'readonly [...T]' is 'readonly' and cannot be assigned to the mutable type '[...T]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(169,5): error TS2322: Type 'readonly [...T]' is not assignable to type 'T'.
   'readonly [...T]' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'readonly unknown[]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(164,5): error TS2322: Type 'T' is not assignable to type '[...T]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(170,5): error TS2322: Type 'T' is not assignable to type '[...T]'.
   The type 'readonly unknown[]' is 'readonly' and cannot be assigned to the mutable type '[...T]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(165,5): error TS4104: The type 'readonly [...T]' is 'readonly' and cannot be assigned to the mutable type '[...T]'.
-tests/cases/conformance/types/tuple/variadicTuples1.ts(297,14): error TS7019: Rest parameter 'x' implicitly has an 'any[]' type.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(171,5): error TS4104: The type 'readonly [...T]' is 'readonly' and cannot be assigned to the mutable type '[...T]'.
+tests/cases/conformance/types/tuple/variadicTuples1.ts(303,14): error TS7019: Rest parameter 'x' implicitly has an 'any[]' type.
 
 
 ==== tests/cases/conformance/types/tuple/variadicTuples1.ts (13 errors) ====
@@ -62,6 +62,12 @@ tests/cases/conformance/types/tuple/variadicTuples1.ts(297,14): error TS7019: Re
     const tc3 = concat([1, 2, 3], sa);
     const tc4 = concat(sa, [1, 2, 3]);  // Ideally would be [...string[], number, number, number]
     
+    function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) {
+        return [...t, ...u];  // (T[number] | U[number])[]
+    }
+    
+    const tc5 = concat2([1, 2, 3] as const, [4, 5, 6] as const);  // (1 | 2 | 3 | 4 | 5 | 6)[]
+    
     // Spread arguments
     
     declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;
@@ -74,7 +80,7 @@ tests/cases/conformance/types/tuple/variadicTuples1.ts(297,14): error TS7019: Re
         foo1(...t1);  // Error
         ~~~~~~~~~~~
 !!! error TS2555: Expected at least 3 arguments, but got 2.
-!!! related TS6210 tests/cases/conformance/types/tuple/variadicTuples1.ts:39:45: An argument for 'c' was not provided.
+!!! related TS6210 tests/cases/conformance/types/tuple/variadicTuples1.ts:45:45: An argument for 'c' was not provided.
         foo1(...t1, 45);  // Error
                     ~~
 !!! error TS2345: Argument of type '45' is not assignable to parameter of type 'boolean'.
diff --git a/tests/baselines/reference/variadicTuples1.js b/tests/baselines/reference/variadicTuples1.js
index e35f25830b5a0..7e85c4badd594 100644
--- a/tests/baselines/reference/variadicTuples1.js
+++ b/tests/baselines/reference/variadicTuples1.js
@@ -35,6 +35,12 @@ const tc2 = concat(['hello'], [42]);
 const tc3 = concat([1, 2, 3], sa);
 const tc4 = concat(sa, [1, 2, 3]);  // Ideally would be [...string[], number, number, number]
 
+function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) {
+    return [...t, ...u];  // (T[number] | U[number])[]
+}
+
+const tc5 = concat2([1, 2, 3] as const, [4, 5, 6] as const);  // (1 | 2 | 3 | 4 | 5 | 6)[]
+
 // Spread arguments
 
 declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;
@@ -320,6 +326,10 @@ var tc1 = concat([], []);
 var tc2 = concat(['hello'], [42]);
 var tc3 = concat([1, 2, 3], sa);
 var tc4 = concat(sa, [1, 2, 3]); // Ideally would be [...string[], number, number, number]
+function concat2(t, u) {
+    return __spreadArrays(t, u); // (T[number] | U[number])[]
+}
+var tc5 = concat2([1, 2, 3], [4, 5, 6]); // (1 | 2 | 3 | 4 | 5 | 6)[]
 function foo2(t1, t2, a1) {
     foo1(1, 'abc', true, 42, 43, 44);
     foo1.apply(void 0, __spreadArrays(t1, [true, 42, 43, 44]));
@@ -483,6 +493,8 @@ declare const tc1: [];
 declare const tc2: [string, number];
 declare const tc3: [number, number, number, ...string[]];
 declare const tc4: (string | number)[];
+declare function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U): (T[number] | U[number])[];
+declare const tc5: (2 | 4 | 1 | 3 | 6 | 5)[];
 declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;
 declare function foo2(t1: [number, string], t2: [boolean], a1: number[]): void;
 declare function foo3<T extends unknown[]>(x: number, ...args: [...T, number]): T;
diff --git a/tests/baselines/reference/variadicTuples1.symbols b/tests/baselines/reference/variadicTuples1.symbols
index 4701211779bf4..022cb589a1862 100644
--- a/tests/baselines/reference/variadicTuples1.symbols
+++ b/tests/baselines/reference/variadicTuples1.symbols
@@ -110,900 +110,918 @@ const tc4 = concat(sa, [1, 2, 3]);  // Ideally would be [...string[], number, nu
 >concat : Symbol(concat, Decl(variadicTuples1.ts, 23, 39))
 >sa : Symbol(sa, Decl(variadicTuples1.ts, 29, 13))
 
+function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) {
+>concat2 : Symbol(concat2, Decl(variadicTuples1.ts, 34, 34))
+>T : Symbol(T, Decl(variadicTuples1.ts, 36, 17))
+>U : Symbol(U, Decl(variadicTuples1.ts, 36, 46))
+>t : Symbol(t, Decl(variadicTuples1.ts, 36, 77))
+>T : Symbol(T, Decl(variadicTuples1.ts, 36, 17))
+>u : Symbol(u, Decl(variadicTuples1.ts, 36, 82))
+>U : Symbol(U, Decl(variadicTuples1.ts, 36, 46))
+
+    return [...t, ...u];  // (T[number] | U[number])[]
+>t : Symbol(t, Decl(variadicTuples1.ts, 36, 77))
+>u : Symbol(u, Decl(variadicTuples1.ts, 36, 82))
+}
+
+const tc5 = concat2([1, 2, 3] as const, [4, 5, 6] as const);  // (1 | 2 | 3 | 4 | 5 | 6)[]
+>tc5 : Symbol(tc5, Decl(variadicTuples1.ts, 40, 5))
+>concat2 : Symbol(concat2, Decl(variadicTuples1.ts, 34, 34))
+
 // Spread arguments
 
 declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->a : Symbol(a, Decl(variadicTuples1.ts, 38, 22))
->b : Symbol(b, Decl(variadicTuples1.ts, 38, 32))
->c : Symbol(c, Decl(variadicTuples1.ts, 38, 43))
->d : Symbol(d, Decl(variadicTuples1.ts, 38, 55))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>a : Symbol(a, Decl(variadicTuples1.ts, 44, 22))
+>b : Symbol(b, Decl(variadicTuples1.ts, 44, 32))
+>c : Symbol(c, Decl(variadicTuples1.ts, 44, 43))
+>d : Symbol(d, Decl(variadicTuples1.ts, 44, 55))
 
 function foo2(t1: [number, string], t2: [boolean], a1: number[]) {
->foo2 : Symbol(foo2, Decl(variadicTuples1.ts, 38, 78))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
->t2 : Symbol(t2, Decl(variadicTuples1.ts, 40, 35))
->a1 : Symbol(a1, Decl(variadicTuples1.ts, 40, 50))
+>foo2 : Symbol(foo2, Decl(variadicTuples1.ts, 44, 78))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
+>t2 : Symbol(t2, Decl(variadicTuples1.ts, 46, 35))
+>a1 : Symbol(a1, Decl(variadicTuples1.ts, 46, 50))
 
     foo1(1, 'abc', true, 42, 43, 44);
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
 
     foo1(...t1, true, 42, 43, 44);
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
 
     foo1(...t1, ...t2, 42, 43, 44);
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
->t2 : Symbol(t2, Decl(variadicTuples1.ts, 40, 35))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
+>t2 : Symbol(t2, Decl(variadicTuples1.ts, 46, 35))
 
     foo1(...t1, ...t2, ...a1);
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
->t2 : Symbol(t2, Decl(variadicTuples1.ts, 40, 35))
->a1 : Symbol(a1, Decl(variadicTuples1.ts, 40, 50))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
+>t2 : Symbol(t2, Decl(variadicTuples1.ts, 46, 35))
+>a1 : Symbol(a1, Decl(variadicTuples1.ts, 46, 50))
 
     foo1(...t1);  // Error
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
 
     foo1(...t1, 45);  // Error
->foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 34, 34))
->t1 : Symbol(t1, Decl(variadicTuples1.ts, 40, 14))
+>foo1 : Symbol(foo1, Decl(variadicTuples1.ts, 40, 60))
+>t1 : Symbol(t1, Decl(variadicTuples1.ts, 46, 14))
 }
 
 declare function foo3<T extends unknown[]>(x: number, ...args: [...T, number]): T;
->foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 47, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 49, 22))
->x : Symbol(x, Decl(variadicTuples1.ts, 49, 43))
->args : Symbol(args, Decl(variadicTuples1.ts, 49, 53))
->T : Symbol(T, Decl(variadicTuples1.ts, 49, 22))
->T : Symbol(T, Decl(variadicTuples1.ts, 49, 22))
+>foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 53, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 55, 22))
+>x : Symbol(x, Decl(variadicTuples1.ts, 55, 43))
+>args : Symbol(args, Decl(variadicTuples1.ts, 55, 53))
+>T : Symbol(T, Decl(variadicTuples1.ts, 55, 22))
+>T : Symbol(T, Decl(variadicTuples1.ts, 55, 22))
 
 function foo4<U extends unknown[]>(u: U) {
->foo4 : Symbol(foo4, Decl(variadicTuples1.ts, 49, 82))
->U : Symbol(U, Decl(variadicTuples1.ts, 51, 14))
->u : Symbol(u, Decl(variadicTuples1.ts, 51, 35))
->U : Symbol(U, Decl(variadicTuples1.ts, 51, 14))
+>foo4 : Symbol(foo4, Decl(variadicTuples1.ts, 55, 82))
+>U : Symbol(U, Decl(variadicTuples1.ts, 57, 14))
+>u : Symbol(u, Decl(variadicTuples1.ts, 57, 35))
+>U : Symbol(U, Decl(variadicTuples1.ts, 57, 14))
 
     foo3(1, 2);
->foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 47, 1))
+>foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 53, 1))
 
     foo3(1, 'hello', true, 2);
->foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 47, 1))
+>foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 53, 1))
 
     foo3(1, ...u, 'hi', 2);
->foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 47, 1))
->u : Symbol(u, Decl(variadicTuples1.ts, 51, 35))
+>foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 53, 1))
+>u : Symbol(u, Decl(variadicTuples1.ts, 57, 35))
 
     foo3(1);
->foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 47, 1))
+>foo3 : Symbol(foo3, Decl(variadicTuples1.ts, 53, 1))
 }
 
 // Contextual typing of array literals
 
 declare function ft1<T extends unknown[]>(t: T): T;
->ft1 : Symbol(ft1, Decl(variadicTuples1.ts, 56, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 60, 21))
->t : Symbol(t, Decl(variadicTuples1.ts, 60, 42))
->T : Symbol(T, Decl(variadicTuples1.ts, 60, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 60, 21))
+>ft1 : Symbol(ft1, Decl(variadicTuples1.ts, 62, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 66, 21))
+>t : Symbol(t, Decl(variadicTuples1.ts, 66, 42))
+>T : Symbol(T, Decl(variadicTuples1.ts, 66, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 66, 21))
 
 declare function ft2<T extends unknown[]>(t: T): readonly [...T];
->ft2 : Symbol(ft2, Decl(variadicTuples1.ts, 60, 51))
->T : Symbol(T, Decl(variadicTuples1.ts, 61, 21))
->t : Symbol(t, Decl(variadicTuples1.ts, 61, 42))
->T : Symbol(T, Decl(variadicTuples1.ts, 61, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 61, 21))
+>ft2 : Symbol(ft2, Decl(variadicTuples1.ts, 66, 51))
+>T : Symbol(T, Decl(variadicTuples1.ts, 67, 21))
+>t : Symbol(t, Decl(variadicTuples1.ts, 67, 42))
+>T : Symbol(T, Decl(variadicTuples1.ts, 67, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 67, 21))
 
 declare function ft3<T extends unknown[]>(t: [...T]): T;
->ft3 : Symbol(ft3, Decl(variadicTuples1.ts, 61, 65))
->T : Symbol(T, Decl(variadicTuples1.ts, 62, 21))
->t : Symbol(t, Decl(variadicTuples1.ts, 62, 42))
->T : Symbol(T, Decl(variadicTuples1.ts, 62, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 62, 21))
+>ft3 : Symbol(ft3, Decl(variadicTuples1.ts, 67, 65))
+>T : Symbol(T, Decl(variadicTuples1.ts, 68, 21))
+>t : Symbol(t, Decl(variadicTuples1.ts, 68, 42))
+>T : Symbol(T, Decl(variadicTuples1.ts, 68, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 68, 21))
 
 declare function ft4<T extends unknown[]>(t: [...T]): readonly [...T];
->ft4 : Symbol(ft4, Decl(variadicTuples1.ts, 62, 56))
->T : Symbol(T, Decl(variadicTuples1.ts, 63, 21))
->t : Symbol(t, Decl(variadicTuples1.ts, 63, 42))
->T : Symbol(T, Decl(variadicTuples1.ts, 63, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 63, 21))
+>ft4 : Symbol(ft4, Decl(variadicTuples1.ts, 68, 56))
+>T : Symbol(T, Decl(variadicTuples1.ts, 69, 21))
+>t : Symbol(t, Decl(variadicTuples1.ts, 69, 42))
+>T : Symbol(T, Decl(variadicTuples1.ts, 69, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 69, 21))
 
 ft1(['hello', 42]);  // (string | number)[]
->ft1 : Symbol(ft1, Decl(variadicTuples1.ts, 56, 1))
+>ft1 : Symbol(ft1, Decl(variadicTuples1.ts, 62, 1))
 
 ft2(['hello', 42]);  // readonly (string | number)[]
->ft2 : Symbol(ft2, Decl(variadicTuples1.ts, 60, 51))
+>ft2 : Symbol(ft2, Decl(variadicTuples1.ts, 66, 51))
 
 ft3(['hello', 42]);  // [string, number]
->ft3 : Symbol(ft3, Decl(variadicTuples1.ts, 61, 65))
+>ft3 : Symbol(ft3, Decl(variadicTuples1.ts, 67, 65))
 
 ft4(['hello', 42]);  // readonly [string, number]
->ft4 : Symbol(ft4, Decl(variadicTuples1.ts, 62, 56))
+>ft4 : Symbol(ft4, Decl(variadicTuples1.ts, 68, 56))
 
 // Indexing variadic tuple types
 
 function f0<T extends unknown[]>(t: [string, ...T], n: number) {
->f0 : Symbol(f0, Decl(variadicTuples1.ts, 68, 19))
->T : Symbol(T, Decl(variadicTuples1.ts, 72, 12))
->t : Symbol(t, Decl(variadicTuples1.ts, 72, 33))
->T : Symbol(T, Decl(variadicTuples1.ts, 72, 12))
->n : Symbol(n, Decl(variadicTuples1.ts, 72, 51))
+>f0 : Symbol(f0, Decl(variadicTuples1.ts, 74, 19))
+>T : Symbol(T, Decl(variadicTuples1.ts, 78, 12))
+>t : Symbol(t, Decl(variadicTuples1.ts, 78, 33))
+>T : Symbol(T, Decl(variadicTuples1.ts, 78, 12))
+>n : Symbol(n, Decl(variadicTuples1.ts, 78, 51))
 
     const a = t[0];  // string
->a : Symbol(a, Decl(variadicTuples1.ts, 73, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 72, 33))
+>a : Symbol(a, Decl(variadicTuples1.ts, 79, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 78, 33))
 >0 : Symbol(0)
 
     const b = t[1];  // [string, ...T][1]
->b : Symbol(b, Decl(variadicTuples1.ts, 74, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 72, 33))
+>b : Symbol(b, Decl(variadicTuples1.ts, 80, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 78, 33))
 
     const c = t[2];  // [string, ...T][2]
->c : Symbol(c, Decl(variadicTuples1.ts, 75, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 72, 33))
+>c : Symbol(c, Decl(variadicTuples1.ts, 81, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 78, 33))
 
     const d = t[n];  // [string, ...T][number]
->d : Symbol(d, Decl(variadicTuples1.ts, 76, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 72, 33))
->n : Symbol(n, Decl(variadicTuples1.ts, 72, 51))
+>d : Symbol(d, Decl(variadicTuples1.ts, 82, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 78, 33))
+>n : Symbol(n, Decl(variadicTuples1.ts, 78, 51))
 }
 
 function f1<T extends unknown[]>(t: [string, ...T, number], n: number) {
->f1 : Symbol(f1, Decl(variadicTuples1.ts, 77, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 79, 12))
->t : Symbol(t, Decl(variadicTuples1.ts, 79, 33))
->T : Symbol(T, Decl(variadicTuples1.ts, 79, 12))
->n : Symbol(n, Decl(variadicTuples1.ts, 79, 59))
+>f1 : Symbol(f1, Decl(variadicTuples1.ts, 83, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 85, 12))
+>t : Symbol(t, Decl(variadicTuples1.ts, 85, 33))
+>T : Symbol(T, Decl(variadicTuples1.ts, 85, 12))
+>n : Symbol(n, Decl(variadicTuples1.ts, 85, 59))
 
     const a = t[0];  // string
->a : Symbol(a, Decl(variadicTuples1.ts, 80, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 79, 33))
+>a : Symbol(a, Decl(variadicTuples1.ts, 86, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 85, 33))
 >0 : Symbol(0)
 
     const b = t[1];  // [string, ...T, number][1]
->b : Symbol(b, Decl(variadicTuples1.ts, 81, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 79, 33))
+>b : Symbol(b, Decl(variadicTuples1.ts, 87, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 85, 33))
 
     const c = t[2];  // [string, ...T, number][2]
->c : Symbol(c, Decl(variadicTuples1.ts, 82, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 79, 33))
+>c : Symbol(c, Decl(variadicTuples1.ts, 88, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 85, 33))
 
     const d = t[n];  // [string, ...T, number][number]
->d : Symbol(d, Decl(variadicTuples1.ts, 83, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 79, 33))
->n : Symbol(n, Decl(variadicTuples1.ts, 79, 59))
+>d : Symbol(d, Decl(variadicTuples1.ts, 89, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 85, 33))
+>n : Symbol(n, Decl(variadicTuples1.ts, 85, 59))
 }
 
 // Destructuring variadic tuple types
 
 function f2<T extends unknown[]>(t: [string, ...T]) {
->f2 : Symbol(f2, Decl(variadicTuples1.ts, 84, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 88, 12))
->t : Symbol(t, Decl(variadicTuples1.ts, 88, 33))
->T : Symbol(T, Decl(variadicTuples1.ts, 88, 12))
-
-    let [...ax] = t;  // [string, ...T]
->ax : Symbol(ax, Decl(variadicTuples1.ts, 89, 9))
->t : Symbol(t, Decl(variadicTuples1.ts, 88, 33))
-
-    let [b1, ...bx] = t;  // string, [...T]
->b1 : Symbol(b1, Decl(variadicTuples1.ts, 90, 9))
->bx : Symbol(bx, Decl(variadicTuples1.ts, 90, 12))
->t : Symbol(t, Decl(variadicTuples1.ts, 88, 33))
-
-    let [c1, c2, ...cx] = t;  // string, [string, ...T][1], T[number][]
->c1 : Symbol(c1, Decl(variadicTuples1.ts, 91, 9))
->c2 : Symbol(c2, Decl(variadicTuples1.ts, 91, 12))
->cx : Symbol(cx, Decl(variadicTuples1.ts, 91, 16))
->t : Symbol(t, Decl(variadicTuples1.ts, 88, 33))
-}
-
-function f3<T extends unknown[]>(t: [string, ...T, number]) {
->f3 : Symbol(f3, Decl(variadicTuples1.ts, 92, 1))
+>f2 : Symbol(f2, Decl(variadicTuples1.ts, 90, 1))
 >T : Symbol(T, Decl(variadicTuples1.ts, 94, 12))
 >t : Symbol(t, Decl(variadicTuples1.ts, 94, 33))
 >T : Symbol(T, Decl(variadicTuples1.ts, 94, 12))
 
-    let [...ax] = t;  // [string, ...T, number]
+    let [...ax] = t;  // [string, ...T]
 >ax : Symbol(ax, Decl(variadicTuples1.ts, 95, 9))
 >t : Symbol(t, Decl(variadicTuples1.ts, 94, 33))
 
-    let [b1, ...bx] = t;  // string, [...T, number]
+    let [b1, ...bx] = t;  // string, [...T]
 >b1 : Symbol(b1, Decl(variadicTuples1.ts, 96, 9))
 >bx : Symbol(bx, Decl(variadicTuples1.ts, 96, 12))
 >t : Symbol(t, Decl(variadicTuples1.ts, 94, 33))
 
-    let [c1, c2, ...cx] = t;  // string, [string, ...T, number][1], (number | T[number])[]
+    let [c1, c2, ...cx] = t;  // string, [string, ...T][1], T[number][]
 >c1 : Symbol(c1, Decl(variadicTuples1.ts, 97, 9))
 >c2 : Symbol(c2, Decl(variadicTuples1.ts, 97, 12))
 >cx : Symbol(cx, Decl(variadicTuples1.ts, 97, 16))
 >t : Symbol(t, Decl(variadicTuples1.ts, 94, 33))
 }
 
+function f3<T extends unknown[]>(t: [string, ...T, number]) {
+>f3 : Symbol(f3, Decl(variadicTuples1.ts, 98, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 100, 12))
+>t : Symbol(t, Decl(variadicTuples1.ts, 100, 33))
+>T : Symbol(T, Decl(variadicTuples1.ts, 100, 12))
+
+    let [...ax] = t;  // [string, ...T, number]
+>ax : Symbol(ax, Decl(variadicTuples1.ts, 101, 9))
+>t : Symbol(t, Decl(variadicTuples1.ts, 100, 33))
+
+    let [b1, ...bx] = t;  // string, [...T, number]
+>b1 : Symbol(b1, Decl(variadicTuples1.ts, 102, 9))
+>bx : Symbol(bx, Decl(variadicTuples1.ts, 102, 12))
+>t : Symbol(t, Decl(variadicTuples1.ts, 100, 33))
+
+    let [c1, c2, ...cx] = t;  // string, [string, ...T, number][1], (number | T[number])[]
+>c1 : Symbol(c1, Decl(variadicTuples1.ts, 103, 9))
+>c2 : Symbol(c2, Decl(variadicTuples1.ts, 103, 12))
+>cx : Symbol(cx, Decl(variadicTuples1.ts, 103, 16))
+>t : Symbol(t, Decl(variadicTuples1.ts, 100, 33))
+}
+
 // Mapped types applied to variadic tuple types
 
 type Arrayify<T> = { [P in keyof T]: T[P][] };
->Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 98, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 102, 14))
->P : Symbol(P, Decl(variadicTuples1.ts, 102, 22))
->T : Symbol(T, Decl(variadicTuples1.ts, 102, 14))
->T : Symbol(T, Decl(variadicTuples1.ts, 102, 14))
->P : Symbol(P, Decl(variadicTuples1.ts, 102, 22))
+>Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 104, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 108, 14))
+>P : Symbol(P, Decl(variadicTuples1.ts, 108, 22))
+>T : Symbol(T, Decl(variadicTuples1.ts, 108, 14))
+>T : Symbol(T, Decl(variadicTuples1.ts, 108, 14))
+>P : Symbol(P, Decl(variadicTuples1.ts, 108, 22))
 
 type TM1<U extends unknown[]> = Arrayify<readonly [string, number?, ...U, ...boolean[]]>;  // [string[], (number | undefined)[]?, Arrayify<U>, ...boolean[][]]
->TM1 : Symbol(TM1, Decl(variadicTuples1.ts, 102, 46))
->U : Symbol(U, Decl(variadicTuples1.ts, 104, 9))
->Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 98, 1))
->U : Symbol(U, Decl(variadicTuples1.ts, 104, 9))
+>TM1 : Symbol(TM1, Decl(variadicTuples1.ts, 108, 46))
+>U : Symbol(U, Decl(variadicTuples1.ts, 110, 9))
+>Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 104, 1))
+>U : Symbol(U, Decl(variadicTuples1.ts, 110, 9))
 
 type TP1<T extends unknown[]> = Partial<[string, ...T, number]>;  // [string?, Partial<T>, number?]
->TP1 : Symbol(TP1, Decl(variadicTuples1.ts, 104, 89))
->T : Symbol(T, Decl(variadicTuples1.ts, 106, 9))
+>TP1 : Symbol(TP1, Decl(variadicTuples1.ts, 110, 89))
+>T : Symbol(T, Decl(variadicTuples1.ts, 112, 9))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(variadicTuples1.ts, 106, 9))
+>T : Symbol(T, Decl(variadicTuples1.ts, 112, 9))
 
 type TP2<T extends unknown[]> = Partial<[string, ...T, ...number[]]>;  // [string?, Partial<T>, ...(number | undefined)[]]
->TP2 : Symbol(TP2, Decl(variadicTuples1.ts, 106, 64))
->T : Symbol(T, Decl(variadicTuples1.ts, 107, 9))
+>TP2 : Symbol(TP2, Decl(variadicTuples1.ts, 112, 64))
+>T : Symbol(T, Decl(variadicTuples1.ts, 113, 9))
 >Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
->T : Symbol(T, Decl(variadicTuples1.ts, 107, 9))
+>T : Symbol(T, Decl(variadicTuples1.ts, 113, 9))
 
 // Reverse mapping through mapped type applied to variadic tuple type
 
 declare function fm1<T extends unknown[]>(t: Arrayify<[string, number, ...T]>): T;
->fm1 : Symbol(fm1, Decl(variadicTuples1.ts, 107, 69))
->T : Symbol(T, Decl(variadicTuples1.ts, 111, 21))
->t : Symbol(t, Decl(variadicTuples1.ts, 111, 42))
->Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 98, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 111, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 111, 21))
+>fm1 : Symbol(fm1, Decl(variadicTuples1.ts, 113, 69))
+>T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
+>t : Symbol(t, Decl(variadicTuples1.ts, 117, 42))
+>Arrayify : Symbol(Arrayify, Decl(variadicTuples1.ts, 104, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
 
 let tm1 = fm1([['abc'], [42], [true], ['def']]);  // [boolean, string]
->tm1 : Symbol(tm1, Decl(variadicTuples1.ts, 113, 3))
->fm1 : Symbol(fm1, Decl(variadicTuples1.ts, 107, 69))
+>tm1 : Symbol(tm1, Decl(variadicTuples1.ts, 119, 3))
+>fm1 : Symbol(fm1, Decl(variadicTuples1.ts, 113, 69))
 
 // Spread of readonly array-like infers mutable array-like
 
 declare function fx1<T extends unknown[]>(a: string, ...args: T): T;
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
->T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
->a : Symbol(a, Decl(variadicTuples1.ts, 117, 42))
->args : Symbol(args, Decl(variadicTuples1.ts, 117, 52))
->T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 117, 21))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
+>T : Symbol(T, Decl(variadicTuples1.ts, 123, 21))
+>a : Symbol(a, Decl(variadicTuples1.ts, 123, 42))
+>args : Symbol(args, Decl(variadicTuples1.ts, 123, 52))
+>T : Symbol(T, Decl(variadicTuples1.ts, 123, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 123, 21))
 
 function gx1<U extends unknown[], V extends readonly unknown[]>(u: U, v: V) {
->gx1 : Symbol(gx1, Decl(variadicTuples1.ts, 117, 68))
->U : Symbol(U, Decl(variadicTuples1.ts, 119, 13))
->V : Symbol(V, Decl(variadicTuples1.ts, 119, 33))
->u : Symbol(u, Decl(variadicTuples1.ts, 119, 64))
->U : Symbol(U, Decl(variadicTuples1.ts, 119, 13))
->v : Symbol(v, Decl(variadicTuples1.ts, 119, 69))
->V : Symbol(V, Decl(variadicTuples1.ts, 119, 33))
+>gx1 : Symbol(gx1, Decl(variadicTuples1.ts, 123, 68))
+>U : Symbol(U, Decl(variadicTuples1.ts, 125, 13))
+>V : Symbol(V, Decl(variadicTuples1.ts, 125, 33))
+>u : Symbol(u, Decl(variadicTuples1.ts, 125, 64))
+>U : Symbol(U, Decl(variadicTuples1.ts, 125, 13))
+>v : Symbol(v, Decl(variadicTuples1.ts, 125, 69))
+>V : Symbol(V, Decl(variadicTuples1.ts, 125, 33))
 
     fx1('abc');  // []
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
 
     fx1('abc', ...u);  // U
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
->u : Symbol(u, Decl(variadicTuples1.ts, 119, 64))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
+>u : Symbol(u, Decl(variadicTuples1.ts, 125, 64))
 
     fx1('abc', ...v);  // [...V]
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
->v : Symbol(v, Decl(variadicTuples1.ts, 119, 69))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
+>v : Symbol(v, Decl(variadicTuples1.ts, 125, 69))
 
     fx1<U>('abc', ...u);  // U
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
->U : Symbol(U, Decl(variadicTuples1.ts, 119, 13))
->u : Symbol(u, Decl(variadicTuples1.ts, 119, 64))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
+>U : Symbol(U, Decl(variadicTuples1.ts, 125, 13))
+>u : Symbol(u, Decl(variadicTuples1.ts, 125, 64))
 
     fx1<V>('abc', ...v);  // Error
->fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 113, 48))
->V : Symbol(V, Decl(variadicTuples1.ts, 119, 33))
->v : Symbol(v, Decl(variadicTuples1.ts, 119, 69))
+>fx1 : Symbol(fx1, Decl(variadicTuples1.ts, 119, 48))
+>V : Symbol(V, Decl(variadicTuples1.ts, 125, 33))
+>v : Symbol(v, Decl(variadicTuples1.ts, 125, 69))
 }
 
 declare function fx2<T extends readonly unknown[]>(a: string, ...args: T): T;
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 127, 21))
->a : Symbol(a, Decl(variadicTuples1.ts, 127, 51))
->args : Symbol(args, Decl(variadicTuples1.ts, 127, 61))
->T : Symbol(T, Decl(variadicTuples1.ts, 127, 21))
->T : Symbol(T, Decl(variadicTuples1.ts, 127, 21))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 133, 21))
+>a : Symbol(a, Decl(variadicTuples1.ts, 133, 51))
+>args : Symbol(args, Decl(variadicTuples1.ts, 133, 61))
+>T : Symbol(T, Decl(variadicTuples1.ts, 133, 21))
+>T : Symbol(T, Decl(variadicTuples1.ts, 133, 21))
 
 function gx2<U extends unknown[], V extends readonly unknown[]>(u: U, v: V) {
->gx2 : Symbol(gx2, Decl(variadicTuples1.ts, 127, 77))
->U : Symbol(U, Decl(variadicTuples1.ts, 129, 13))
->V : Symbol(V, Decl(variadicTuples1.ts, 129, 33))
->u : Symbol(u, Decl(variadicTuples1.ts, 129, 64))
->U : Symbol(U, Decl(variadicTuples1.ts, 129, 13))
->v : Symbol(v, Decl(variadicTuples1.ts, 129, 69))
->V : Symbol(V, Decl(variadicTuples1.ts, 129, 33))
+>gx2 : Symbol(gx2, Decl(variadicTuples1.ts, 133, 77))
+>U : Symbol(U, Decl(variadicTuples1.ts, 135, 13))
+>V : Symbol(V, Decl(variadicTuples1.ts, 135, 33))
+>u : Symbol(u, Decl(variadicTuples1.ts, 135, 64))
+>U : Symbol(U, Decl(variadicTuples1.ts, 135, 13))
+>v : Symbol(v, Decl(variadicTuples1.ts, 135, 69))
+>V : Symbol(V, Decl(variadicTuples1.ts, 135, 33))
 
     fx2('abc');  // []
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
 
     fx2('abc', ...u);  // U
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
->u : Symbol(u, Decl(variadicTuples1.ts, 129, 64))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
+>u : Symbol(u, Decl(variadicTuples1.ts, 135, 64))
 
     fx2('abc', ...v);  // [...V]
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
->v : Symbol(v, Decl(variadicTuples1.ts, 129, 69))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
+>v : Symbol(v, Decl(variadicTuples1.ts, 135, 69))
 
     fx2<U>('abc', ...u);  // U
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
->U : Symbol(U, Decl(variadicTuples1.ts, 129, 13))
->u : Symbol(u, Decl(variadicTuples1.ts, 129, 64))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
+>U : Symbol(U, Decl(variadicTuples1.ts, 135, 13))
+>u : Symbol(u, Decl(variadicTuples1.ts, 135, 64))
 
     fx2<V>('abc', ...v);  // V
->fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 125, 1))
->V : Symbol(V, Decl(variadicTuples1.ts, 129, 33))
->v : Symbol(v, Decl(variadicTuples1.ts, 129, 69))
+>fx2 : Symbol(fx2, Decl(variadicTuples1.ts, 131, 1))
+>V : Symbol(V, Decl(variadicTuples1.ts, 135, 33))
+>v : Symbol(v, Decl(variadicTuples1.ts, 135, 69))
 }
 
 // Relations involving variadic tuple types
 
 function f10<T extends string[], U extends T>(x: [string, ...unknown[]], y: [string, ...T], z: [string, ...U]) {
->f10 : Symbol(f10, Decl(variadicTuples1.ts, 135, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 139, 13))
->U : Symbol(U, Decl(variadicTuples1.ts, 139, 32))
->T : Symbol(T, Decl(variadicTuples1.ts, 139, 13))
->x : Symbol(x, Decl(variadicTuples1.ts, 139, 46))
->y : Symbol(y, Decl(variadicTuples1.ts, 139, 72))
->T : Symbol(T, Decl(variadicTuples1.ts, 139, 13))
->z : Symbol(z, Decl(variadicTuples1.ts, 139, 91))
->U : Symbol(U, Decl(variadicTuples1.ts, 139, 32))
+>f10 : Symbol(f10, Decl(variadicTuples1.ts, 141, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 145, 13))
+>U : Symbol(U, Decl(variadicTuples1.ts, 145, 32))
+>T : Symbol(T, Decl(variadicTuples1.ts, 145, 13))
+>x : Symbol(x, Decl(variadicTuples1.ts, 145, 46))
+>y : Symbol(y, Decl(variadicTuples1.ts, 145, 72))
+>T : Symbol(T, Decl(variadicTuples1.ts, 145, 13))
+>z : Symbol(z, Decl(variadicTuples1.ts, 145, 91))
+>U : Symbol(U, Decl(variadicTuples1.ts, 145, 32))
 
     x = y;
->x : Symbol(x, Decl(variadicTuples1.ts, 139, 46))
->y : Symbol(y, Decl(variadicTuples1.ts, 139, 72))
+>x : Symbol(x, Decl(variadicTuples1.ts, 145, 46))
+>y : Symbol(y, Decl(variadicTuples1.ts, 145, 72))
 
     x = z;
->x : Symbol(x, Decl(variadicTuples1.ts, 139, 46))
->z : Symbol(z, Decl(variadicTuples1.ts, 139, 91))
+>x : Symbol(x, Decl(variadicTuples1.ts, 145, 46))
+>z : Symbol(z, Decl(variadicTuples1.ts, 145, 91))
 
     y = x;  // Error
->y : Symbol(y, Decl(variadicTuples1.ts, 139, 72))
->x : Symbol(x, Decl(variadicTuples1.ts, 139, 46))
+>y : Symbol(y, Decl(variadicTuples1.ts, 145, 72))
+>x : Symbol(x, Decl(variadicTuples1.ts, 145, 46))
 
     y = z;
->y : Symbol(y, Decl(variadicTuples1.ts, 139, 72))
->z : Symbol(z, Decl(variadicTuples1.ts, 139, 91))
+>y : Symbol(y, Decl(variadicTuples1.ts, 145, 72))
+>z : Symbol(z, Decl(variadicTuples1.ts, 145, 91))
 
     z = x;  // Error
->z : Symbol(z, Decl(variadicTuples1.ts, 139, 91))
->x : Symbol(x, Decl(variadicTuples1.ts, 139, 46))
+>z : Symbol(z, Decl(variadicTuples1.ts, 145, 91))
+>x : Symbol(x, Decl(variadicTuples1.ts, 145, 46))
 
     z = y;  // Error
->z : Symbol(z, Decl(variadicTuples1.ts, 139, 91))
->y : Symbol(y, Decl(variadicTuples1.ts, 139, 72))
+>z : Symbol(z, Decl(variadicTuples1.ts, 145, 91))
+>y : Symbol(y, Decl(variadicTuples1.ts, 145, 72))
 }
 
 // For a generic type T, [...T] is assignable to T, T is assignable to readonly [...T], and T is assignable
 // to [...T] when T is constrained to a mutable array or tuple type.
 
 function f11<T extends unknown[]>(t: T, m: [...T], r: readonly [...T]) {
->f11 : Symbol(f11, Decl(variadicTuples1.ts, 146, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 151, 13))
->t : Symbol(t, Decl(variadicTuples1.ts, 151, 34))
->T : Symbol(T, Decl(variadicTuples1.ts, 151, 13))
->m : Symbol(m, Decl(variadicTuples1.ts, 151, 39))
->T : Symbol(T, Decl(variadicTuples1.ts, 151, 13))
->r : Symbol(r, Decl(variadicTuples1.ts, 151, 50))
->T : Symbol(T, Decl(variadicTuples1.ts, 151, 13))
+>f11 : Symbol(f11, Decl(variadicTuples1.ts, 152, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 157, 13))
+>t : Symbol(t, Decl(variadicTuples1.ts, 157, 34))
+>T : Symbol(T, Decl(variadicTuples1.ts, 157, 13))
+>m : Symbol(m, Decl(variadicTuples1.ts, 157, 39))
+>T : Symbol(T, Decl(variadicTuples1.ts, 157, 13))
+>r : Symbol(r, Decl(variadicTuples1.ts, 157, 50))
+>T : Symbol(T, Decl(variadicTuples1.ts, 157, 13))
 
     t = m;
->t : Symbol(t, Decl(variadicTuples1.ts, 151, 34))
->m : Symbol(m, Decl(variadicTuples1.ts, 151, 39))
+>t : Symbol(t, Decl(variadicTuples1.ts, 157, 34))
+>m : Symbol(m, Decl(variadicTuples1.ts, 157, 39))
 
     t = r;  // Error
->t : Symbol(t, Decl(variadicTuples1.ts, 151, 34))
->r : Symbol(r, Decl(variadicTuples1.ts, 151, 50))
+>t : Symbol(t, Decl(variadicTuples1.ts, 157, 34))
+>r : Symbol(r, Decl(variadicTuples1.ts, 157, 50))
 
     m = t;
->m : Symbol(m, Decl(variadicTuples1.ts, 151, 39))
->t : Symbol(t, Decl(variadicTuples1.ts, 151, 34))
+>m : Symbol(m, Decl(variadicTuples1.ts, 157, 39))
+>t : Symbol(t, Decl(variadicTuples1.ts, 157, 34))
 
     m = r;  // Error
->m : Symbol(m, Decl(variadicTuples1.ts, 151, 39))
->r : Symbol(r, Decl(variadicTuples1.ts, 151, 50))
+>m : Symbol(m, Decl(variadicTuples1.ts, 157, 39))
+>r : Symbol(r, Decl(variadicTuples1.ts, 157, 50))
 
     r = t;
->r : Symbol(r, Decl(variadicTuples1.ts, 151, 50))
->t : Symbol(t, Decl(variadicTuples1.ts, 151, 34))
+>r : Symbol(r, Decl(variadicTuples1.ts, 157, 50))
+>t : Symbol(t, Decl(variadicTuples1.ts, 157, 34))
 
     r = m;
->r : Symbol(r, Decl(variadicTuples1.ts, 151, 50))
->m : Symbol(m, Decl(variadicTuples1.ts, 151, 39))
+>r : Symbol(r, Decl(variadicTuples1.ts, 157, 50))
+>m : Symbol(m, Decl(variadicTuples1.ts, 157, 39))
 }
 
 function f12<T extends readonly unknown[]>(t: T, m: [...T], r: readonly [...T]) {
->f12 : Symbol(f12, Decl(variadicTuples1.ts, 158, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 160, 13))
->t : Symbol(t, Decl(variadicTuples1.ts, 160, 43))
->T : Symbol(T, Decl(variadicTuples1.ts, 160, 13))
->m : Symbol(m, Decl(variadicTuples1.ts, 160, 48))
->T : Symbol(T, Decl(variadicTuples1.ts, 160, 13))
->r : Symbol(r, Decl(variadicTuples1.ts, 160, 59))
->T : Symbol(T, Decl(variadicTuples1.ts, 160, 13))
+>f12 : Symbol(f12, Decl(variadicTuples1.ts, 164, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 166, 13))
+>t : Symbol(t, Decl(variadicTuples1.ts, 166, 43))
+>T : Symbol(T, Decl(variadicTuples1.ts, 166, 13))
+>m : Symbol(m, Decl(variadicTuples1.ts, 166, 48))
+>T : Symbol(T, Decl(variadicTuples1.ts, 166, 13))
+>r : Symbol(r, Decl(variadicTuples1.ts, 166, 59))
+>T : Symbol(T, Decl(variadicTuples1.ts, 166, 13))
 
     t = m;
->t : Symbol(t, Decl(variadicTuples1.ts, 160, 43))
->m : Symbol(m, Decl(variadicTuples1.ts, 160, 48))
+>t : Symbol(t, Decl(variadicTuples1.ts, 166, 43))
+>m : Symbol(m, Decl(variadicTuples1.ts, 166, 48))
 
     t = r;  // Error
->t : Symbol(t, Decl(variadicTuples1.ts, 160, 43))
->r : Symbol(r, Decl(variadicTuples1.ts, 160, 59))
+>t : Symbol(t, Decl(variadicTuples1.ts, 166, 43))
+>r : Symbol(r, Decl(variadicTuples1.ts, 166, 59))
 
     m = t;  // Error
->m : Symbol(m, Decl(variadicTuples1.ts, 160, 48))
->t : Symbol(t, Decl(variadicTuples1.ts, 160, 43))
+>m : Symbol(m, Decl(variadicTuples1.ts, 166, 48))
+>t : Symbol(t, Decl(variadicTuples1.ts, 166, 43))
 
     m = r;  // Error
->m : Symbol(m, Decl(variadicTuples1.ts, 160, 48))
->r : Symbol(r, Decl(variadicTuples1.ts, 160, 59))
+>m : Symbol(m, Decl(variadicTuples1.ts, 166, 48))
+>r : Symbol(r, Decl(variadicTuples1.ts, 166, 59))
 
     r = t;
->r : Symbol(r, Decl(variadicTuples1.ts, 160, 59))
->t : Symbol(t, Decl(variadicTuples1.ts, 160, 43))
+>r : Symbol(r, Decl(variadicTuples1.ts, 166, 59))
+>t : Symbol(t, Decl(variadicTuples1.ts, 166, 43))
 
     r = m;
->r : Symbol(r, Decl(variadicTuples1.ts, 160, 59))
->m : Symbol(m, Decl(variadicTuples1.ts, 160, 48))
+>r : Symbol(r, Decl(variadicTuples1.ts, 166, 59))
+>m : Symbol(m, Decl(variadicTuples1.ts, 166, 48))
 }
 
 // Inference between variadic tuple types
 
 type First<T extends readonly unknown[]> = T[0];
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
->T : Symbol(T, Decl(variadicTuples1.ts, 171, 11))
->T : Symbol(T, Decl(variadicTuples1.ts, 171, 11))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
+>T : Symbol(T, Decl(variadicTuples1.ts, 177, 11))
+>T : Symbol(T, Decl(variadicTuples1.ts, 177, 11))
 
 type DropFirst<T extends readonly unknown[]> = T extends readonly [any, ...infer U] ? U : [...T];
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
->T : Symbol(T, Decl(variadicTuples1.ts, 172, 15))
->T : Symbol(T, Decl(variadicTuples1.ts, 172, 15))
->U : Symbol(U, Decl(variadicTuples1.ts, 172, 80))
->U : Symbol(U, Decl(variadicTuples1.ts, 172, 80))
->T : Symbol(T, Decl(variadicTuples1.ts, 172, 15))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
+>T : Symbol(T, Decl(variadicTuples1.ts, 178, 15))
+>T : Symbol(T, Decl(variadicTuples1.ts, 178, 15))
+>U : Symbol(U, Decl(variadicTuples1.ts, 178, 80))
+>U : Symbol(U, Decl(variadicTuples1.ts, 178, 80))
+>T : Symbol(T, Decl(variadicTuples1.ts, 178, 15))
 
 type Last<T extends readonly unknown[]> = T extends readonly [...infer _, infer U] ? U : undefined;
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
->T : Symbol(T, Decl(variadicTuples1.ts, 174, 10))
->T : Symbol(T, Decl(variadicTuples1.ts, 174, 10))
->_ : Symbol(_, Decl(variadicTuples1.ts, 174, 70))
->U : Symbol(U, Decl(variadicTuples1.ts, 174, 79))
->U : Symbol(U, Decl(variadicTuples1.ts, 174, 79))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
+>T : Symbol(T, Decl(variadicTuples1.ts, 180, 10))
+>T : Symbol(T, Decl(variadicTuples1.ts, 180, 10))
+>_ : Symbol(_, Decl(variadicTuples1.ts, 180, 70))
+>U : Symbol(U, Decl(variadicTuples1.ts, 180, 79))
+>U : Symbol(U, Decl(variadicTuples1.ts, 180, 79))
 
 type DropLast<T extends readonly unknown[]> = T extends readonly [...infer U, any] ? U : [...T];
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
->T : Symbol(T, Decl(variadicTuples1.ts, 175, 14))
->T : Symbol(T, Decl(variadicTuples1.ts, 175, 14))
->U : Symbol(U, Decl(variadicTuples1.ts, 175, 74))
->U : Symbol(U, Decl(variadicTuples1.ts, 175, 74))
->T : Symbol(T, Decl(variadicTuples1.ts, 175, 14))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
+>T : Symbol(T, Decl(variadicTuples1.ts, 181, 14))
+>T : Symbol(T, Decl(variadicTuples1.ts, 181, 14))
+>U : Symbol(U, Decl(variadicTuples1.ts, 181, 74))
+>U : Symbol(U, Decl(variadicTuples1.ts, 181, 74))
+>T : Symbol(T, Decl(variadicTuples1.ts, 181, 14))
 
 type T00 = First<[number, symbol, string]>;
->T00 : Symbol(T00, Decl(variadicTuples1.ts, 175, 96))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T00 : Symbol(T00, Decl(variadicTuples1.ts, 181, 96))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T01 = First<[symbol, string]>;
->T01 : Symbol(T01, Decl(variadicTuples1.ts, 177, 43))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T01 : Symbol(T01, Decl(variadicTuples1.ts, 183, 43))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T02 = First<[string]>;
->T02 : Symbol(T02, Decl(variadicTuples1.ts, 178, 35))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T02 : Symbol(T02, Decl(variadicTuples1.ts, 184, 35))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T03 = First<[number, symbol, ...string[]]>;
->T03 : Symbol(T03, Decl(variadicTuples1.ts, 179, 27))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T03 : Symbol(T03, Decl(variadicTuples1.ts, 185, 27))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T04 = First<[symbol, ...string[]]>;
->T04 : Symbol(T04, Decl(variadicTuples1.ts, 180, 48))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T04 : Symbol(T04, Decl(variadicTuples1.ts, 186, 48))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T05 = First<string[]>;
->T05 : Symbol(T05, Decl(variadicTuples1.ts, 181, 40))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T05 : Symbol(T05, Decl(variadicTuples1.ts, 187, 40))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T06 = First<[]>;
->T06 : Symbol(T06, Decl(variadicTuples1.ts, 182, 27))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T06 : Symbol(T06, Decl(variadicTuples1.ts, 188, 27))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T07 = First<any>;
->T07 : Symbol(T07, Decl(variadicTuples1.ts, 183, 21))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T07 : Symbol(T07, Decl(variadicTuples1.ts, 189, 21))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T08 = First<never>;
->T08 : Symbol(T08, Decl(variadicTuples1.ts, 184, 22))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>T08 : Symbol(T08, Decl(variadicTuples1.ts, 190, 22))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type T10 = DropFirst<[number, symbol, string]>;
->T10 : Symbol(T10, Decl(variadicTuples1.ts, 185, 24))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T10 : Symbol(T10, Decl(variadicTuples1.ts, 191, 24))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T11 = DropFirst<[symbol, string]>;
->T11 : Symbol(T11, Decl(variadicTuples1.ts, 187, 47))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T11 : Symbol(T11, Decl(variadicTuples1.ts, 193, 47))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T12 = DropFirst<[string]>;
->T12 : Symbol(T12, Decl(variadicTuples1.ts, 188, 39))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T12 : Symbol(T12, Decl(variadicTuples1.ts, 194, 39))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T13 = DropFirst<[number, symbol, ...string[]]>;
->T13 : Symbol(T13, Decl(variadicTuples1.ts, 189, 31))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T13 : Symbol(T13, Decl(variadicTuples1.ts, 195, 31))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T14 = DropFirst<[symbol, ...string[]]>;
->T14 : Symbol(T14, Decl(variadicTuples1.ts, 190, 52))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T14 : Symbol(T14, Decl(variadicTuples1.ts, 196, 52))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T15 = DropFirst<string[]>;
->T15 : Symbol(T15, Decl(variadicTuples1.ts, 191, 44))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T15 : Symbol(T15, Decl(variadicTuples1.ts, 197, 44))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T16 = DropFirst<[]>;
->T16 : Symbol(T16, Decl(variadicTuples1.ts, 192, 31))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T16 : Symbol(T16, Decl(variadicTuples1.ts, 198, 31))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T17 = DropFirst<any>;
->T17 : Symbol(T17, Decl(variadicTuples1.ts, 193, 25))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T17 : Symbol(T17, Decl(variadicTuples1.ts, 199, 25))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T18 = DropFirst<never>;
->T18 : Symbol(T18, Decl(variadicTuples1.ts, 194, 26))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>T18 : Symbol(T18, Decl(variadicTuples1.ts, 200, 26))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type T20 = Last<[number, symbol, string]>;
->T20 : Symbol(T20, Decl(variadicTuples1.ts, 195, 28))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T20 : Symbol(T20, Decl(variadicTuples1.ts, 201, 28))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T21 = Last<[symbol, string]>;
->T21 : Symbol(T21, Decl(variadicTuples1.ts, 197, 42))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T21 : Symbol(T21, Decl(variadicTuples1.ts, 203, 42))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T22 = Last<[string]>;
->T22 : Symbol(T22, Decl(variadicTuples1.ts, 198, 34))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T22 : Symbol(T22, Decl(variadicTuples1.ts, 204, 34))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T23 = Last<[number, symbol, ...string[]]>;
->T23 : Symbol(T23, Decl(variadicTuples1.ts, 199, 26))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T23 : Symbol(T23, Decl(variadicTuples1.ts, 205, 26))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T24 = Last<[symbol, ...string[]]>;
->T24 : Symbol(T24, Decl(variadicTuples1.ts, 200, 47))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T24 : Symbol(T24, Decl(variadicTuples1.ts, 206, 47))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T25 = Last<string[]>;
->T25 : Symbol(T25, Decl(variadicTuples1.ts, 201, 39))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T25 : Symbol(T25, Decl(variadicTuples1.ts, 207, 39))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T26 = Last<[]>;  // unknown[], maybe should be []
->T26 : Symbol(T26, Decl(variadicTuples1.ts, 202, 26))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T26 : Symbol(T26, Decl(variadicTuples1.ts, 208, 26))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T27 = Last<any>;  // unknown, maybe should be any
->T27 : Symbol(T27, Decl(variadicTuples1.ts, 203, 20))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T27 : Symbol(T27, Decl(variadicTuples1.ts, 209, 20))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T28 = Last<never>;
->T28 : Symbol(T28, Decl(variadicTuples1.ts, 204, 21))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>T28 : Symbol(T28, Decl(variadicTuples1.ts, 210, 21))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type T30 = DropLast<[number, symbol, string]>;
->T30 : Symbol(T30, Decl(variadicTuples1.ts, 205, 23))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T30 : Symbol(T30, Decl(variadicTuples1.ts, 211, 23))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T31 = DropLast<[symbol, string]>;
->T31 : Symbol(T31, Decl(variadicTuples1.ts, 207, 46))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T31 : Symbol(T31, Decl(variadicTuples1.ts, 213, 46))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T32 = DropLast<[string]>;
->T32 : Symbol(T32, Decl(variadicTuples1.ts, 208, 38))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T32 : Symbol(T32, Decl(variadicTuples1.ts, 214, 38))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T33 = DropLast<[number, symbol, ...string[]]>;
->T33 : Symbol(T33, Decl(variadicTuples1.ts, 209, 30))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T33 : Symbol(T33, Decl(variadicTuples1.ts, 215, 30))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T34 = DropLast<[symbol, ...string[]]>;
->T34 : Symbol(T34, Decl(variadicTuples1.ts, 210, 51))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T34 : Symbol(T34, Decl(variadicTuples1.ts, 216, 51))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T35 = DropLast<string[]>;
->T35 : Symbol(T35, Decl(variadicTuples1.ts, 211, 43))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T35 : Symbol(T35, Decl(variadicTuples1.ts, 217, 43))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T36 = DropLast<[]>;  // unknown[], maybe should be []
->T36 : Symbol(T36, Decl(variadicTuples1.ts, 212, 30))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T36 : Symbol(T36, Decl(variadicTuples1.ts, 218, 30))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T37 = DropLast<any>;
->T37 : Symbol(T37, Decl(variadicTuples1.ts, 213, 24))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T37 : Symbol(T37, Decl(variadicTuples1.ts, 219, 24))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type T38 = DropLast<never>;
->T38 : Symbol(T38, Decl(variadicTuples1.ts, 214, 25))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>T38 : Symbol(T38, Decl(variadicTuples1.ts, 220, 25))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R00 = First<readonly [number, symbol, string]>;
->R00 : Symbol(R00, Decl(variadicTuples1.ts, 215, 27))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R00 : Symbol(R00, Decl(variadicTuples1.ts, 221, 27))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R01 = First<readonly [symbol, string]>;
->R01 : Symbol(R01, Decl(variadicTuples1.ts, 217, 52))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R01 : Symbol(R01, Decl(variadicTuples1.ts, 223, 52))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R02 = First<readonly [string]>;
->R02 : Symbol(R02, Decl(variadicTuples1.ts, 218, 44))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R02 : Symbol(R02, Decl(variadicTuples1.ts, 224, 44))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R03 = First<readonly [number, symbol, ...string[]]>;
->R03 : Symbol(R03, Decl(variadicTuples1.ts, 219, 36))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R03 : Symbol(R03, Decl(variadicTuples1.ts, 225, 36))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R04 = First<readonly [symbol, ...string[]]>;
->R04 : Symbol(R04, Decl(variadicTuples1.ts, 220, 57))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R04 : Symbol(R04, Decl(variadicTuples1.ts, 226, 57))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R05 = First<readonly string[]>;
->R05 : Symbol(R05, Decl(variadicTuples1.ts, 221, 49))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R05 : Symbol(R05, Decl(variadicTuples1.ts, 227, 49))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R06 = First<readonly []>;
->R06 : Symbol(R06, Decl(variadicTuples1.ts, 222, 36))
->First : Symbol(First, Decl(variadicTuples1.ts, 167, 1))
+>R06 : Symbol(R06, Decl(variadicTuples1.ts, 228, 36))
+>First : Symbol(First, Decl(variadicTuples1.ts, 173, 1))
 
 type R10 = DropFirst<readonly [number, symbol, string]>;
->R10 : Symbol(R10, Decl(variadicTuples1.ts, 223, 30))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R10 : Symbol(R10, Decl(variadicTuples1.ts, 229, 30))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R11 = DropFirst<readonly [symbol, string]>;
->R11 : Symbol(R11, Decl(variadicTuples1.ts, 225, 56))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R11 : Symbol(R11, Decl(variadicTuples1.ts, 231, 56))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R12 = DropFirst<readonly [string]>;
->R12 : Symbol(R12, Decl(variadicTuples1.ts, 226, 48))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R12 : Symbol(R12, Decl(variadicTuples1.ts, 232, 48))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R13 = DropFirst<readonly [number, symbol, ...string[]]>;
->R13 : Symbol(R13, Decl(variadicTuples1.ts, 227, 40))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R13 : Symbol(R13, Decl(variadicTuples1.ts, 233, 40))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R14 = DropFirst<readonly [symbol, ...string[]]>;
->R14 : Symbol(R14, Decl(variadicTuples1.ts, 228, 61))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R14 : Symbol(R14, Decl(variadicTuples1.ts, 234, 61))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R15 = DropFirst<readonly string[]>;
->R15 : Symbol(R15, Decl(variadicTuples1.ts, 229, 53))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R15 : Symbol(R15, Decl(variadicTuples1.ts, 235, 53))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R16 = DropFirst<readonly []>;
->R16 : Symbol(R16, Decl(variadicTuples1.ts, 230, 40))
->DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 171, 48))
+>R16 : Symbol(R16, Decl(variadicTuples1.ts, 236, 40))
+>DropFirst : Symbol(DropFirst, Decl(variadicTuples1.ts, 177, 48))
 
 type R20 = Last<readonly [number, symbol, string]>;
->R20 : Symbol(R20, Decl(variadicTuples1.ts, 231, 34))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R20 : Symbol(R20, Decl(variadicTuples1.ts, 237, 34))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R21 = Last<readonly [symbol, string]>;
->R21 : Symbol(R21, Decl(variadicTuples1.ts, 233, 51))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R21 : Symbol(R21, Decl(variadicTuples1.ts, 239, 51))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R22 = Last<readonly [string]>;
->R22 : Symbol(R22, Decl(variadicTuples1.ts, 234, 43))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R22 : Symbol(R22, Decl(variadicTuples1.ts, 240, 43))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R23 = Last<readonly [number, symbol, ...string[]]>;
->R23 : Symbol(R23, Decl(variadicTuples1.ts, 235, 35))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R23 : Symbol(R23, Decl(variadicTuples1.ts, 241, 35))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R24 = Last<readonly [symbol, ...string[]]>;
->R24 : Symbol(R24, Decl(variadicTuples1.ts, 236, 56))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R24 : Symbol(R24, Decl(variadicTuples1.ts, 242, 56))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R25 = Last<readonly string[]>;
->R25 : Symbol(R25, Decl(variadicTuples1.ts, 237, 48))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R25 : Symbol(R25, Decl(variadicTuples1.ts, 243, 48))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R26 = Last<readonly []>;
->R26 : Symbol(R26, Decl(variadicTuples1.ts, 238, 35))
->Last : Symbol(Last, Decl(variadicTuples1.ts, 172, 97))
+>R26 : Symbol(R26, Decl(variadicTuples1.ts, 244, 35))
+>Last : Symbol(Last, Decl(variadicTuples1.ts, 178, 97))
 
 type R30 = DropLast<readonly [number, symbol, string]>;
->R30 : Symbol(R30, Decl(variadicTuples1.ts, 239, 29))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R30 : Symbol(R30, Decl(variadicTuples1.ts, 245, 29))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R31 = DropLast<readonly [symbol, string]>;
->R31 : Symbol(R31, Decl(variadicTuples1.ts, 241, 55))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R31 : Symbol(R31, Decl(variadicTuples1.ts, 247, 55))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R32 = DropLast<readonly [string]>;
->R32 : Symbol(R32, Decl(variadicTuples1.ts, 242, 47))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R32 : Symbol(R32, Decl(variadicTuples1.ts, 248, 47))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R33 = DropLast<readonly [number, symbol, ...string[]]>;
->R33 : Symbol(R33, Decl(variadicTuples1.ts, 243, 39))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R33 : Symbol(R33, Decl(variadicTuples1.ts, 249, 39))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R34 = DropLast<readonly [symbol, ...string[]]>;
->R34 : Symbol(R34, Decl(variadicTuples1.ts, 244, 60))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R34 : Symbol(R34, Decl(variadicTuples1.ts, 250, 60))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R35 = DropLast<readonly string[]>;
->R35 : Symbol(R35, Decl(variadicTuples1.ts, 245, 52))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R35 : Symbol(R35, Decl(variadicTuples1.ts, 251, 52))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 type R36 = DropLast<readonly []>;
->R36 : Symbol(R36, Decl(variadicTuples1.ts, 246, 39))
->DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 174, 99))
+>R36 : Symbol(R36, Decl(variadicTuples1.ts, 252, 39))
+>DropLast : Symbol(DropLast, Decl(variadicTuples1.ts, 180, 99))
 
 // Inference to [...T, ...U] with implied arity for T
 
 function curry<T extends unknown[], U extends unknown[], R>(f: (...args: [...T, ...U]) => R, ...a: T) {
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->T : Symbol(T, Decl(variadicTuples1.ts, 251, 15))
->U : Symbol(U, Decl(variadicTuples1.ts, 251, 35))
->R : Symbol(R, Decl(variadicTuples1.ts, 251, 56))
->f : Symbol(f, Decl(variadicTuples1.ts, 251, 60))
->args : Symbol(args, Decl(variadicTuples1.ts, 251, 64))
->T : Symbol(T, Decl(variadicTuples1.ts, 251, 15))
->U : Symbol(U, Decl(variadicTuples1.ts, 251, 35))
->R : Symbol(R, Decl(variadicTuples1.ts, 251, 56))
->a : Symbol(a, Decl(variadicTuples1.ts, 251, 92))
->T : Symbol(T, Decl(variadicTuples1.ts, 251, 15))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>T : Symbol(T, Decl(variadicTuples1.ts, 257, 15))
+>U : Symbol(U, Decl(variadicTuples1.ts, 257, 35))
+>R : Symbol(R, Decl(variadicTuples1.ts, 257, 56))
+>f : Symbol(f, Decl(variadicTuples1.ts, 257, 60))
+>args : Symbol(args, Decl(variadicTuples1.ts, 257, 64))
+>T : Symbol(T, Decl(variadicTuples1.ts, 257, 15))
+>U : Symbol(U, Decl(variadicTuples1.ts, 257, 35))
+>R : Symbol(R, Decl(variadicTuples1.ts, 257, 56))
+>a : Symbol(a, Decl(variadicTuples1.ts, 257, 92))
+>T : Symbol(T, Decl(variadicTuples1.ts, 257, 15))
 
     return (...b: U) => f(...a, ...b);
->b : Symbol(b, Decl(variadicTuples1.ts, 252, 12))
->U : Symbol(U, Decl(variadicTuples1.ts, 251, 35))
->f : Symbol(f, Decl(variadicTuples1.ts, 251, 60))
->a : Symbol(a, Decl(variadicTuples1.ts, 251, 92))
->b : Symbol(b, Decl(variadicTuples1.ts, 252, 12))
+>b : Symbol(b, Decl(variadicTuples1.ts, 258, 12))
+>U : Symbol(U, Decl(variadicTuples1.ts, 257, 35))
+>f : Symbol(f, Decl(variadicTuples1.ts, 257, 60))
+>a : Symbol(a, Decl(variadicTuples1.ts, 257, 92))
+>b : Symbol(b, Decl(variadicTuples1.ts, 258, 12))
 }
 
 const fn1 = (a: number, b: string, c: boolean, d: string[]) => 0;
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
->a : Symbol(a, Decl(variadicTuples1.ts, 255, 13))
->b : Symbol(b, Decl(variadicTuples1.ts, 255, 23))
->c : Symbol(c, Decl(variadicTuples1.ts, 255, 34))
->d : Symbol(d, Decl(variadicTuples1.ts, 255, 46))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
+>a : Symbol(a, Decl(variadicTuples1.ts, 261, 13))
+>b : Symbol(b, Decl(variadicTuples1.ts, 261, 23))
+>c : Symbol(c, Decl(variadicTuples1.ts, 261, 34))
+>d : Symbol(d, Decl(variadicTuples1.ts, 261, 46))
 
 const c0 = curry(fn1);  // (a: number, b: string, c: boolean, d: string[]) => number
->c0 : Symbol(c0, Decl(variadicTuples1.ts, 257, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
+>c0 : Symbol(c0, Decl(variadicTuples1.ts, 263, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
 
 const c1 = curry(fn1, 1);  // (b: string, c: boolean, d: string[]) => number
->c1 : Symbol(c1, Decl(variadicTuples1.ts, 258, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
+>c1 : Symbol(c1, Decl(variadicTuples1.ts, 264, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
 
 const c2 = curry(fn1, 1, 'abc');  // (c: boolean, d: string[]) => number
->c2 : Symbol(c2, Decl(variadicTuples1.ts, 259, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
+>c2 : Symbol(c2, Decl(variadicTuples1.ts, 265, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
 
 const c3 = curry(fn1, 1, 'abc', true);  // (d: string[]) => number
->c3 : Symbol(c3, Decl(variadicTuples1.ts, 260, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
+>c3 : Symbol(c3, Decl(variadicTuples1.ts, 266, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
 
 const c4 = curry(fn1, 1, 'abc', true, ['x', 'y']);  // () => number
->c4 : Symbol(c4, Decl(variadicTuples1.ts, 261, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 255, 5))
+>c4 : Symbol(c4, Decl(variadicTuples1.ts, 267, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn1 : Symbol(fn1, Decl(variadicTuples1.ts, 261, 5))
 
 const fn2 = (x: number, b: boolean, ...args: string[]) => 0;
->fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 263, 5))
->x : Symbol(x, Decl(variadicTuples1.ts, 263, 13))
->b : Symbol(b, Decl(variadicTuples1.ts, 263, 23))
->args : Symbol(args, Decl(variadicTuples1.ts, 263, 35))
+>fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 269, 5))
+>x : Symbol(x, Decl(variadicTuples1.ts, 269, 13))
+>b : Symbol(b, Decl(variadicTuples1.ts, 269, 23))
+>args : Symbol(args, Decl(variadicTuples1.ts, 269, 35))
 
 const c10 = curry(fn2);  // (x: number, b: boolean, ...args: string[]) => number
->c10 : Symbol(c10, Decl(variadicTuples1.ts, 265, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 263, 5))
+>c10 : Symbol(c10, Decl(variadicTuples1.ts, 271, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 269, 5))
 
 const c11 = curry(fn2, 1);  // (b: boolean, ...args: string[]) => number
->c11 : Symbol(c11, Decl(variadicTuples1.ts, 266, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 263, 5))
+>c11 : Symbol(c11, Decl(variadicTuples1.ts, 272, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 269, 5))
 
 const c12 = curry(fn2, 1, true);  // (...args: string[]) => number
->c12 : Symbol(c12, Decl(variadicTuples1.ts, 267, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 263, 5))
+>c12 : Symbol(c12, Decl(variadicTuples1.ts, 273, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 269, 5))
 
 const c13 = curry(fn2, 1, true, 'abc', 'def');  // (...args: string[]) => number
->c13 : Symbol(c13, Decl(variadicTuples1.ts, 268, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 263, 5))
+>c13 : Symbol(c13, Decl(variadicTuples1.ts, 274, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn2 : Symbol(fn2, Decl(variadicTuples1.ts, 269, 5))
 
 const fn3 = (...args: string[]) => 0;
->fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 270, 5))
->args : Symbol(args, Decl(variadicTuples1.ts, 270, 13))
+>fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 276, 5))
+>args : Symbol(args, Decl(variadicTuples1.ts, 276, 13))
 
 const c20 = curry(fn3);  // (...args: string[]) => number
->c20 : Symbol(c20, Decl(variadicTuples1.ts, 272, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 270, 5))
+>c20 : Symbol(c20, Decl(variadicTuples1.ts, 278, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 276, 5))
 
 const c21 = curry(fn3, 'abc', 'def');  // (...args: string[]) => number
->c21 : Symbol(c21, Decl(variadicTuples1.ts, 273, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 270, 5))
+>c21 : Symbol(c21, Decl(variadicTuples1.ts, 279, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 276, 5))
 
 const c22 = curry(fn3, ...sa);  // (...args: string[]) => number
->c22 : Symbol(c22, Decl(variadicTuples1.ts, 274, 5))
->curry : Symbol(curry, Decl(variadicTuples1.ts, 247, 33))
->fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 270, 5))
+>c22 : Symbol(c22, Decl(variadicTuples1.ts, 280, 5))
+>curry : Symbol(curry, Decl(variadicTuples1.ts, 253, 33))
+>fn3 : Symbol(fn3, Decl(variadicTuples1.ts, 276, 5))
 >sa : Symbol(sa, Decl(variadicTuples1.ts, 29, 13))
 
 // No inference to [...T, ...U] when there is no implied arity
 
 function curry2<T extends unknown[], U extends unknown[], R>(f: (...args: [...T, ...U]) => R, t: [...T], u: [...U]) {
->curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 274, 30))
->T : Symbol(T, Decl(variadicTuples1.ts, 278, 16))
->U : Symbol(U, Decl(variadicTuples1.ts, 278, 36))
->R : Symbol(R, Decl(variadicTuples1.ts, 278, 57))
->f : Symbol(f, Decl(variadicTuples1.ts, 278, 61))
->args : Symbol(args, Decl(variadicTuples1.ts, 278, 65))
->T : Symbol(T, Decl(variadicTuples1.ts, 278, 16))
->U : Symbol(U, Decl(variadicTuples1.ts, 278, 36))
->R : Symbol(R, Decl(variadicTuples1.ts, 278, 57))
->t : Symbol(t, Decl(variadicTuples1.ts, 278, 93))
->T : Symbol(T, Decl(variadicTuples1.ts, 278, 16))
->u : Symbol(u, Decl(variadicTuples1.ts, 278, 104))
->U : Symbol(U, Decl(variadicTuples1.ts, 278, 36))
+>curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 280, 30))
+>T : Symbol(T, Decl(variadicTuples1.ts, 284, 16))
+>U : Symbol(U, Decl(variadicTuples1.ts, 284, 36))
+>R : Symbol(R, Decl(variadicTuples1.ts, 284, 57))
+>f : Symbol(f, Decl(variadicTuples1.ts, 284, 61))
+>args : Symbol(args, Decl(variadicTuples1.ts, 284, 65))
+>T : Symbol(T, Decl(variadicTuples1.ts, 284, 16))
+>U : Symbol(U, Decl(variadicTuples1.ts, 284, 36))
+>R : Symbol(R, Decl(variadicTuples1.ts, 284, 57))
+>t : Symbol(t, Decl(variadicTuples1.ts, 284, 93))
+>T : Symbol(T, Decl(variadicTuples1.ts, 284, 16))
+>u : Symbol(u, Decl(variadicTuples1.ts, 284, 104))
+>U : Symbol(U, Decl(variadicTuples1.ts, 284, 36))
 
     return f(...t, ...u);
->f : Symbol(f, Decl(variadicTuples1.ts, 278, 61))
->t : Symbol(t, Decl(variadicTuples1.ts, 278, 93))
->u : Symbol(u, Decl(variadicTuples1.ts, 278, 104))
+>f : Symbol(f, Decl(variadicTuples1.ts, 284, 61))
+>t : Symbol(t, Decl(variadicTuples1.ts, 284, 93))
+>u : Symbol(u, Decl(variadicTuples1.ts, 284, 104))
 }
 
 declare function fn10(a: string, b: number, c: boolean): string[];
->fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 280, 1))
->a : Symbol(a, Decl(variadicTuples1.ts, 282, 22))
->b : Symbol(b, Decl(variadicTuples1.ts, 282, 32))
->c : Symbol(c, Decl(variadicTuples1.ts, 282, 43))
+>fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 286, 1))
+>a : Symbol(a, Decl(variadicTuples1.ts, 288, 22))
+>b : Symbol(b, Decl(variadicTuples1.ts, 288, 32))
+>c : Symbol(c, Decl(variadicTuples1.ts, 288, 43))
 
 curry2(fn10, ['hello', 42], [true]);
->curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 274, 30))
->fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 280, 1))
+>curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 280, 30))
+>fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 286, 1))
 
 curry2(fn10, ['hello'], [42, true]);
->curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 274, 30))
->fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 280, 1))
+>curry2 : Symbol(curry2, Decl(variadicTuples1.ts, 280, 30))
+>fn10 : Symbol(fn10, Decl(variadicTuples1.ts, 286, 1))
 
 // Last argument is contextually typed
 
 declare function call<T extends unknown[], R>(...args: [...T, (...args: T) => R]): [T, R];
->call : Symbol(call, Decl(variadicTuples1.ts, 285, 36))
->T : Symbol(T, Decl(variadicTuples1.ts, 289, 22))
->R : Symbol(R, Decl(variadicTuples1.ts, 289, 42))
->args : Symbol(args, Decl(variadicTuples1.ts, 289, 46))
->T : Symbol(T, Decl(variadicTuples1.ts, 289, 22))
->args : Symbol(args, Decl(variadicTuples1.ts, 289, 63))
->T : Symbol(T, Decl(variadicTuples1.ts, 289, 22))
->R : Symbol(R, Decl(variadicTuples1.ts, 289, 42))
->T : Symbol(T, Decl(variadicTuples1.ts, 289, 22))
->R : Symbol(R, Decl(variadicTuples1.ts, 289, 42))
+>call : Symbol(call, Decl(variadicTuples1.ts, 291, 36))
+>T : Symbol(T, Decl(variadicTuples1.ts, 295, 22))
+>R : Symbol(R, Decl(variadicTuples1.ts, 295, 42))
+>args : Symbol(args, Decl(variadicTuples1.ts, 295, 46))
+>T : Symbol(T, Decl(variadicTuples1.ts, 295, 22))
+>args : Symbol(args, Decl(variadicTuples1.ts, 295, 63))
+>T : Symbol(T, Decl(variadicTuples1.ts, 295, 22))
+>R : Symbol(R, Decl(variadicTuples1.ts, 295, 42))
+>T : Symbol(T, Decl(variadicTuples1.ts, 295, 22))
+>R : Symbol(R, Decl(variadicTuples1.ts, 295, 42))
 
 call('hello', 32, (a, b) => 42);
->call : Symbol(call, Decl(variadicTuples1.ts, 285, 36))
->a : Symbol(a, Decl(variadicTuples1.ts, 291, 19))
->b : Symbol(b, Decl(variadicTuples1.ts, 291, 21))
+>call : Symbol(call, Decl(variadicTuples1.ts, 291, 36))
+>a : Symbol(a, Decl(variadicTuples1.ts, 297, 19))
+>b : Symbol(b, Decl(variadicTuples1.ts, 297, 21))
 
 // Would be nice to infer [...string[], (...args: string[]) => number] here
 // Requires [starting-fixed-part, ...rest-part, ending-fixed-part] tuple structure
 
 call(...sa, (...x) => 42);
->call : Symbol(call, Decl(variadicTuples1.ts, 285, 36))
+>call : Symbol(call, Decl(variadicTuples1.ts, 291, 36))
 >sa : Symbol(sa, Decl(variadicTuples1.ts, 29, 13))
->x : Symbol(x, Decl(variadicTuples1.ts, 296, 13))
+>x : Symbol(x, Decl(variadicTuples1.ts, 302, 13))
 
diff --git a/tests/baselines/reference/variadicTuples1.types b/tests/baselines/reference/variadicTuples1.types
index 616127e76172c..430ff6483e472 100644
--- a/tests/baselines/reference/variadicTuples1.types
+++ b/tests/baselines/reference/variadicTuples1.types
@@ -117,6 +117,34 @@ const tc4 = concat(sa, [1, 2, 3]);  // Ideally would be [...string[], number, nu
 >2 : 2
 >3 : 3
 
+function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) {
+>concat2 : <T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) => (T[number] | U[number])[]
+>t : T
+>u : U
+
+    return [...t, ...u];  // (T[number] | U[number])[]
+>[...t, ...u] : (T[number] | U[number])[]
+>...t : unknown
+>t : T
+>...u : unknown
+>u : U
+}
+
+const tc5 = concat2([1, 2, 3] as const, [4, 5, 6] as const);  // (1 | 2 | 3 | 4 | 5 | 6)[]
+>tc5 : (2 | 4 | 1 | 3 | 6 | 5)[]
+>concat2([1, 2, 3] as const, [4, 5, 6] as const) : (2 | 4 | 1 | 3 | 6 | 5)[]
+>concat2 : <T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) => (T[number] | U[number])[]
+>[1, 2, 3] as const : readonly [1, 2, 3]
+>[1, 2, 3] : readonly [1, 2, 3]
+>1 : 1
+>2 : 2
+>3 : 3
+>[4, 5, 6] as const : readonly [4, 5, 6]
+>[4, 5, 6] : readonly [4, 5, 6]
+>4 : 4
+>5 : 5
+>6 : 6
+
 // Spread arguments
 
 declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;
diff --git a/tests/cases/conformance/types/tuple/variadicTuples1.ts b/tests/cases/conformance/types/tuple/variadicTuples1.ts
index ca9087af294b8..e7751d0860fba 100644
--- a/tests/cases/conformance/types/tuple/variadicTuples1.ts
+++ b/tests/cases/conformance/types/tuple/variadicTuples1.ts
@@ -37,6 +37,12 @@ const tc2 = concat(['hello'], [42]);
 const tc3 = concat([1, 2, 3], sa);
 const tc4 = concat(sa, [1, 2, 3]);  // Ideally would be [...string[], number, number, number]
 
+function concat2<T extends readonly unknown[], U extends readonly unknown[]>(t: T, u: U) {
+    return [...t, ...u];  // (T[number] | U[number])[]
+}
+
+const tc5 = concat2([1, 2, 3] as const, [4, 5, 6] as const);  // (1 | 2 | 3 | 4 | 5 | 6)[]
+
 // Spread arguments
 
 declare function foo1(a: number, b: string, c: boolean, ...d: number[]): void;