Infer fixed-size tuples from infer type parameters with extends clauses at variadic positions

Author: Andarist

src/compiler/checker.ts

@@ -23326,13 +23326,25 @@ namespace ts {
                             }
                             else {
                                 const middleLength = targetArity - startLength - endLength;
-                                if (middleLength === 2 && elementFlags[startLength] & elementFlags[startLength + 1] & ElementFlags.Variadic && isTupleType(source)) {
-                                    // Middle of target is [...T, ...U] and source is tuple type
-                                    const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
-                                    if (targetInfo && targetInfo.impliedArity !== undefined) {
+                                if (middleLength === 2) {
+                                    let impliedArity: number | undefined;
+
+                                    if (elementFlags[startLength] & elementFlags[startLength + 1] & ElementFlags.Variadic && isTupleType(source)) {
+                                        // Middle of target is [...T, ...U] and source is tuple type
+                                        impliedArity = getInferenceInfoForType(elementTypes[startLength])?.impliedArity;
+                                    }
+                                    else if (elementFlags[startLength] & ElementFlags.Variadic && elementFlags[startLength + 1] & ElementFlags.Rest && isTupleType(source)) {
+                                        // Middle of target is [...T, ...rest] and source is tuple type
+                                        const param = getInferenceInfoForType(elementTypes[startLength])?.typeParameter;
+                                        const constraint = param && getBaseConstraintOfType(param);
+                                        if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) {
+                                            impliedArity = constraint.target.fixedLength;
+                                        }
+                                    }
+                                    if (impliedArity !== undefined) {
                                         // Infer slices from source based on implied arity of T.
-                                        inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]);
-                                        inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]);
+                                        inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - impliedArity), elementTypes[startLength]);
+                                        inferFromTypes(sliceTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]);
                                     }
                                 }
                                 else if (middleLength === 1 && elementFlags[startLength] & ElementFlags.Variadic) {

tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols

@@ -0,0 +1,41 @@
+=== tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts ===
+// repro #51138
+
+type SubTup2FixedLength<T extends unknown[]> = T extends [
+>SubTup2FixedLength : Symbol(SubTup2FixedLength, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 0, 0))
+>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 2, 24))
+>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 2, 24))
+
+  ...infer B extends [any, any],
+>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 3, 10))
+
+  any
+]
+  ? B
+>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 3, 10))
+
+  : never;
+
+type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>;
+>SubTup2FixedLengthTest : Symbol(SubTup2FixedLengthTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 7, 10))
+>SubTup2FixedLength : Symbol(SubTup2FixedLength, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 0, 0))
+
+type SubTup2Variadic<T extends unknown[]> = T extends [
+>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74))
+>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 11, 21))
+>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 11, 21))
+
+  ...infer B extends [any, any],
+>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 12, 10))
+
+  ...any
+]
+  ? B
+>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 12, 10))
+
+  : never;
+
+type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>;
+>SubTup2VariadicTest : Symbol(SubTup2VariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 16, 10))
+>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74))
+

tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts ===
+// repro #51138
+
+type SubTup2FixedLength<T extends unknown[]> = T extends [
+>SubTup2FixedLength : SubTup2FixedLength<T>
+
+  ...infer B extends [any, any],
+  any
+]
+  ? B
+  : never;
+
+type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>;
+>SubTup2FixedLengthTest : [a: 0, b: 1]
+
+type SubTup2Variadic<T extends unknown[]> = T extends [
+>SubTup2Variadic : SubTup2Variadic<T>
+
+  ...infer B extends [any, any],
+  ...any
+]
+  ? B
+  : never;
+
+type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>;
+>SubTup2VariadicTest : [a: 0, b: 1]
+

tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts

@@ -0,0 +1,22 @@
+// @strict: true
+// @noEmit: true
+
+// repro #51138
+
+type SubTup2FixedLength<T extends unknown[]> = T extends [
+  ...infer B extends [any, any],
+  any
+]
+  ? B
+  : never;
+
+type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>;
+
+type SubTup2Variadic<T extends unknown[]> = T extends [
+  ...infer B extends [any, any],
+  ...any
+]
+  ? B
+  : never;
+
+type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>;