Inconsistent behaivor between Pick<T,K> and [P in K]: T[K]

[weichensw]

TypeScript Version: 3.2.0-dev.20181107

Search Terms:
Pick Inconsistent readonly optional

Code

interface T {
    a: string;
    b?: string;
    c: string;
    readonly d: string;
    readonly e?: string;
}
type Test = Pick<T, Exclude<keyof T, 'c'>>;
type Test1 = { [P in Exclude<keyof T, 'c'>]: T[P]; };

Expected behavior:
Test1 should be equal to Test, as it is just an inline version of it

Actual behavior:
Test1 removed any optional or readonly on properties, while Test doesn't.

Playground Link:
Playground

Related Issues:
#14295

[jack-williams]

I'm afraid I can't help fix this issue, but here are some more examples that might help diagnose the problem.

interface T {
    a: string;
    b?: string;
    c: string;
    readonly d: string;
    readonly e?: string;
}

type Alias<T> = T extends unknown ? keyof T : never;
type Mapped<T> = { [P in (T extends unknown ? keyof T : never)]: T[P] };
type MappedKeyof<T> = { [P in (keyof T extends unknown ? keyof T : never)]: T[P] };
type MappedAlias<T> = { [P in Alias<T>]: T[P] };
type A = Mapped<T>; // does not have '?'
type B = MappedKeyof<T>; // has '?'
type C = MappedAlias<T>; // does not have '?'

I find the difference between A and B especially odd.

[jcalz]

Yeah, the only way I know to get homomorphic mapped types over a subset of the keys of a type is to use a type alias featuring both the type parameter X and another parameter Y constrained to keyof X, and then map over Y:

type Foo<Y extends keyof X, X> = {[P in Y]: Bar<P>};

type Homomorphic = Foo<"a", {readonly a?: string}>
// type Homomorphic = {readonly a?: Bar<"a">}

Looks like that was specifically done to make Pick<T, K> work, according to #14295 and its linked issues / pull requests.

I don't know how you'd make the inline version work the same way, without possibly making other mapped types suddenly become homomorphic with respect to some unexpected types. You'd need to make {[P in Baz<T>]: Bar<P>} divine from Baz<T> what type to copy the modifiers from. That's obvious if Baz<T> is literally keyof T, and is arguably obvious-ish if it's like Exclude<keyof T, "c">, but what do you do with keyof T & keyof U or keyof T | keyof U or X extends Y ? keyof T : keyof U etc?

[weichensw]

Thanks for the insight @jcalz. That make sense. Closing the issue.