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

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:

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.

Daniel Rosenwasser (@DanielRosenwasser)

It is worth nothing that this is a result of #17912. As Daniel Rosenwasser (@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.

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."

Daniel Rosenwasser (@DanielRosenwasser)

Ah, I overlooked the case of overlapping keys in the type intersection. Thanks for the explanation and the workaround, Daniel Rosenwasser (@DanielRosenwasser) and Mohamed Hegazy (@mhegazy).

Daniel Rosenwasser (@DanielRosenwasser)

Daniel Rosenwasser (@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;
}

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.

Navigation Menu

Repository navigation

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

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

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

Description

Activity

DanielRosenwasser commented on Jan 12, 2018

mhegazy commented on Jan 12, 2018

DanielRosenwasser commented on Jan 13, 2018

athasach commented on Jan 14, 2018

athasach commented on Jan 15, 2018

mhegazy commented on Jan 16, 2018

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions