Same type evaluated differently when in a Tuple or by itself

[188599]

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about _________

⏯ Playground Link

Playground link with relevant code

💻 Code

Considering the following code:

type TypeWithoutTuple<T> = [T, Partial<T>];
type TypeWithTuple<T> = T | [T, Partial<T>];

interface A {
    a: number;
    b: string;
}

class A { }

const funcNotUsingTupleType = <
    T extends readonly unknown[]
    >(...args: [...{ [K in keyof T]: TypeWithoutTuple<T[K]> }]) => { }

const funcUsingTupleType = <
    T extends readonly unknown[]
    >(...args: [...{ [K in keyof T]: TypeWithTuple<T[K]> }]) => { }


funcNotUsingTupleType([new A(), {}]) // infers the typying <[A]>(things_0: ThingNoTuple<A>) => void

funcUsingTupleType([new A(), {}]) // infers the typying <[{}]>(things_0: TypeWithTuple<{}>) => void

🙁 Actual behavior

The same calls to funcNotUsingTupleType and funcUsingTupleType have different inferred typyings, even when they are evaluating the same thing.

🙂 Expected behavior

The same calls to funcNotUsingTupleType and funcUsingTupleType to have the same inferred typyings.

[RyanCavanaugh]

These are both valid inferences.

In the first case, because TypeWithoutTuple is just a tuple type, we can safely collect inference candidates based on the tuple positions.

In the second case, TypeWithTuple has the possibility of T, so it's not safe to collect inference candidates from the tuple positions, so instead the type of the array literal gets computed (and reduced to { }, since we can't see at this point that {} is supposed to be a Partial<A>).

This might be solved with #30134 but in general an inference onto type S<T> = T | U<T> is not going to be able to produce as good as inference as one without it.

[188599]

I see, I figured it might be worth bringing this up here because I had this working with multiple generic types before, something like this:

const funcUsingTupleTypeWithoutRestParamsGeneric = <T1, T2, T3>(...args: [TypeWithTuple<T1>, TypeWithTuple<T2>?, TypeWithTuple<T3>?]) => { }

funcUsingTupleTypeWithoutRestParamsGeneric([new A(), {}]) // infers the typing <A, unknown, unknown>(args_0: TypeWithTuple<A>, args_1?: unknown, args_2?: unknown) => void

And I figured that converting to this other way I mentioned on the issue would work just as well.

[github-actions]

This issue has been marked as 'Not a Defect' and has seen no recent activity. It has been automatically closed for house-keeping purposes.