Distributed keyof over union leads to erroneous indexed access

Bug Report

🕗 Version & Regression Information

This is the behavior in every version I tried

⏯ Playground Link

Playground link with relevant code

💻 Code

type KeyOf<T> = T extends unknown ? keyof T : never

type Wrong<T> = { [K in KeyOf<T>]: T[K] }

🙁 Actual behavior

It is accepted by the type checker, but it shouldn’t be allowed because T could be a union of objects with unrelated properties. The computed type doesn’t even have any sense:

type test= Wrong<{ prop0: string } | { prop1: number; prop2: boolean } | { prop3: string[] }>
//   { prop0: unknown; prop1: unknown; prop2: unknown; prop3: unknown; }

🙂 Expected behavior

K shouldn’t be allowed to index type T.

[bentongxyz]

Hi @RyanCavanaugh, @jfet97, @MartinJohns,

I created a PR that seem to fix this error.

The problem (paste again below) …

type KeyOf<T> = T extends unknown ? keyof T : never;
type Wrong<T> = { [K in KeyOf<T>]: T[K] }
//                                 ^^^^ `K` should not be allowed to index `T`

… seems to be that in structuredTypeRelatedTo (checker.ts L19684-L19691), KeyOf<T> is found to be related to T, because keyof T inside T extends unknown ? keyof T : never returns IndexType.

It seems to be a legit operation if e.g. T extends **object** ? keyof T : never instead of T extends [some union]/ unknown ? keyof T : never.

So my working solution is to guard against return IndexType if the above conditions are met.

I place the logic at getTrueTypeFromConditionalType.

However, I am quite new to this and I am not quite sure:

1. that getTrueTypeFromConditionalType is the right place to place the logic; and
2. what is the right type to return in place of IndexType (I am returning UnknownType)

Please do give me a few pointers whether I am approaching this correctly.

Please do correct me if I am wrong!

Thank you for reviewing!

[bentongxyz]

Hi there, I’d like to take a shot on this issue!