if statement in loop changes type of variable outside the if

[ghost]

TypeScript Version: 2.7.0-dev.20171112

Code

type U = { kind: "A", xs?: number[] } | { kind: "B", xs?: number[] };
function f(u: U) {
	if (u.xs) {
		for (const b of u.xs) {
			if (u.kind === "A") {}
		}
	}
}

Expected behavior:

No error.

Actual behavior:

src/a.ts(4,19): error TS2532: Object is possibly 'undefined'.

[ahejlsberg]

Duplicate of #18840.

[ahejlsberg]

Actually, I'll flip it back to a bug since it is not exactly the same as #18840. However the root cause is similar: A narrowing by a discriminant property (such as u.kind === "A") resets any previous narrowing in effect for the variable. Here, the back edge of the for loop causes the narrowing of u.xs to disappear. This is unfortunately not a simple thing to fix.

[ghost]

Another case:

function containsItself(arr: {}): boolean {
    if (!Array.isArray(arr)) {
        return false;
    }
    for (const x of arr) {
        if (x === arr) {
            return true;
        }
    }
    return false;
}

src/a.ts(5,16): error TS7022: 'x' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.

And another:

function f(u: { type: "A"; x: number; } | { type: "B"; x?: number; }) {
    if (u.type === "A") {
        u.x; //number
    }
    if (u.type === "B" && u.x !== undefined) {
        u.x; //number
    }
    if (u.type === "A" || u.type === "B" && u.x !== undefined) {
        u.x; // number | undefined
    }
}

[ghost]

A possibly related error:

interface Base { a: number | string; }
interface A extends Base { kind: "A"; }
interface B extends Base { kind: "B"; }

function f(x: A | B): void {
	if (typeof x.a === "number") {
		if (x.kind === "A") { } // No error if this is removed
		const n: number = x.a; // Error
	}
}

[ghost]

Another case:

function f(a: number | undefined) {
    if (!a) return;
    for (const b of [a]) {
        if (b === a) {}
    }
}

src/a.ts:3:16 - error TS7022: 'b' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.

3     for (const b of [a]) {
                 ~

[ghost]

Another case from #26673:

interface A {
	isA: true;
	m?(): void;
}

interface B {
	isA: false;
	m?(): void;
}

class User {
	p!: A | B;

	go(): void {
		if (this.p.m) {
			if (this.p.isA) {}
			this.p.m(); // No error (good)
		}

		const p = this.p;
		if (p.m) {
			if (p.isA) {}
			p.m(); // Error (bad)
		}
	}
}

[jack-williams]

This looks to be fixed by #32695; specifically, the cases involving loops.

[sandersn]

Indeed it is. Thanks for noticing!