`keyof "a"` behaves differently when using a type parameter

TypeScript Version: 2.9.0-dev.20180411

Code

type A = { [P in keyof "a"]?: boolean }; // { padStart?: boolean | undefined, ... }
type Indirect<T> = { [P in keyof T]?: boolean };
type B = Indirect<"a">; // "a"

declare const a: A;
const b: B = a; // Error

Expected behavior:

No error. B is the same as A.

Actual behavior:

Error: B is the string literal type "a".

[ahejlsberg]

This is working as intended. When instantiating a homomorphic mapped type such as { [P in keyof T]?: boolean } we distribute over union types and leave non-object types unchanged. For example, Indirect<{ x: string } | undefined> is resolved as Indirect<{ x: string }> | undefined. For this reason, Indirect<"a"> is simply "a".

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.

[aleclarson]

we distribute over union types and leave non-object types unchanged

What does it mean to "distribute over union types"?

Also, it seems that as long as I avoid using keyof inside the generic "mapped type" declaration, I can avoid this footgun. See here: https://goo.gl/DakrYm

What's the practical benefit of making keyof behave differently when inside a generic "mapped type"? Or is it simply a consequence of the current implementation?