Unexpected distributive behaviour on type alias

[realainov]

🔎 Search Terms

distributive conditional types, naked type parameter, type alias, unions

🕗 Version & Regression Information

• This changed between versions 3.8.3 and 3.9.7.
• This is the behavior in every version I tried, and I reviewed the FAQ for entries about distributive conditional types, naked type parameter, type alias, unions.

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.3#code/C4TwDgpgBAaghgGwK7QLxQIxQD5QEwBQBokUAKhALZhToDa8yEAulBAB7AQB2AJgM5Q6AS24AzCACdYzAlCgB+WG048BUJNwDW3APYB3bnPmKhMADSxEKWSagAuKNwgA3KccfO3koiWgAlCH4kBGBacioaAHoolUgAYzC6DEssXDxWXDo8VJx8WxMYgD0FIA

💻 Code

type Value = 1 | 2

type Result = [Value] extends [infer V]
  ? V extends unknown
    ? [V, Value]
    : never
  : never

🙁 Actual behavior

[1, 1] | [2, 2]

🙂 Expected behavior

[1, 1 | 2] | [2, 1 | 2]

Additional information about the issue

It shouldn't work the way it does now, for several reasons:

1. Value is not naked type parameter.
2. Using brackets, distributive behaviour must be disabled.

[RyanCavanaugh]

We have logic that can effectively "narrow a type alias" when it's shown the alias extends some other type variable; seems like it's triggering incorrectly here.

Working version:

type Distrib<T, U = T> = T extends infer V ? [V, U] : never;
type Temp = Distrib<Value>;

[Andarist]

Implementation-wise: the inner Value became a substitution type, so it actually acts as Value & V. And it's being instantiated by a V -> 1 (and later V -> 2) mapper when distributing in the inner conditional type.

An example of a workaround closer to the OP's code:

type Temp = [Value, any] extends [infer V, any]
  ? V extends unknown
    ? [V, Value]
    : never
  : never

[realainov]

Thanks for the reply.

[RyanCavanaugh]

And it's being instantiated by a V -> 1 (and later V -> 2) mapper when distributing in the inner conditional type.

I feel like this is a bug - a substitution type should not be used here because the type variable it was matched to ([Value] extends [infer V]) is not the "same" one that's being instantiated (the iterated V). Thoughts?

[realainov]

We have logic that can effectively "narrow a type alias" when it's shown the alias extends some other type variable;

Now it is clear why this behavior occurs.

Example:

type Value = 1 | 2
type In1<T extends 1> = T

type Test1 = Value extends 1 
  ? In1<Value> // no error here
  : never

It turns out that due to the fact that we narrow the Value to 1, then exactly 1 will fall into the true branch, even if the condition itself is still false.

For the same reason, Value then narrows to V.

But still, I have a suspicion that when you get into the second ternary, the narrowing should no longer occur.

[Andarist]

I feel like this is a bug - a substitution type should not be used here because the type variable it was matched to ([Value] extends [infer V]) is not the "same" one that's being instantiated (the iterated V). Thoughts?

My intuition tells me this is a bug too. Value "needs" to have that substition type though in some cases, skipping it entirely breaks things (see #62768 ). Perhaps there is some rule to be figured out that woudl allow to skip it but I can't think of one right now. This issue also manifests here:

type Result2 = Value2 extends { prop: infer V }
  ? V extends unknown
    ? [V, Value2]
    : never
  : never;

In general, if we think about it... there should be 2 Vs here. One is non-distributive and one is distributive. So I'm thinking this should be reflected in the types so the distribution mapper applied to V wouldn't affect the Value2 & V substition type as that would just refer to the "outer" non-distributive V. This would, if i'm not mistaken, require some changes to getConditionalFlowTypeOfType