Type guard failures with expressions that can use for type guards

[falsandtru]

TypeScript Version: 2.0.0

Code

class A<T> {
  private _: T;
}
class B<T> {
  private _: T;
}
function f() {
  var o: A<void> | B<void> = new A<void>();
  o instanceof A || o instanceof B;
  o; // A<any>, should be A<void> | B<void>
}

Expected behavior:

A type of o after expr is A<void> | B<void>.

Actual behavior:

A type of o after expr is A<any>.

[yortus]

Looks like same thing as #9861. It's due to the new A<void> assignment. The type of o from that point onward is narrowed to A<void>. Add an extra line before the expression to see this:

class A<T> {
  private _: T;
}
class B<T> {
  private _: T;
}
function f() {
  var o: A<void> | B<void> = new A<void>();
  o; // A<void>
  o instanceof A || o instanceof B;
  o; // A<any>, should be A<void> | B<void>
}

I'm not sure why it changes from A<void> to A<any> though....

[mhegazy]

Same as #9861. please keep the discussion in #9859

[yortus]

@mhegazy there is something odd about the inferred type of o changing from A<void> to A<any> after the expression, which is not captured in #9861. That part is a different issue - could it be a bug? Or otherwise is there an explanation for the change to the inferred type after the expression?

[mhegazy]

you are right. it should be A<void>. this looks like a bug.

[yortus]

Another repro:

function f() {
    var s: Set<string> | Set<number>;

    s = new Set<number>();
    s; // Set<number>
    s instanceof Set;
    s; // Set<number>

    s = new Set<number>();
    s; // Set<number>
    s instanceof Set || s instanceof Set;
    s; // Set<any>                                <===== inferred type changed

    s = new Set<number>();
    s; // Set<number>
    s instanceof Set && s instanceof Set;
    s; // Set<any>                                <===== inferred type changed

    s = new Set<number>();
    s; // Set<number>
    s instanceof Set, s instanceof Set;
    s; // Set<number>

    s = new Set<number>();
    s; // Set<number>
    typeof s === 'object' || typeof s === 'object';
    s; // Set<number>
}

[sandersn]

In master, the inferred type is now Set<number> | Set<any>. Which is still wrong.

[sandersn]

Surprisingly, it is supposed to work this way! And after a lot of discussion with @ahejlsberg I think I can explain why.

You need to understand three facts:

1. if affects control flow by splitting it in half and then unioning the result type of the two halves. See example.
2. Conditional expressions are treated just like ifs, even if they're just by themselves in a statement, because side effects can happen in any expression.
3. instanceof can only narrow the generic type A<T> to A<any> because, at runtime, there's no such thing as a type parameter and instanceof operates on the prototype, which will let any A through, regardless of the type of its members.

Example: If control flow

function f(x: string | number) {
    if (typeof x === 'string') {
        throw new Error("I don't handle strings after all!");
    }
    else {
        console.log('numbers are ok');
    }
    return x; // x: number
}

The then-branch of the if narrows x: string but then throws, so it results in x: never. The else-branch narrows x: number and then does nothing to alter the type. That means that the type of x after the if is x: number | never = number.

Complete example

Now let's look at a miniature version of the examples above:

function f(s: Set<string> | Set<number>) {
  s = new Set<number>();
  s instanceof Set || s instanceof Set;
  s; // Set<number> | Set<any>
}

The type of the lone s; gets Set<number> from the assignment s = new Set<number>();. The line s instanceof Set || s instanceof Set is treated like the then-branch of an if, and adds Set<any> to the type. Then else-branch is not present so it doesn't add any type to the union.