Generic symbols without an actual generic type now 'infer' {} instead of any

[dbaeumer]

TypeScript Version: 2.0.2
Code

function bug<T>(obj: T): T {
    if (obj instanceof RegExp) {
        return obj;
    }
    return null;
}

function isArray<T>(arg: any): arg is Array<T> {
    return true;
}

function bug2() {
    let rules: any;

    if (isArray(rules)) {
        let str: string = rules[0];
    }
}

function bug3() {
    let values: any[];
    let strings: string[];

    if (isArray(values)) {
        strings = values;
    }
}

All this code worked in 1.8.10 but now fails in 2.0.2. From what I can read into the error message the taken type when no actual type parameter is provided is now {}. It seemed to was any before. If I change the code to for example

function bug2() {
    let rules: any;

    if (isArray<any>(rules)) {
        let str: string = rules[0];
    }
}

Everything compiles.

[mhegazy]

Generic type parameters with no inference sites always resulted in {} (well at least since TS 1.0).

The issue here is in TS 2.0 we started narrowing any (see #9999). before isArray(rules) did not change the type of rules since rules was declared as any; subsequently rules[0] is any. Now it does change the type to {}[] and thus rules[0] is {} and that is not assignable to string.

so the issue here is that isArray is not defined correctly. the T here is not really infer-able in any way. I understand that it can be useful for casts. consider rewriting it as:

function isArray(arg: any): arg is Array<any>;
function isArray<T>(arg: any): arg is Array<T>;
function isArray<T>(arg: any): arg is Array<T> {
    return true;
}

One thing to note, is this will cause loss of safety. I would recommend defining rules as a union type instead (assuming this is possible).

[mhegazy]

I also should note that #9999 is a breaking change.

[dbaeumer]

Thanks @mhegazy for the quick reply. Your explanation makes sense to me for the isArray case. But why is this failing now:

function bug<T>(obj: T): T {
    if (obj instanceof RegExp) {
        return obj;
    }
    return null;
}

I understand now that obj in the return case is narrowed to RegExp but why is this not assignable anymore to T. obj was T to begin with.

[mhegazy]

This is another change, in the past T was not narrowed, now it is. so RegExp is not assignable to T. I see your point of making the type of obj T & RegExp instead of just RegExp. this is the same issue discussed in #7662.

[mhegazy]

We already narrow using intersection for instanceof if the type is not a subtype of the declared type. so we should do the same for generic type arguments as well.

[Andarist]

@RyanCavanaugh @sandersn the issue here is quite ancient. I took a look at the posted examples and I think that all of them behave OK according to today's expectations. What @mhegazy has diagnosed here as something that should be implemented:

We already narrow using intersection for instanceof if the type is not a subtype of the declared type. so we should do the same for generic type arguments as well.

also does work OK today.

I think it's reasonable to close this issue.