Optional chaining operator infers `never` in a loop

[VojtaStanek]

Bug Report

🔎 Search Terms

• optional chaining

🕗 Version & Regression Information

It's broken in all tested versions of typescript (3.7 until 4.8 nightly in TS playground). Versions prior 3.7 do not support optional chaining.

⏯ Playground Link

Playground link with relevant code

💻 Code

function foo(input: boolean[]) {
	let acc: null | { prop?: boolean } = null
	for (const item of input) {
		acc = { prop: item || acc?.prop } // <- Property 'prop' does not exist on type 'never'.
	}
}

🙁 Actual behavior

It infers never for acc variable, thus gives an error:

Property 'prop' does not exist on type 'never'.

function foo(input: boolean[]) {
	let acc: null | { prop?: boolean } = null
	for (const item of input) {
		acc = { prop: item || acc?.prop } // <- Property 'prop' does not exist on type 'never'.
	}
}

🙂 Expected behavior

To work and not to give an error (infer boolean for prop property) - the same way as does this equivalent code:

function foo(input: boolean[]) {
	let acc: null | { prop?: boolean } = null
	for (const item of input) {
		acc = { prop: item || (acc !== null ? acc.prop : undefined) }
	}
}

[Andarist]

I spent some time debugging this and while I don't know how to fix this I think that some of the information that I've gathered might be useful for somebody else wanting to work on this.

It is a little bit funny that in both of those cases the intermediate type of acc gets actually computed as never. So why does one error and the other one doesn't?

The working one, with conditional expression, gets never computed as its flow type at this position:

function foo(input: boolean[]) {
	let acc: null | { prop?: boolean } = null
	for (const item of input) {
		acc = { prop: item || (acc !== null ? acc/*1*/.prop : undefined) }
	}
}

and based on that we exit checkPropertyAccessExpressionOrQualifiedName here:
https://github.dev/microsoft/TypeScript/blob/1213c35d57d91cc773f05c3e5dc36770c602ba94/src/compiler/checker.ts#L29103
because the computed never type is actually the so-called silentNeverType and thus we don't get to the line that is responsible for reporting the error in the other case and which is within the same checkPropertyAccessExpressionOrQualifiedName here:
https://github.dev/microsoft/TypeScript/blob/1213c35d57d91cc773f05c3e5dc36770c602ba94/src/compiler/checker.ts#L29141

It's worth noting that the computed type of a conditional type is a union of its branches:
https://github.dev/microsoft/TypeScript/blob/1213c35d57d91cc773f05c3e5dc36770c602ba94/src/compiler/checker.ts#L34407

So why the same doesn't happen for the reported case even if, according to my words, the type for acc gets computed as never too?

Well, the problem is that it's computed as never in a slightly different way... At this location:

function foo(input: boolean[]) {
	let acc: null | { prop?: boolean } = null
	for (const item of input) {
		acc = { prop: item || acc/*1*/?.prop }
	}
}

the flow type gets computed as null, that becomes leftType and thus the nonOptionalType becomes never here:
https://github.dev/microsoft/TypeScript/blob/1213c35d57d91cc773f05c3e5dc36770c602ba94/src/compiler/checker.ts#L28917-L28918

The problem is that this never type is not a silentNeverType and thus we end up reporting the error.

I don't have enough knowledge about the internal to really assess what's wrong here but that acc gets computed as never in the conditional expression case seems somewhat fishy to me. Maybe it is OK given the current implementation but IMHO in the context of this loop the acc there should be computed as { prop: boolean } (or { prop: true }).

It also seems that given the current "order of computation" it's not that easy to satisfy the reported case - perhaps if the optional property access would be handled as a whole then it would be easier to compute this correctly. With the current order of computation the null (thanks to CFA) gets resolved "too soon".

Although I'm unsure how to satisfy this case AND report error for this case at the same time:

const foo = null
foo?.prop

So my intuition here just goes back to the first problem - perhaps the type of acc should never resolve here to null/never under CFA - if it wouldn't then this would probably resolve the issue altogether.