Conditional type doesn't go to true or false branch.

[alexeymolchan]

Bug Report

🔎 Search Terms

generic conditional types

already checked https://github.com/Microsoft/TypeScript/wiki/FAQ#common-bugs-that-arent-bugs and #31751

🕗 Version & Regression Information

3.9.7 / 4.6.2

⏯ Playground Link

Playground link with relevant code

💻 Code

type Action<P, T = never> = { type: string; payload: P } & ([T] extends [never] ? { metaSkipped: true } : { meta: T });

function prepareAction<P, T extends Record<string, unknown> = Record<string, unknown>>(action: Action<P, T>): void {
    action.meta // Property 'meta' does not exist on type 'Payload<P, T>'.(2339)
    action.metaSkipped  // Property 'metaSkipped' does not exist on type 'Payload<P, T>'.(2339)
}

🙁 Actual behavior

properties from intersection are not accessible (conditional type doesn't resolve as true / false branch)

🙂 Expected behavior

conditional type should go to false branch. correct my please if i'm wrong

Thanks in advance.

[MartinJohns]

Resolving of conditional types involving unbound generic type arguments is deferred. At that point the compiler doesn't know what Action<P, T> resolves to, because the compiler doesn't know what types P and T are.

[alexeymolchan]

@MartinJohns thanks for clarification, but i still don't understand. why it doesn't know what result of conditional type if i'm telling it that T will extend Record<string, unknown>

[MartinJohns]

T can still be never, as never also extends Record<string, unknown>. TypeScript simply does not resolve conditional types involving unbound generic types, even if theoretically in some specific corner cases it could.

[alexeymolchan]

@MartinJohns playground but why this works ?

[RyanCavanaugh]

if i'm telling it that T will extend Record<string, unknown>

Conditional types are not necessarily linear (meaning that they have predictable behavior between T and an a subtype of T), and figuring out whether or not they are requires reasoning in the form of "Does any type exist such that this type would behave in the other way?", which is not very tractable.

[alexeymolchan]

@RyanCavanaugh okey, but why [T] extends [never] and T extends never produce different results (you can see the example above) ?

[fatcerberus]

@alexeymolchan https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types

T extends ... distributes over unions. [T] extends [...] does not. The former is thus more likely to be deferred than the latter, since it can't know whether to enable the distributive behavior or not until it has a concrete type to work with.

[alexeymolchan]

@fatcerberus as i see from playground where T extends ... no defer occur and i can access action.meta. correct me please, if i'm wrong.

[alexeymolchan]

@MartinJohns mapped type like this type OptionsFlags<Type> = { [Property in keyof Type]: boolean; }; will be deferred too ?

[MartinJohns]

How would the compiler know what the final type will look like without knowing what type T actually is?

[fatcerberus]

To be clear, generics in TS don't work like C++ templates. The compiler only looks at the body of a generic once and tries to determine if it will work for all possible combinations of type parameters, but these checks are necessarily conservative because it would be prohibitively expensive and/or complex to do otherwise.

[typescript-bot]

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