Control Flow Type Inference: Inferred Type Varying by Condition Order

[ethanresnick]

TypeScript Version: nightly (2.1.0-dev.20161006)

Code

type A_or_C_Child = A | C_Child;

interface A {
 a: string;
}

interface B {
 b: string;
}

interface C {
 c: string;
}

interface C_Child extends A, C {
 extra: string;
}

declare function isA(it: any): it is A;
declare function isB(it: any): it is B;
declare function isC(it: any): it is C;
declare function isA_or_C_Child(it: any): it is A_or_C_Child;

let item: any;
if (isA_or_C_Child(item) && !isC(item) && isB(item)) {
 item; // inferred as A & B
}

if (isA_or_C_Child(item) && isB(item) && !isC(item)) {
 item; // inferred as A_or_C_Child & B
}

Expected behavior:
Within the the last two if statements, item should be inferred to be the same type, as both if statements use the same type guards &&ed together.

Actual behavior:
item is (correctly, I think) inferred as A & B in the first if, but as A_or_C_Child & B in the second.

[ethanresnick]

Any idea what's going on here? Can others reproduce?

[mhegazy]

The way narrowing works is by removing types from a union. in some cases, where there are two constraints that are not assignable, an intersection is created, e.g. isA(item) && isB(item).

the first clause isA_or_C_Child(item) narrows the type from any to A | C, !isC() removes the C from the union, then isB() adds the B.

the second one, isA_or_C_Child(item) narrows the type from any to A | C, then we add in the B because of isB(item). then the !isC(item) happens, and at this point we have (A | C ) & B, so trying to remove C from that results in no change.

I suppose this should be fixed by going deep on the intersection to see if we can remove one of the constituents. though it is not clear how this work in more complex situations.

[ethanresnick]

Mohamed Hegazy (@mhegazy) Thanks for the explanation!

[ethanresnick]

This is fixed by #11717