Type guards not working for indexed types with generics

[TPReal]

TypeScript Version: 2.7

Search Terms: indexed type guard

Code

function f<T extends string>(q: {[k:string]: number | string}, t: T) {
    const v= q[t];
    if (typeof(v)!=="string") {
        const vv: number = v;
    }
}

Expected behavior:
Type of v is string|number, and in the if it is just number. Compiles.

Actual behavior:
Assignment to vv doesn't compile: string not assignable to number. When hovering, type of v is { [k: string]: string | number; }[T], so eliminating string from it does not change the type, it is still the same, and only when assigning to vv it gets resolved to string|number which then causes compilation error.

Changing type of t to string fixes the problem. The problem also appears if q has type keyed by [k in T].

Playground Link: link

Related Issues:

[RyanCavanaugh]

Note that if (typeof v === "number") { works, and should probably be preferred since you really can't be sure undefined isn't in there.

[TPReal]

This code is just for illustration of the compiler problem, and not any good otherwise of course. A snippet where the problem is even more obvious, without such an obvious fix:

function f<T extends string>(q: {[k:string]: number | null}, t: T) {
    const v= q[t];
    if (v) {
        const vv: number = v;
    }
}

Note that this fails only with strict null checks enabled.

[mhegazy]

Narrowing with primitives really does not work with generics.. here is a simpler example:

function f<T extends string | number>(t: T) {
    if (typeof t !== "string") {
        const v: number = t; // Error
    }
}

The issue here is that T has to stay generic. any narrowing we do has to be on the type of the constraint, so in if block t should be T extends number instead of T extends number | string.

[weswigham]

However we could totally improve our behavior and narrow to Exclude<T, string> (and Extract<T, string> in the other branch) now that we have it, which will handle the constraint behaviors while retaining the T relationships 😄

[TPReal]

The problem is that this is a regression - my original example, or something equivalent to it, used to work in some earlier version (I'm not sure which exactly) because q[t] was immediately treated as string | number, at least in the case when the key was declared as [k in T]. So I'm quite sure this is a bug, not just a suggestion.

I think that this is why @mhegazy's example is different than mine, where the type does not really depend on T.

[mhegazy]

u are correct. q[t] is not generic really, since q has an index signature, so regardless of what value t will have the type of q[t] is always 0-order.