Typecast to any in one array element affects other elements

[DanielSWolf]

TypeScript Version: 3.1.0-dev.20180803

Search Terms: any, object, array, "is not assignable to type"

Code

const x: Array<{ foo: number }> = [
  { foo: 'this is the wrong type' },
  { foo: 42 as any },
];

const y: Array<{ foo: number }> = [
  { foo: 'this is the wrong type' },
  { foo: 42 },
];

Expected behavior:

I expect two build errors: One for the assignment of x, one for y.

This is because both x and y are assigned values of the wrong type. In both cases, not all array elements contain a property foo of type number.

Actual behavior:

There is no build error for the assignment of x, only for the assignment of y. This is the build output:

➜  dev tsc any-test.ts
any-test.ts:6:7 - error TS2322: Type '({ foo: string; } | { foo: number; })[]' is not assignable to type '{ foo: number; }[]'.
  Type '{ foo: string; } | { foo: number; }' is not assignable to type '{ foo: number; }'.
    Type '{ foo: string; }' is not assignable to type '{ foo: number; }'.
      Types of property 'foo' are incompatible.
        Type 'string' is not assignable to type 'number'.

6 const y: Array<{ foo: number }> = [
        ~

In the assignment of x, the foo property of the second array element is converted to any. Rather than converting only this one value to any, TypeScript seems to convert the foo properties of all array elements to any.

Playground Link: Playground demo

Related Issues: none

[RyanCavanaugh]

The algorithm for checking the program works like this:

• Is the initializer assignable to the declared type?
• Let's figure out the type of the initializer
• What the type of the initializer? It's an array of something. What is "something" ?
• It's the union type of all the elements. What's the type of each element?
• First element is {foo: string}, second element is {foo: any}
• The union type {foo: string} | {foo: any} is subtype-reduced to {foo: any}
• Is Array<{foo: any}> assignable to Array<{foo: number>}> ?
• Yes
• The program contains no errors

The net result is "wrong" but every individual step in that logic is right and can't really be changed without breaking something else (including being a breaking change in existing code). You can cast to never instead to get the "correct" result

[weswigham]

@RyanCavanaugh Typechecking array literals as tuples (which we had mentioned elsewhere for other things) would actually solve this.

[RyanCavanaugh]

@weswigham in addition to being a breaking change, it still leaves problems like

var x = ["", 1 as any]; // presumably still widened to any[]?
var y: number[] = x;

[DanielSWolf]

Would it be possible to treat literals differently if their target type is known in advance? Here are a few examples:

// Assignment to variable of known type
const foo: SomeType = [...];

// Function argument of known type
function foo(arg: SomeType);
foo([...]);

// Property of known type
const foo: { bar: number[] } = { bar: [...] };

I know that there are other languages that do this. But I have no idea whether that's feasible for TypeScript.

[RyanCavanaugh]

We tried doing this - see #19541 - and ran into some architectural problems. We should try again, though

[DanielSWolf]

@RyanCavanaugh Did you mean to close this issue, while marking the other (#32165) as a duplicate?

[chrisnojima]

I agree we should leave this one open, i closed mine.
Just to explain my use case. I'm importing several modules in a brownfield app and building an array of a known type. One of the modules hasn't been nicely typed so its value is any.