No error when type guard claims the object will have a certain value at a key passed as a string param, but doesn't work.

[krryan]

Came across this while trying to come up with a workaround for #17567 .

TypeScript Version: 2.4.0-dev.20170607

Code

type A = {
    [index: string]: [number, number] | null;
}
const value: A = { foo: [42, 42] };

function hasField(value: A, field: keyof A): value is { [field]: [number, number] } {
    return value[field] !== undefined && value[field] !== null;
}

if (hasField(value, 'foo')) {
    value.foo;
}

Expected behavior:
Ideally, value.foo has type [number, number], but if not, then an error on value is { [field]: [number, number] } saying that this kind of type guard does not work.

Actual behavior:
No errors for the hasField function at all, but value has type {} within the if (hasField(value, 'foo')) block, resulting in an error on value.foo stating that “Property foo does not exist on type {}.”

Note that the behavior is nearly identical if you have

type A = {
    foo?: [number, number] | null;
    bar?: [number, number] | null;
}

In this case, hasField still has a return value (according to VS Code intellisense) of value is {}, and value.foo has a type of [number, number] | null | undefined. So the indexed definition of A doesn't actually affect this.

[DanielRosenwasser]

{ [field]: [number, number] } is not valid syntax. We've discussed something like it before, but what you probably meant was

{ [K in typeof field]: [number, number] }

or

Record<typeof field, [number, number]>

But I think altogether this is going down the wrong path. You may want something closer to

function hasField<K extends string>(value: A, field: K): value is A & Record<K, [number, number]> {
    return value[field] !== undefined && value[field] !== null;
}

[krryan]

Right, that's fine—the bug isn't that it doesn't work, the bug is that there is no error telling you that it doesn't work. If that's not valid syntax, there should be an error saying so, rather than leaving users to find out on their own that the type guard doesn't do what they think it does.

[aluanhaddad]

It seems that some fairly arbitrarily complex expressions are tolerated in the key position of an object literal type that is the object of an is clause.

The following is legal

type A = {
    [index: string]: [number, number] | null;
}
const value: A = { foo: [42, 42] };

function hasField(value: A, field: keyof A): value is {
    [function ns() {
        const x = new class { protected static readonly s: 1 = 'hello' }(12345);
    }()]: [number, number]
} {
    return value[field] !== undefined && value[field] !== null;
}

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.