Assume that array lookup can return undefined inside conditional expressions

[ifeltsweet]

Search Terms

Array lookup
Array lookup undefined
Array indexing undefined

Suggestion

Please forgive my TypeScript terminology.

I am proposing for the compiler to assume that array lookup can return undefined inside conditional expressions ONLY.

I am NOT proposing for all array lookup to return T | undefined (#11122)

Use Cases

This helps to catch subtle, hard to spot bugs.

Examples

const setItem = (value: Item | undefined) => { item = value };

// This a bug, setItem shouldn't accept null, TS didn't catch it.
setItem(response.data.items[0] || null)

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[MartinJohns]

Your example doesn't compile:

type Item = string
type ResponseData = { data: { items: Item[] } }

let item: Item | undefined
const setItem = (value: Item | undefined) => { item = value };

const response: ResponseData = { data: { items: [] } }

setItem(response.data.items[0] || null)

Playground link

Unless I'm missing something. You didn*t provide a fully working example of your issue.

[ifeltsweet]

Martin Johns (@MartinJohns), thanks for pointing this out.

Item must be a non-primitive type for the example to work. If Item is a primitive type then for some reason compiler does catch it.

type Item = { name: string };
type ResponseData = { data: { items: Item[] } };

let item: Item | undefined;
const setItem = (value: Item | undefined) => { item = value };

const response: ResponseData = { data: { items: [] } };

setItem(response.data.items[0] || null);

Playground link

[ifeltsweet]

Turning on noUncheckedIndexedAccess makes the compiler raise the error. However noUncheckedIndexedAccess is an all-in flag. This feature request is for conditional expressions only.

Considering that primitive types do raise the error without this flag, I am wondering whether this is a bug or not.

[RyanCavanaugh]

It's very, very confusing in programming languages when expressions change behavior based on where you write them, so we don't do this unless the upside is extremely compellilng.

Considering that primitive types do raise the error without this flag, I am wondering whether this is a bug or not.

"" | null is null, as is 0 || null so the expression response.data.items[0] || null can produce null if the left operand is string or number

[ifeltsweet]

Thanks for the explanation about why the primitives work in this case.

You can close this issue if something like this is unlikely to be implemented. Those who want more type safety will have to opt in to noUncheckedIndexedAccess. Cheers.