Control flow analysis: T|T[] case, Array.isArray and else case

[Strate]

TypeScript Version:

1.9.0-dev (nightly)

Code

// A self-contained demonstration of the problem follows...
function <T>(arg: T|T[]) {
  if (Array.isArray(arg)) {
    // arg expected to be T[] here, and it has type T[] (works as expected)
  } else {
    // arg expected to be T here, but it is has type T|T[] (unexpected behaviour)
  }
}

[mhegazy]

do not think this is accurate. T can be an array.

foo<number[]>([[1],[2]]);

[Strate]

Same thing about non generic functions:

arg: string|string[]

[mhegazy]

[Strate]

@mhegazy Sorry for inconvience, there should be a little more complex case.

interface Struct {
    type: string
    [key: string]: any
}
function handle(object: Struct | Struct []) {
    if (Array.isArray(object)) {
        for (let single of object) {
            handle(single)
        }
    } else {
        Object.keys(object).forEach(key => {
            let value = object[key];
            if (Array.isArray(value)) {
                console.log(value.length);
            } else {
                console.log(object.type);
            }
        })
    }
}

This code raises compilation error on typescript 1.9.0-dev.20160602-1.0 on line console.log(object.type):

 error TS2339: Property 'type' does not exist on type 'Struct | Struct[]'. 

But with typescript 1.8 everything is ok.

[mhegazy]

The issue is a change in how narowing works. in TS 1.8 narrowing worked cross function expression/lambda expression, which was not correct; the compiler has no guarantee that forEach will call the lambda expression immediately, so making assumptions about the type of object is not correct. you can find more information about this in #7719 (comment)

if object was a const, the compiler will narrow correctly the type through the function expressions, as it knows it can not be modified once captured. so:

function handle(obj: Struct | Struct []) {
    const object = obj;  // capture it in a const
    if (Array.isArray(object)) {
        for (let single of object) {
            handle(single)
        }
    } else {
        Object.keys(object).forEach(key => {
            let value = object[key];
            if (Array.isArray(value)) {
                console.log(value.length);
            } else {
                console.log(object.type);
            }
        })
    }
}

You would probably like to get the same behavior for function arguments, except that there is no way to tell the compiler that these are "constant" like variables or "readonly" like members. We have recently discussed allowing a const modifier on function arguments, that will allow the compiler to make these assumptions without giving up on safety. you can find more about this in #8908.