Key in mapped type not traversed when there's a something-with-generics extends clause in it

[Holzchopf]

🔎 Search Terms

mapped conditional type keyof generic extends ternary

🕗 Version & Regression Information

• This changed between versions 4.0.5 and 4.1.5
  (Because the mapped type wouldn't work prior to 4.1)

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.2#code/KYDwDg9gTgLgBDAnmYcCyBDMKAmAVCPKDAN2CgGdgcAePAPjgF4BYAKDjgG93POBtANJwAlgDs4Aa2CIIAMzh44GCoqEBdOKBjAxOVRjGI4AfjjCAXOfVWA5DGJlK1W7zgBfduyQo4ACQgnPAALEQoARmZ0LFwCIlJyKloeDmUjAAUoCDArQ0Q3CgdM7KtCqHEAczcIACMAK2KcuFq64ABjGHZ3enYAel64QBRyQHg-5QAbMbgwLJRYEWADKFQxCAB3OAAiBwTnHA2LPoGfVACg0IiolP6+TjzGqy3HROoNgG5Dm7gy+83tpyS3h8bi0fo8dgD3mxrp42N5kCdAuQQmEAEx0RhMaLYahxJ67GgpW4ZGa5IwFIokr4OSrVeo-PBdHpQgaAGXJmnSZqJVABbMIUSoHZkIeH+RFQZEUNEMS5Avh3Slg-4vSHXG7fBV-Z57FUDGFw3ynJHnADM6KimGx+EIeKSBLc8pKaXyqXVjrKNNSIMpACV2tBaNJZAo8AAaOBiACu3Jq5CZ3Q+bK92S5cF5FH5Ygqguux1FZzCpulmKuAxuDqaiq1gKFaopjsru2r0KAA

💻 Code

export type MappedToTraversed<T> =
  {
    [K in keyof T as T[K] extends any ? K : K]: 'traversed'
  }

type HoverThis1 = MappedToTraversed<{
  anyProp: any
  strProp: string
  objProp: object
}>
// ✔️ all properties are now "traversed":
// type HoverThis1 = {
//     anyProp: "traversed";
//     strProp: "traversed";
//     objProp: "traversed";
// }

type HoverThis2<T> = MappedToTraversed<{
  anyProp: any
  strProp: string
  objProp: T
}>
// ❌ objProp is missing:
// type HoverThis2<T> = {
//     anyProp: "traversed";
//     strProp: "traversed";
// }

type HoverThis3<T> = MappedToTraversed<{
  anyProp: any
  strProp: string
  objProp: Record<keyof T, number>
}>
// ❌ objProp is missing:
// type HoverThis3<T> = {
//     anyProp: "traversed";
//     strProp: "traversed";
// }

🙁 Actual behavior

The objProp is missing from the HoverThis types when it is somehow using a generic (e.g. when used as property type or key in a Record). Looks like it is not being traversed during mapping at all due to the extends clause, because the ternary as T[K] extends any ? K : K should IMHO always evaluate to K.

🙂 Expected behavior

objProp should be listed in all HoverThis types.

Additional information about the issue

I think it's due to the extends clause, because if the mapping is simply written as

export type MappedToTraversed<T> =
  {
    [K in keyof T as K]: 'traversed'
  }

objProp is listed in the resulting HoverThis types.

It also fails if

• the ternary is the other way round, i.e. any extends T[K] ? K : K
• the ternary checks something that should always be true T[K] extends T[K] ? K : K
• I try to disable union distribution according to hand book: [T[K]] extends [any] ? K : K

However, if I mess up disabling the union distribution (putting only one side in square brackets), it works..? [T[K]] extends any ? K : K. This feels like an unsafe workaround.

[jcalz]

Is this just a type display issue? If HoverThis2<T> really were collapsed to { anyProp: "traversed", strProp: "traversed"}, then that would be the type no matter what T is specified to be. But if you actually evaluate, say, HoverThis2<number>, you get the expected result:

type Example = HoverThis2<number>;
/* type Example = {
    anyProp: "traversed";
    strProp: "traversed";
    objProp: "traversed";
} */

Playground link

So the type is evaluated correctly, and it's just the generic definition that displays incorrectly?

[Holzchopf]

It's not just a display issue. Yes, once you specify the type parameter, it works on that side. But tsc still doesn't see that property in a generic function, even when the generic type extends something known:

https://www.typescriptlang.org/play/?ts=5.9.2#code/C4TwDgpgBAsghmSATAKgexQJzgNwpgZwiQB4UA+KAXgFgAoKKAb3scYG0BpKASwDsoAawgg0AMygoocApK4BdKBAAewCHySy4fEFAD8UbgC5D8kwHJg2PIWLnWUAL716oSFAASaGygAWPAgBGalgEZHQsXHwiUhYGaR0ABUw0MBNtEAcCK2TUk2zMfgBzBzQAIwArXLSocoqIAGNgekdyFzoxAFc+Jp40AQB3HmBfLx9-IMS4bABbAAowabgZkzH8PwDAgEpmB0XZgDoM6r2lmYOCk-j95YO6q8YG-oI0ABsIA9e0IoWzrZb2kMRmtMBtJmc5kxjikapZrNE7AAaKCXGEWKxRWxIczI+5oqBwzExcyOf50dpuaAgsEAJjIlCooUQxAi8KxJDijGheQSmXiqJ5BWKpUq1RMKBabXJHW6vX6UCBo286wmNKmszISlU6k0zDgJkCyLKJhprV+s1WytBqvpO05UBu525YFOhwFLuuZzuophUAA9H6oIAZcig1XwoAJeNS5igSDQEFkfDQwC1ART8spBPgzNQGDZMQ5vLFvIA3CicvihXwimWozUUGXWvZ4k8+C93p9vublmTnNLFdTVerlpDnej80jy5hi4SbMTcT6ebOEdjSe1XOAqVawQBmekhbPhPNE4gchxj3lZCuCqzC+J1kwAJUaaEwpGEogkKGRfE6MzK+BSq07RdD0wB9IMwxKuMAQ7sOMyaioagaLIUIGkaJpmo6lowQQe4UHarq3M6RHnO6pHelUvoBsGoYwuGujmHWMZxgmUBJimKhprUAiZuYh4ssec6nkwRb4hkZbuvkt7VrWi41M+TxviQH7iJIP5-gBmDkI25DmAcDitu2HxfD8jq9oCUGDrB8Gjkk+LLliOJTjOGLCdiC5UUubkriSWxAA

[jcalz]

But then you're expecting TS to perform higher-order operations on generics, which it hardly ever does. You want it to say "no matter what T happens to be, T[K] extends X ? K : K is going to be K... but that's not what TS ever does, it effectively just says "I don't know T so I can't currently evaluate this". So that is going to turn out to be a design limitation of TypeScript, or maybe a feature request needing something like #27932? I'm not a TS team member so I'll bow out until they say something definitive.

[RyanCavanaugh]

jcalz is correct; we don't have a good mechanism to do correct evaluations of types like this. In most cases if you have some situation where it's demonstrable that a generic type would always produce a certain output, then you don't need that type in the first place, so it's a bit of a moot scenario. In other words there's no reason not to write

[K in keyof T]: 'traversed'

instead, and for the cases where you need something more interesting in the

[K in keyof T as T[K] extends any ? K : K]: 'traversed'

form (replacing any or K with something else) you almost always end up in a situation where it wouldn't be safe to put objProp on the output.

[Holzchopf]

@jcalz and @RyanCavanaugh first of all, let me thank you for taking your time. Of course, you're correct when you say TS can't make assumptions. But I can :P And I'd assume if TS can't make a proper assumption, something like T[K] would end up as unknown instead of just causing the key to be skipped entirely.

To make it clear: My issue is that the K in keyof T... is skipped entirely as soon as there's a T[K] extends (or extends T[K]) in the key. I wouldn't care if TS told me T[K] is unknown (it's actually what I'd expect). But that's not what happens, apparently.

And yes, Ryan, of course the example is moot - I tried to simplify my use case so much that the problem can be pinpointed as exactly as possible. The real world scenario looks more like the playground linked below (don't click it yet, the next paragraph is important).

However, I'm stubborn. So I kept looking for a workaround. Someone will probably stumble across the same issue. I'll share the workaround for my use case (which is making empty object properties optional): Since [K in keyof T] goes through all keys, I can just build an intersection type of all props optional and my mapped type (the one with the generic extends clause).

https://www.typescriptlang.org/play/?#code/PTAEGcAcBsEsBcLwE6wHYHNQENEHJg9R14B7CAUwwFsK15wc0ATUeAV2TWPvICUKAY1LJmAHnBVa9cABokqTAD4AsACh4AT0gVQAUQAeMUswoBlKXQYA5bLABuFMQBVQFA-DrNG4FOgxKoAC8oK7uniyMAAYAJADe6ABmFMigFjRWAL7A8UkpoAK+mVGgAPygcQDaANI8aZb0ALoAXAr+maAAZPpG0CbmDTZ2jmKF8IGtVbXooS1tmJnqIKDIFNSkjjjQ0KCQyKQ6yPCwFIzwABa4oMykaHiIvthHoADuCOc4oMJ9aPLM+5A2OddN9buotDpQAAxWDQTzIAAKT2w1HS0iGDicYQ8XkYAmEogkfkw8l8igCgRCUzqAGsKJpSIlQjhGLVwrjQFFmrk0MlUgjimVQAjQK00BRHMg5mT2uolmAbv4gbp4C9yNgAEYbFXkcLIbCCRBROKQJ4ARlaMoWJUS+2onLw4FItAu-mAzVNyDNeCi4O0ukMKAN8D4pHYniR+uo4BcbhxkXmAWC0Nh8MjKLRVnAtkxYkMxlMmZkOZGziUqjU8tA1GwdNApA1ACshIg9gcUsdTq93qA0OQaX2Xtw24dO4wABRrSBaACU9ensFu2Ggfshemo080AFlsKYAPILpfQWPshMN5uGynqUAVa830A1Wn0xnM7CMOIdU-eUI1RpC2pihKKSNKUrTOL+d4dN0cR3jej4zHSDJMq4b4VJ+8bfuB1R-uU4qSqKoDYWBEFqDeHR3ssarIDSTxhiwoCJCIoDnPA8CQOAzQgBg7zsBqAB0wjUMA1CwII+xOok8DAM4-pmGJsDTsAsDgOA7CnMAABsABMADMADsAAMd7QbBD7TNwiEvs4IHEdhkFypWagkCkiQGroADiFDwAexy3DGobhroX4+MSSYwaRuzItGrSBvqhoBRGUX+WGngVjeACOanIJooEFEIIjiFaGCkqFFaLI56iJOwaCGou3AYF5owpUFGEheSSjjvsgWtAlFDyAcvloBx+gbloO77oeaDLmInneZNyWBeWc7hTeXWeKAyyACjkgDwfwUzVxhE35FXeA11eAfGeiijBbbtMJwik6aooM2bDE4+Z9IWz0lk4vXlqAAA+oDVaYiToBQzAnfNfGZSkmgbWAO15QShWhSV7UA0DLAUKD4oQ2o5XqA18Djng3zQC2Z14PIH5zjdkVRowgjYNwGq6M6CCeKwrNM+wkjEPAjrzoNy69qQLyE15JNkxTflUxU9NXZMHSZLTCO7UzLO6KaKngyybijXD54thLxOk6Q2wy0NctxAr0Xy7AzCtDpoDK6roCIxroCs5FOusKhRuGibUvm+TtV+e60th2gAD6DvWyr8OgIAMuTCgCHZw3gl3RkQynVsp4D+EHZsW1H4ARyHlux8w1u28NNuR75VetHgOlEK7icpwAIg7oAMuw1YUMzbDkC8qDrcXoeDVXeClEXDdneXJdT3H1O15MXwV1HTegC3bcu27O0OcsvP5O4QgpIIykUK0gkwF5KrAl7FB9C8pIULo2DhqQt-k+tMzBnVIukgGDumAdPeQM51BAA

Edit

Comment out lines 17-19 to see my issue in action: without it, options.params on line 30 errors.

[Andarist]

If I'm not mistaken your type can be simplified to:

type EmptyMadeOptional<T extends object> =
  {
    [K in keyof T as {} extends T[K] ? never : K]: T[K]
  } 
  // workaround for https://github.com/microsoft/TypeScript/issues/62370
  & {
    [K in keyof T]?: T[K]
  }

Given the "workaround type" already includes all of the keys as optional, you don't have to include the other constituent that makes some of the keys optional. You only need the constituent that makes some of the keys required (given an optional property intersected with a required one gives u a required property)

[Holzchopf]

That's true yes. Silly me. I somehow forgot about this while simultaneously using that very property for my workaround...

[typescript-bot]

This issue has been marked as "Design Limitation" and has seen no recent activity. It has been automatically closed for house-keeping purposes.