Type guard not applied for type which is a union with an indexed type

[sylvanaar]

TypeScript Version: 2.7.0-dev.20180105

Code

type union = { foo: { bar: true }, baz: true } | { [key: string]: {} };

const test = (value: union) => {
    if ("foo" in value) {
        if ("bar" in value.foo) { // incorrect error: Property 'foo' does not exist on type '{ [key: string]: {}; }'.
            return value.foo.bar; // incorrect erro:r Property 'foo' does not exist on type '{ [key: string]: {}; }'.
        }
        return value.baz;         // correct error:  Property 'baz' does not exist on type '{ [key: string]: {}; }'
    } else {
        return value.baz;  // knows its {}
    }
};

Expected behavior:
after performing in tests, access to the property tested for should not be an error, we know it is there.

Actual behavior:
error when trying to use the property guarded by the in test.
Property 'foo' does not exist on type '{ [key: string]: {}; }'.

[Jessidhia]

The error seems confusing, but I'm not sure the in check should cause a refinement there.

The property 'foo' most certainly should exist in { [key: string]: {} } because any string key exists in an indexed type... 😕

[sandersn]

The true branch behaves correctly, as @Kovensky points out. Both types could have a member named "foo", and the second error follows on from the first.

I thought the false branch should actually be never, but after looking at the existing test cases, I see that it shouldn't; "prop" in stringIndexed ? stringIndexed["prop"] : stringIndexed["other"] asserts that "prop" exists in the true branch, but doesn't exclude the possibility that it might have some "other" property in the false case.

[Jessidhia]

@sandersn I still think the error message itself is incorrect. { [key: string]: {} } is an indexed type so any string key should be treated as existing in it; the "bar" in value.foo should error saying that bar doesn't exist in {} (depending on how the types are merged).

value.baz also should not be an error; it should be true | {}.

[sandersn]

@Kovensky that's a separate issue, although one that doesn't seem to be reported yet. You don't need to narrow to encounter it:

type U = { foo: { bar: true }, baz: true } | { [key: string]: {} };
declare var u: U;
u.foo
u.baz

Both foo and baz should be present, but neither are. Probably we should have another issue for this suggestion, though.

[sandersn]

@Kovensky I opened #21141 to track your issue.