Assignment of a partial type member to an intersection type including the partial does not compile in 2.7.0-dev.20180112

[athasach]

TypeScript Version: 2.7.0-dev.20180112

Code

interface IX {
    x: boolean;
}

function fn<T>(obj: T, props: Partial<T>): (T & IX) {
    const xobj = obj as T & IX;
    xobj.x = true;
    for (const p in props) {
        // The following line causes a compilation error:
        // TS2322: Type 'Partial<T>[keyof T]' is not assignable to type '(T & IX)[keyof T]'.
        xobj[p] = props[p];
    }
    return xobj;
}

Expected behavior:
This should compile since the members of Partial<T> is a subset of the members of (T & IX).
This does compile in 2.7.0-dev.20180108.

Actual behavior:
The following error is emitted when compiled:

index.ts(9,9): error TS2322: Type 'Partial<T>[keyof T]' is not assignable to type '(T & IX)[keyof T]'.
  Type 'T[keyof T]' is not assignable to type '(T & IX)[keyof T]'.
    Type 'T' is not assignable to type 'T & IX'.
      Type 'T' is not assignable to type 'IX'.

Related:

[DanielRosenwasser]

I think this is appropriate. If IX has a property in common with T, then (IX & T)[keyof T] will result in a property that might be more-derived than in T.

[mhegazy]

It is worth nothing that this is a result of #17912. As @DanielRosenwasser noted, the current behavior is correct. since kyeof T can overlap with keyof IX and thus the type of (T & IX)[keyof T] can be more specialized than that of T[keyof T]. in this example if T had a property x :number. the result would be number & boolean which is not just a number.

[DanielRosenwasser]

Here's what I think would be a better workaround:

interface X {
    x: boolean;
}

function fn<T extends Partial<X>>(obj: T, props: Partial<T>): (T & X) {
    const xobj = obj;
    xobj.x = true;
    for (const p in props) {
        xobj[p] = props[p];
    }
    return xobj as T & X;
}

Here, you ensure that common properties of T must be compatible with those of X. The type assertion at the end is basically a way for you to say "this is not just T anymore, the properties of X have been set."

[athasach]

Ah, I overlooked the case of overlapping keys in the type intersection. Thanks for the explanation and the workaround, @DanielRosenwasser and @mhegazy.

[athasach]

@DanielRosenwasser The workaround suggested fails with strictNullChecks and gives the following compilation error:

index.ts(45,9): error TS2322: Type 'Partial<T>[keyof T]' is not assignable to type 'T[keyof T]'.
  Type 'T[keyof T] | undefined' is not assignable to type 'T[keyof T]'.
    Type 'undefined' is not assignable to type 'T[keyof T]'.

To get past this problem, I cast props[p] to T[keyof T]:

interface X {
    x: boolean;
}

function fn<T extends Partial<X>>(obj: T, props: Partial<T>): (T & X) {
    const xobj = obj;
    xobj.x = true;
    for (const p in props) {
        xobj[p] = props[p] as T[keyof T]; // <---
    }
    return xobj as T & X;
}

[mhegazy]

This is another instance of #13195. Partial<T> adds undefined to the domain of the property types. the type system really does not distinguish between an undefined property and one that is optional (meaning either defined or not, but not defined to the value undefined). #13195 tracks that.