Partial and Readonly are not commutative when using generics

[sccolbert]

TypeScript Version: 2.4.2

Code

type State = {
    [key: string]: string | boolean | number | null;
};


type Args1<T extends State> = {
    readonly previous: Readonly<Partial<T>>;
    readonly current: Readonly<Partial<T>>;
};


type Args2<T extends State> = {
    readonly previous: Partial<Readonly<T>>;
    readonly current: Partial<Readonly<T>>;
};


function doit<T extends State>() {
    let previous: Partial<T> = Object.create(null);
    let current: Partial<T> = Object.create(null);
    let args1: Args1<T> = { previous, current };  // not okay
    let args2: Args2<T> = { previous, current };  // okay
}


type State2 = { foo: number, bar: string };


type Args3 = {
    readonly previous: Readonly<Partial<State2>>;
    readonly current: Readonly<Partial<State2>>;
};


type Args4 = {
    readonly previous: Partial<Readonly<State2>>;
    readonly current: Partial<Readonly<State2>>;
};


function doit2() {
    let previous: Partial<State2> = Object.create(null);
    let current: Partial<State2> = Object.create(null);
    let args1: Args3 = { previous, current };  // okay
    let args2: Args4 = { previous, current };  // okay
}

Expected behavior:

All examples compile.

Actual behavior:

The generic args only compile if Partial and Readonly are applied in a specific order.

[mhegazy]

@ahejlsberg our current comparison logic makes it so that mapped types are not commutative. also the special handling we have for Partial<T> to be assignable from {} will not work if Partial is wrapped in any other mapped type. should be have some special handling for Readonly as well, and treat it like an identity mapper, i.e. U is assignable to Readonly<T> iff U is assignable to T.