Don't relate unmatched parameter positions in signatures

src/compiler/checker.ts

@@ -16156,8 +16156,9 @@ namespace ts {
             const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
 
             for (let i = 0; i < paramCount; i++) {
-                const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : getTypeAtPosition(source, i);
-                const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : getTypeAtPosition(target, i);
+                const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+                const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+                if (sourceType && targetType) {
                     // In order to ensure that any generic type Foo<T> is at least co-variant with respect to T no matter
                     // how Foo uses T, we need to relate parameters bi-variantly (given that parameters are input positions,
                     // they naturally relate only contra-variantly). However, if the source and target parameters both have
@@ -16187,6 +16188,7 @@ namespace ts {
                     }
                     result &= related;
                 }
+            }
 
             if (!(checkMode & SignatureCheckMode.IgnoreReturnTypes)) {
                 // If a signature resolution is already in-flight, skip issuing a circularity error

tests/baselines/reference/unmatchedParameterPositions.js

@@ -0,0 +1,13 @@
+//// [unmatchedParameterPositions.ts]
+// Repros from #40251
+
+declare let s: (...items: never[]) => never[];
+let t1: () => unknown[] = s;
+let t2: (...args: []) => unknown[] = s;
+
+
+//// [unmatchedParameterPositions.js]
+"use strict";
+// Repros from #40251
+var t1 = s;
+var t2 = s;

tests/baselines/reference/unmatchedParameterPositions.symbols

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/unmatchedParameterPositions.ts ===
+// Repros from #40251
+
+declare let s: (...items: never[]) => never[];
+>s : Symbol(s, Decl(unmatchedParameterPositions.ts, 2, 11))
+>items : Symbol(items, Decl(unmatchedParameterPositions.ts, 2, 16))
+
+let t1: () => unknown[] = s;
+>t1 : Symbol(t1, Decl(unmatchedParameterPositions.ts, 3, 3))
+>s : Symbol(s, Decl(unmatchedParameterPositions.ts, 2, 11))
+
+let t2: (...args: []) => unknown[] = s;
+>t2 : Symbol(t2, Decl(unmatchedParameterPositions.ts, 4, 3))
+>args : Symbol(args, Decl(unmatchedParameterPositions.ts, 4, 9))
+>s : Symbol(s, Decl(unmatchedParameterPositions.ts, 2, 11))
+

tests/baselines/reference/unmatchedParameterPositions.types

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/unmatchedParameterPositions.ts ===
+// Repros from #40251
+
+declare let s: (...items: never[]) => never[];
+>s : (...items: never[]) => never[]
+>items : never[]
+
+let t1: () => unknown[] = s;
+>t1 : () => unknown[]
+>s : (...items: never[]) => never[]
+
+let t2: (...args: []) => unknown[] = s;
+>t2 : () => unknown[]
+>args : []
+>s : (...items: never[]) => never[]
+

tests/cases/compiler/unmatchedParameterPositions.ts

@@ -0,0 +1,7 @@
+// @strict: true
+
+// Repros from #40251
+
+declare let s: (...items: never[]) => never[];
+let t1: () => unknown[] = s;
+let t2: (...args: []) => unknown[] = s;