Typescript incorrectly narrows types when indexing into a union of arrays

[Jaymoss520]

Bug Report

⏯ Playground Link

Playground link

💻 Code

interface A {
    first: any;
    second: any;
}

interface B {
    second: any;
}

function func(array: A[] | B[]) {
    const item = array[0];
    // typescript assumes item is of type 'B'

    if ('first' in item) {
        // typescript thinks this is impossible
        return item.first;
    }
}

🙁 Actual behavior

Typescript assumes that item is of type B.

Furthermore, when I try to narrow the type to A in order to access item.first, I get an error that says:

Property 'first' does not exist on type 'never'.(2339)

🙂 Expected behavior

Typescript should infer that item is of type A | B, not B.

The error does not occur when A is not a supertype of B

Also, the error does not occur when array has type (A | B)[] instead of A[] | B[]. The problem is that sometimes the latter type is the implied by typescript when accessing the properties of union types. Consider the following example:

interface C {
    items: A[]
}

interface D {
    items: B[]
}

function bar (value: C | D) {
    const item = value.items[0];
    // typescript assumes item is of type 'B'

    if ('first' in item) {
        // typescript thinks this is impossible
        return item.first;
    }
}

[RyanCavanaugh]

This is a widening, not a narrowing.

There isn't much we can do here; subtype reduction is necessary for many other things to work. You can declare A and B such that they are mutually exclusive if this is the case, otherwise a type assertion is appropriate here.

[Jaymoss520]

I understand if it's a design limitation but I don't know what you mean by "This is a widening, not a narrowing." In the example I gave, typescript assumes that item is of type B, which would be a narrowing no? (since it's a strict subset of the types that are actually possible, i.e. A OR B).

Also, I'm curious, what "other things" would not work if typescript inferred that item had type A | B instead of B?