Generator<T, TReturn>['next'] doesn't narrow properly when using assignment expressions or the comma operator

[JakeTunaley]

TypeScript Version: 3.8.0-dev.20191203

Search Terms:

• generator
• generators
• iterator
• iterators
• narrow
• narrowing
• assignment
• expression
• next
• comma
• operator

Code

function* generator () {
	yield 4;
	return 'hello world';
}

function consumer1 () {
	const gen = generator();
	let result = gen.next();
	while (!result.done) {
		((x: number) => {})(result.value);
		result = gen.next();
	}
	((x: string) => {})(result.value);
}

function consumer2 () {
	const gen = generator();
	let result;
	while (!(result = gen.next()).done) {
		((x: number) => {})(result.value);
	}
	((x: string) => {})(result.value);
}

function consumer3 () {
	const gen = generator();
	let result;
	while (result = gen.next(), !result.done) {
		((x: number) => {})(result.value);
	}
	((x: string) => {})(result.value);
}

Expected behavior:

Type narrowing for result.value should be the same in consumer1, consumer2, and consumer3.

Actual behavior:

consumer1 narrows result.value.

consumer2 and consumer3 don't narrow result.value, thus giving the following errors:

Argument of type 'string | number' is not assignable to parameter of type 'number'.

Type 'string' is not assignable to type 'number' .ts(2345)

Argument of type 'string | number' is not assignable to parameter of type 'string'.

Type 'number' is not assignable to type 'string'. ts(2345)

Explicitly declaring the type of result to be IteratorResult<number, string> (the type inferred in consumer1) does not fix the issue.

Playground Link:

Playground Link

Related Issues:

None

[rbuckton]

In the time since this bug was filed, we seem to have addressed the issue regarding narrowing for consumer3, however consumer2 still does not perform narrowing of result.

In consumer3, the reference for result in result.value has a control flow graph that looks something like this:

True (result = gen.next(), !result.done) ─ Assignment (result) ─ Loop ─ Assignment (gen = generator()) ─ Start  

Meaning that we're on the True branch of the loop.

In consumer2, the graph differs for result.value:

Assignment (result) ─ Loop ─ Assignment (gen = generator()) ─ Start  

All we see is the assignment to result, the .done is disconnected from the reference.

This failing case can be simplified in the following manner:

type D = { done: true, value: 1 } | { done: false, value: 2 };
declare function fn(): D;
{
  let o: D;
  if (o = fn(), o.done) {
    const x = o.value; // x has type '1'
  }
}
{
  let o: D;
  if ((o = fn()).done) {
      const x = o.value; // x has type '1 | 2' but should be '1'
  }
}