Inherited types - array of unions vs union of arrays.

[jkjustjoshing]

I'm trying to upgrade some Typescript 2.0 code to 2.1 and running into an issue. It distills down to the following:

TypeScript Version: 2.1.4

Code

interface Common {
    common: boolean;
}

interface A extends Common {
    a: A[];
}

interface B extends Common {
    b: B[];
}

let items: (A[] | B[]) = [];    
items.map(item => item.common); // Error

let otherItems: (A | B)[] = [];    
otherItems.map(item => item.common); // No error

In both of these situations I would expect no error to occur. Regardless of whether the array has all the same type or a mixture of types, both can be simplified to Common[] which is valid. However, I get the following error:

Cannot invoke an expression whose type lacks a call signature. Type '{ <U>(this: [A, A, A, A, A], callbackfn: (value: A, index: number, array: A[]) => U, thisArg?: an...' has no compatible call signatures.

(A[] | B[]) is the type that truly matches what my data model is, since my code guaranteed that the array only contains one type of object. Therefore, I'd rather not use (A | B)[].

[RyanCavanaugh]

See #11205, #10620, #7294