From 399528bf3df837f7340445852359978bfd84e4c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Wed, 12 Oct 2022 00:17:21 +0200 Subject: [PATCH 1/6] Infer fixed-size tuples from infer type parameters with extends clauses at variadic positions --- src/compiler/checker.ts | 24 ++++++++--- ...ixedTupleExtendsAtVariadicPosition.symbols | 41 +++++++++++++++++++ ...hFixedTupleExtendsAtVariadicPosition.types | 27 ++++++++++++ ...WithFixedTupleExtendsAtVariadicPosition.ts | 22 ++++++++++ 4 files changed, 108 insertions(+), 6 deletions(-) create mode 100644 tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols create mode 100644 tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types create mode 100644 tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9ebaca719f2b9..9ebafeea78d62 100644 --- a/src/compiler/checker.ts +++ b/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) { diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols new file mode 100644 index 0000000000000..203ed7e4a4189 --- /dev/null +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols @@ -0,0 +1,41 @@ +=== tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts === +// repro #51138 + +type SubTup2FixedLength = 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 [ +>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)) + diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types new file mode 100644 index 0000000000000..a5a67193ce85b --- /dev/null +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts === +// repro #51138 + +type SubTup2FixedLength = T extends [ +>SubTup2FixedLength : SubTup2FixedLength + + ...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 [ +>SubTup2Variadic : SubTup2Variadic + + ...infer B extends [any, any], + ...any +] + ? B + : never; + +type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; +>SubTup2VariadicTest : [a: 0, b: 1] + diff --git a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts new file mode 100644 index 0000000000000..e663e8f693c8d --- /dev/null +++ b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts @@ -0,0 +1,22 @@ +// @strict: true +// @noEmit: true + +// repro #51138 + +type SubTup2FixedLength = T extends [ + ...infer B extends [any, any], + any +] + ? B + : never; + +type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>; + +type SubTup2Variadic = T extends [ + ...infer B extends [any, any], + ...any +] + ? B + : never; + +type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; From 3bdd8604a4f37e04bd3a57bd4c796b2d5a5dd09b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Wed, 12 Oct 2022 23:02:29 +0200 Subject: [PATCH 2/6] Improve the fix to handle tuples with leading variadic elements --- src/compiler/checker.ts | 32 +++++--- ...ixedTupleExtendsAtVariadicPosition.symbols | 75 +++++++++++++++++++ ...hFixedTupleExtendsAtVariadicPosition.types | 50 +++++++++++++ ...WithFixedTupleExtendsAtVariadicPosition.ts | 33 ++++++++ 4 files changed, 181 insertions(+), 9 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9ebafeea78d62..468d861c888cd 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -23327,24 +23327,38 @@ namespace ts { else { const middleLength = targetArity - startLength - endLength; 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; + const impliedArity = getInferenceInfoForType(elementTypes[startLength])?.impliedArity; + if (impliedArity !== undefined) { + // Infer slices from source based on implied arity of T. + inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - impliedArity), elementTypes[startLength]); + inferFromTypes(sliceTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]); + } } - else if (elementFlags[startLength] & ElementFlags.Variadic && elementFlags[startLength + 1] & ElementFlags.Rest && isTupleType(source)) { + else if (elementFlags[startLength] & ElementFlags.Variadic && elementFlags[startLength + 1] & ElementFlags.Rest) { // Middle of target is [...T, ...rest] and source is tuple type + // if T is constrained by a fixed-size tuple we might be able to use its arity to infer T const param = getInferenceInfoForType(elementTypes[startLength])?.typeParameter; const constraint = param && getBaseConstraintOfType(param); if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) { - impliedArity = constraint.target.fixedLength; + const impliedArity = constraint.target.fixedLength; + inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]); } } - if (impliedArity !== undefined) { - // Infer slices from source based on implied arity of T. - inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - impliedArity), elementTypes[startLength]); - inferFromTypes(sliceTupleType(source, startLength + impliedArity, endLength), elementTypes[startLength + 1]); + else if (elementFlags[startLength] & ElementFlags.Rest && elementFlags[startLength + 1] & ElementFlags.Variadic && isTupleType(source)) { + // Middle of target is [...rest, ...T] and source is tuple type + // if T is constrained by a fixed-size tuple we might be able to use its arity to infer T + const param = getInferenceInfoForType(elementTypes[startLength + 1])?.typeParameter; + const constraint = param && getBaseConstraintOfType(param); + if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) { + const impliedArity = constraint.target.fixedLength; + const endIndex = sourceArity - getEndElementCount(target.target, ElementFlags.Fixed); + const startIndex = endIndex - impliedArity; + const trailingSlice = createTupleType(getTypeArguments(source).slice(startIndex, endIndex), source.target.elementFlags.slice(startIndex, endIndex), + /*readonly*/ false, source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)); + inferFromTypes(trailingSlice, elementTypes[startLength + 1]); + } } } else if (middleLength === 1 && elementFlags[startLength] & ElementFlags.Variadic) { diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols index 203ed7e4a4189..c34c94f60de10 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols @@ -39,3 +39,78 @@ 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)) +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; +>SubTup2VariadicTest2 : Symbol(SubTup2VariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 18, 73)) +>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74)) + +type SubTup2TrailingVariadic = T extends [ +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 29)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 29)) + + ...any, + ...infer B extends [any, any], +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 10)) + +] + ? B +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 10)) + + : never; + +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; +>SubTup2TrailingVariadicTest : Symbol(SubTup2TrailingVariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 26, 10)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) + +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; +>SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 89)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) + +type SubTup2VariadicWithLeadingFixedElements = T extends [ +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 31, 45)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 31, 45)) + + any, + ...infer B extends [any, any], +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 33, 10)) + + ...any +] + ? B +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 33, 10)) + + : never; + +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; +>SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 10)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) + +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; +>SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 39, 127)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) + +type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 54)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 54)) + + ...any, + ...infer B extends [any, any], +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 44, 10)) + + any, +] + ? B +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 44, 10)) + + : never; + +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; +>SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 48, 10)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) + +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; +>SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 50, 145)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) + diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types index a5a67193ce85b..5fb8bb32cecb3 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types @@ -25,3 +25,53 @@ type SubTup2Variadic = T extends [ type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; >SubTup2VariadicTest : [a: 0, b: 1] +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; +>SubTup2VariadicTest2 : [a: 0, b: 1] + +type SubTup2TrailingVariadic = T extends [ +>SubTup2TrailingVariadic : SubTup2TrailingVariadic + + ...any, + ...infer B extends [any, any], +] + ? B + : never; + +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; +>SubTup2TrailingVariadicTest : [b: 1, c: 2] + +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; +>SubTup2TrailingVariadicTest2 : [c: 2, d: 3] + +type SubTup2VariadicWithLeadingFixedElements = T extends [ +>SubTup2VariadicWithLeadingFixedElements : SubTup2VariadicWithLeadingFixedElements + + any, + ...infer B extends [any, any], + ...any +] + ? B + : never; + +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; +>SubTup2VariadicWithLeadingFixedElementsTest : [b: 1, c: 2] + +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; +>SubTup2VariadicWithLeadingFixedElementsTest2 : [b: 1, c: 2] + +type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ +>SubTup2TrailingVariadicWithTrailingFixedElements : SubTup2TrailingVariadicWithTrailingFixedElements + + ...any, + ...infer B extends [any, any], + any, +] + ? B + : never; + +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; +>SubTup2TrailingVariadicWithTrailingFixedElementsTest : [b: 1, c: 2] + +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; +>SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : [c: 2, d: 3] + diff --git a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts index e663e8f693c8d..99c27baf79187 100644 --- a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts +++ b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts @@ -20,3 +20,36 @@ type SubTup2Variadic = T extends [ : never; type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; + +type SubTup2TrailingVariadic = T extends [ + ...any, + ...infer B extends [any, any], +] + ? B + : never; + +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; + +type SubTup2VariadicWithLeadingFixedElements = T extends [ + any, + ...infer B extends [any, any], + ...any +] + ? B + : never; + +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; + +type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ + ...any, + ...infer B extends [any, any], + any, +] + ? B + : never; + +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; From f92c184c3e336af351ee3612153807f7fcb32c3d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Fri, 25 Nov 2022 08:51:20 +0100 Subject: [PATCH 3/6] Fixed indentation --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 088253a7457e2..7e4b844eb816a 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -24334,7 +24334,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const startIndex = endIndex - impliedArity; const trailingSlice = createTupleType(getTypeArguments(source).slice(startIndex, endIndex), source.target.elementFlags.slice(startIndex, endIndex), /*readonly*/ false, source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)); - inferFromTypes(trailingSlice, elementTypes[startLength + 1]); + inferFromTypes(trailingSlice, elementTypes[startLength + 1]); } } } From 8a60a2813171df018eb3cf268f546ba632a43849 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Mon, 26 Dec 2022 09:01:00 +0100 Subject: [PATCH 4/6] Infer rest element following a variadic element with a fixed-size constraint --- src/compiler/checker.ts | 1 + ...ixedTupleExtendsAtVariadicPosition.symbols | 76 ++++++++++++------- ...hFixedTupleExtendsAtVariadicPosition.types | 12 +++ ...WithFixedTupleExtendsAtVariadicPosition.ts | 9 +++ 4 files changed, 71 insertions(+), 27 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9d6b03dbfa1aa..32a20630803e9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -24325,6 +24325,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (constraint && isTupleType(constraint) && !constraint.target.hasRestElement) { const impliedArity = constraint.target.fixedLength; inferFromTypes(sliceTupleType(source, startLength, sourceArity - (startLength + impliedArity)), elementTypes[startLength]); + inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength + impliedArity, endLength)!, elementTypes[startLength + 1]); } } else if (elementFlags[startLength] & ElementFlags.Rest && elementFlags[startLength + 1] & ElementFlags.Variadic && isTupleType(source)) { diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols index c34c94f60de10..a745f1ea4a19e 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols @@ -43,74 +43,96 @@ type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; >SubTup2VariadicTest2 : Symbol(SubTup2VariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 18, 73)) >SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74)) +type SubTup2VariadicAndRest = T extends [ +>SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 28)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 28)) + + ...infer B extends [any, any], +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 22, 12)) + + ...(infer C)[] +>C : Symbol(C, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 13)) + +] + ? [...B, ...[C]] +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 22, 12)) +>C : Symbol(C, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 13)) + + : never; + +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; +>SubTup2VariadicAndRestTest : Symbol(SubTup2VariadicAndRestTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 26, 12)) +>SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) + type SubTup2TrailingVariadic = T extends [ ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 29)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 29)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 30, 29)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 30, 29)) ...any, ...infer B extends [any, any], ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 32, 10)) ] ? B ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 23, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 32, 10)) : never; type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; ->SubTup2TrailingVariadicTest : Symbol(SubTup2TrailingVariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 26, 10)) ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>SubTup2TrailingVariadicTest : Symbol(SubTup2TrailingVariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 35, 10)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; ->SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 89)) ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 89)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) type SubTup2VariadicWithLeadingFixedElements = T extends [ ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 31, 45)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 31, 45)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 45)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 45)) any, ...infer B extends [any, any], ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 33, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 10)) ...any ] ? B ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 33, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 10)) : never; type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; ->SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 10)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) +>SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 46, 10)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; ->SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 39, 127)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 29, 96)) +>SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 48, 127)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 54)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 54)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 54)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 54)) ...any, ...infer B extends [any, any], ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 44, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 53, 10)) any, ] ? B ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 44, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 53, 10)) : never; type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; ->SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 48, 10)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 57, 10)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; ->SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 50, 145)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 59, 145)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types index 5fb8bb32cecb3..6483eec899cde 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types @@ -28,6 +28,18 @@ type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; >SubTup2VariadicTest2 : [a: 0, b: 1] +type SubTup2VariadicAndRest = T extends [ +>SubTup2VariadicAndRest : SubTup2VariadicAndRest + + ...infer B extends [any, any], + ...(infer C)[] +] + ? [...B, ...[C]] + : never; + +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; +>SubTup2VariadicAndRestTest : [0, 1, number] + type SubTup2TrailingVariadic = T extends [ >SubTup2TrailingVariadic : SubTup2TrailingVariadic diff --git a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts index 99c27baf79187..bdaa795dd2934 100644 --- a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts +++ b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts @@ -22,6 +22,15 @@ type SubTup2Variadic = T extends [ type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicAndRest = T extends [ + ...infer B extends [any, any], + ...(infer C)[] +] + ? [...B, ...[C]] + : never; + +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; + type SubTup2TrailingVariadic = T extends [ ...any, ...infer B extends [any, any], From aef842f457c5c9dada1f808deb3a047e922aeaa2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Mon, 26 Dec 2022 11:27:27 +0100 Subject: [PATCH 5/6] Infer rest element preceding a variadic element with a fixed-size constraint --- src/compiler/checker.ts | 2 + ...ixedTupleExtendsAtVariadicPosition.symbols | 58 +++++++++++++------ ...hFixedTupleExtendsAtVariadicPosition.types | 12 ++++ ...WithFixedTupleExtendsAtVariadicPosition.ts | 9 +++ 4 files changed, 63 insertions(+), 18 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 32a20630803e9..b0d385226bd33 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -24339,6 +24339,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const startIndex = endIndex - impliedArity; const trailingSlice = createTupleType(getTypeArguments(source).slice(startIndex, endIndex), source.target.elementFlags.slice(startIndex, endIndex), /*readonly*/ false, source.target.labeledElementDeclarations && source.target.labeledElementDeclarations.slice(startIndex, endIndex)); + + inferFromTypes(getElementTypeOfSliceOfTupleType(source, startLength, endLength + impliedArity)!, elementTypes[startLength]); inferFromTypes(trailingSlice, elementTypes[startLength + 1]); } } diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols index a745f1ea4a19e..fa15de347bfaf 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols @@ -88,51 +88,73 @@ type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: >SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 89)) >SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) +type SubTup2RestAndTrailingVariadic2 = T extends [ +>SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 37)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 37)) + + ...(infer C)[], +>C : Symbol(C, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 41, 13)) + + ...infer B extends [any, any], +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 12)) + +] + ? [C, ...B] +>C : Symbol(C, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 41, 13)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 12)) + + : never; + +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; +>SubTup2RestAndTrailingVariadic2Test : Symbol(SubTup2RestAndTrailingVariadic2Test, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 45, 12)) +>SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) + type SubTup2VariadicWithLeadingFixedElements = T extends [ ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 45)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 45)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 45)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 45)) any, ...infer B extends [any, any], ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 10)) ...any ] ? B ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 42, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 10)) : never; type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; ->SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 46, 10)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 55, 10)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; ->SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 48, 127)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 57, 127)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 54)) ->T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 51, 54)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 60, 54)) +>T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 60, 54)) ...any, ...infer B extends [any, any], ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 53, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 62, 10)) any, ] ? B ->B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 53, 10)) +>B : Symbol(B, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 62, 10)) : never; type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; ->SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 57, 10)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 66, 10)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; ->SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 59, 145)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 68, 145)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types index 6483eec899cde..ac3740ed4ca72 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types @@ -55,6 +55,18 @@ type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1 type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; >SubTup2TrailingVariadicTest2 : [c: 2, d: 3] +type SubTup2RestAndTrailingVariadic2 = T extends [ +>SubTup2RestAndTrailingVariadic2 : SubTup2RestAndTrailingVariadic2 + + ...(infer C)[], + ...infer B extends [any, any], +] + ? [C, ...B] + : never; + +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; +>SubTup2RestAndTrailingVariadic2Test : [number, 1, 2] + type SubTup2VariadicWithLeadingFixedElements = T extends [ >SubTup2VariadicWithLeadingFixedElements : SubTup2VariadicWithLeadingFixedElements diff --git a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts index bdaa795dd2934..941422921c252 100644 --- a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts +++ b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts @@ -41,6 +41,15 @@ type SubTup2TrailingVariadic = T extends [ type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2RestAndTrailingVariadic2 = T extends [ + ...(infer C)[], + ...infer B extends [any, any], +] + ? [C, ...B] + : never; + +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; + type SubTup2VariadicWithLeadingFixedElements = T extends [ any, ...infer B extends [any, any], From f7478bf72a4626c8aee04feb690d8a7264a868a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Mon, 26 Dec 2022 11:30:23 +0100 Subject: [PATCH 6/6] Rewrite the test to avoid accidental union reductions --- ...ixedTupleExtendsAtVariadicPosition.symbols | 62 +++++++++---------- ...hFixedTupleExtendsAtVariadicPosition.types | 26 ++++---- ...WithFixedTupleExtendsAtVariadicPosition.ts | 22 +++---- 3 files changed, 55 insertions(+), 55 deletions(-) diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols index fa15de347bfaf..6992698a04983 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.symbols @@ -16,12 +16,12 @@ type SubTup2FixedLength = T extends [ : never; -type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>; +type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: 2]>; >SubTup2FixedLengthTest : Symbol(SubTup2FixedLengthTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 7, 10)) >SubTup2FixedLength : Symbol(SubTup2FixedLength, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 0, 0)) type SubTup2Variadic = T extends [ ->SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74)) +>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 69)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 11, 21)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 11, 21)) @@ -35,16 +35,16 @@ type SubTup2Variadic = T extends [ : never; -type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; +type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: 2[]]>; >SubTup2VariadicTest : Symbol(SubTup2VariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 16, 10)) ->SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74)) +>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 69)) -type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; ->SubTup2VariadicTest2 : Symbol(SubTup2VariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 18, 73)) ->SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 74)) +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: 3[]]>; +>SubTup2VariadicTest2 : Symbol(SubTup2VariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 18, 68)) +>SubTup2Variadic : Symbol(SubTup2Variadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 9, 69)) type SubTup2VariadicAndRest = T extends [ ->SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 75)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 28)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 21, 28)) @@ -61,12 +61,12 @@ type SubTup2VariadicAndRest = T extends [ : never; -type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: 2[]]>; >SubTup2VariadicAndRestTest : Symbol(SubTup2VariadicAndRestTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 26, 12)) ->SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 80)) +>SubTup2VariadicAndRest : Symbol(SubTup2VariadicAndRest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 19, 75)) type SubTup2TrailingVariadic = T extends [ ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 82)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 30, 29)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 30, 29)) @@ -80,16 +80,16 @@ type SubTup2TrailingVariadic = T extends [ : never; -type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2]>; >SubTup2TrailingVariadicTest : Symbol(SubTup2TrailingVariadicTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 35, 10)) ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 82)) -type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; ->SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 89)) ->SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 87)) +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2, d: 3]>; +>SubTup2TrailingVariadicTest2 : Symbol(SubTup2TrailingVariadicTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 37, 84)) +>SubTup2TrailingVariadic : Symbol(SubTup2TrailingVariadic, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 28, 82)) type SubTup2RestAndTrailingVariadic2 = T extends [ ->SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 91)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 37)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 40, 37)) @@ -106,12 +106,12 @@ type SubTup2RestAndTrailingVariadic2 = T extends [ : never; -type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: 0[], b: 1, c: 2]>; >SubTup2RestAndTrailingVariadic2Test : Symbol(SubTup2RestAndTrailingVariadic2Test, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 45, 12)) ->SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 96)) +>SubTup2RestAndTrailingVariadic2 : Symbol(SubTup2RestAndTrailingVariadic2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 38, 91)) type SubTup2VariadicWithLeadingFixedElements = T extends [ ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 100)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 45)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 49, 45)) @@ -126,16 +126,16 @@ type SubTup2VariadicWithLeadingFixedElements = T extends [ : never; -type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: 3[]]>; >SubTup2VariadicWithLeadingFixedElementsTest : Symbol(SubTup2VariadicWithLeadingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 55, 10)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 100)) -type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; ->SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 57, 127)) ->SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 105)) +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: 4[]]>; +>SubTup2VariadicWithLeadingFixedElementsTest2 : Symbol(SubTup2VariadicWithLeadingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 57, 122)) +>SubTup2VariadicWithLeadingFixedElements : Symbol(SubTup2VariadicWithLeadingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 47, 100)) type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 129)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 60, 54)) >T : Symbol(T, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 60, 54)) @@ -150,11 +150,11 @@ type SubTup2TrailingVariadicWithTrailingFixedElements = T e : never; -type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3]>; >SubTup2TrailingVariadicWithTrailingFixedElementsTest : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 66, 10)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 129)) -type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; ->SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 68, 145)) ->SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 134)) +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3, e: 4]>; +>SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : Symbol(SubTup2TrailingVariadicWithTrailingFixedElementsTest2, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 68, 140)) +>SubTup2TrailingVariadicWithTrailingFixedElements : Symbol(SubTup2TrailingVariadicWithTrailingFixedElements, Decl(inferTypesWithFixedTupleExtendsAtVariadicPosition.ts, 58, 129)) diff --git a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types index ac3740ed4ca72..416958583480a 100644 --- a/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types +++ b/tests/baselines/reference/inferTypesWithFixedTupleExtendsAtVariadicPosition.types @@ -10,7 +10,7 @@ type SubTup2FixedLength = T extends [ ? B : never; -type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>; +type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: 2]>; >SubTup2FixedLengthTest : [a: 0, b: 1] type SubTup2Variadic = T extends [ @@ -22,10 +22,10 @@ type SubTup2Variadic = T extends [ ? B : never; -type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; +type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: 2[]]>; >SubTup2VariadicTest : [a: 0, b: 1] -type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: 3[]]>; >SubTup2VariadicTest2 : [a: 0, b: 1] type SubTup2VariadicAndRest = T extends [ @@ -37,8 +37,8 @@ type SubTup2VariadicAndRest = T extends [ ? [...B, ...[C]] : never; -type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; ->SubTup2VariadicAndRestTest : [0, 1, number] +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: 2[]]>; +>SubTup2VariadicAndRestTest : [0, 1, 2] type SubTup2TrailingVariadic = T extends [ >SubTup2TrailingVariadic : SubTup2TrailingVariadic @@ -49,10 +49,10 @@ type SubTup2TrailingVariadic = T extends [ ? B : never; -type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2]>; >SubTup2TrailingVariadicTest : [b: 1, c: 2] -type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2, d: 3]>; >SubTup2TrailingVariadicTest2 : [c: 2, d: 3] type SubTup2RestAndTrailingVariadic2 = T extends [ @@ -64,8 +64,8 @@ type SubTup2RestAndTrailingVariadic2 = T extends [ ? [C, ...B] : never; -type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; ->SubTup2RestAndTrailingVariadic2Test : [number, 1, 2] +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: 0[], b: 1, c: 2]>; +>SubTup2RestAndTrailingVariadic2Test : [0, 1, 2] type SubTup2VariadicWithLeadingFixedElements = T extends [ >SubTup2VariadicWithLeadingFixedElements : SubTup2VariadicWithLeadingFixedElements @@ -77,10 +77,10 @@ type SubTup2VariadicWithLeadingFixedElements = T extends [ ? B : never; -type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: 3[]]>; >SubTup2VariadicWithLeadingFixedElementsTest : [b: 1, c: 2] -type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: 4[]]>; >SubTup2VariadicWithLeadingFixedElementsTest2 : [b: 1, c: 2] type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ @@ -93,9 +93,9 @@ type SubTup2TrailingVariadicWithTrailingFixedElements = T e ? B : never; -type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3]>; >SubTup2TrailingVariadicWithTrailingFixedElementsTest : [b: 1, c: 2] -type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3, e: 4]>; >SubTup2TrailingVariadicWithTrailingFixedElementsTest2 : [c: 2, d: 3] diff --git a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts index 941422921c252..89e513adaa0ae 100644 --- a/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts +++ b/tests/cases/compiler/inferTypesWithFixedTupleExtendsAtVariadicPosition.ts @@ -10,7 +10,7 @@ type SubTup2FixedLength = T extends [ ? B : never; -type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: number]>; +type SubTup2FixedLengthTest = SubTup2FixedLength<[a: 0, b: 1, c: 2]>; type SubTup2Variadic = T extends [ ...infer B extends [any, any], @@ -19,8 +19,8 @@ type SubTup2Variadic = T extends [ ? B : never; -type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: number[]]>; -type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: number[]]>; +type SubTup2VariadicTest = SubTup2Variadic<[a: 0, b: 1, ...c: 2[]]>; +type SubTup2VariadicTest2 = SubTup2Variadic<[a: 0, b: 1, c: 2, ...d: 3[]]>; type SubTup2VariadicAndRest = T extends [ ...infer B extends [any, any], @@ -29,7 +29,7 @@ type SubTup2VariadicAndRest = T extends [ ? [...B, ...[C]] : never; -type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: number[]]>; +type SubTup2VariadicAndRestTest = SubTup2VariadicAndRest<[a: 0, b: 1, ...c: 2[]]>; type SubTup2TrailingVariadic = T extends [ ...any, @@ -38,8 +38,8 @@ type SubTup2TrailingVariadic = T extends [ ? B : never; -type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2]>; -type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: number[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicTest = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2]>; +type SubTup2TrailingVariadicTest2 = SubTup2TrailingVariadic<[...a: 0[], b: 1, c: 2, d: 3]>; type SubTup2RestAndTrailingVariadic2 = T extends [ ...(infer C)[], @@ -48,7 +48,7 @@ type SubTup2RestAndTrailingVariadic2 = T extends [ ? [C, ...B] : never; -type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: number[], b: 1, c: 2]>; +type SubTup2RestAndTrailingVariadic2Test = SubTup2RestAndTrailingVariadic2<[...a: 0[], b: 1, c: 2]>; type SubTup2VariadicWithLeadingFixedElements = T extends [ any, @@ -58,8 +58,8 @@ type SubTup2VariadicWithLeadingFixedElements = T extends [ ? B : never; -type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: number[]]>; -type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: number[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, ...d: 3[]]>; +type SubTup2VariadicWithLeadingFixedElementsTest2 = SubTup2VariadicWithLeadingFixedElements<[a: 0, b: 1, c: 2, d: 3, ...e: 4[]]>; type SubTup2TrailingVariadicWithTrailingFixedElements = T extends [ ...any, @@ -69,5 +69,5 @@ type SubTup2TrailingVariadicWithTrailingFixedElements = T e ? B : never; -type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3]>; -type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: number[], b: 1, c: 2, d: 3, e: 4]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3]>; +type SubTup2TrailingVariadicWithTrailingFixedElementsTest2 = SubTup2TrailingVariadicWithTrailingFixedElements<[...a: 0[], b: 1, c: 2, d: 3, e: 4]>;