Incorrect ts(18048) (possibly 'undefined' error) after optional chaining with const

[tsoestini]

Bug Report

🔎 Search Terms

ts(18048)
is possibly 'undefined'.
optional chaining

🕗 Version & Regression Information

Verified bugged in 4.9.5 through 5.0.4 and the most recent Nightly as of this posting.

(The same code throws a different ts error earlier than 4.9.5.)

⏯ Playground Link

Playground link with relevant code

💻 Code

interface Foo {
    foo: {
        a: string;
        b: string;
    };
    bar: string;
}

export default function getBar(obj: Foo | undefined): string {
    const foo = obj?.foo;
    const a = foo?.a;
    if (!a) {
        throw new Error("Invalid args");
    }

    return obj.bar; // <--- obj is possible undefined here according to tsc even though it can never really be
}

🙁 Actual behavior

'obj' is possibly 'undefined'.(18048) at the final return line for 'obj'

🙂 Expected behavior

No typescript error should be shown here, because 'obj' can never be undefined since 'foo' and 'a' would then also be undefined so the code would never reach the final return.

[RyanCavanaugh]

Narrowing only occurs based on expressions involving the variable in question (i.e. it's not a constraint-solving system). Since a isn't obj, the if (!a) { block doesn't have any effect here.

[tsoestini]

If you change if (!a) to if (!foo), though, then it doesn't raise the objection, but foo is also not obj?
So it must have some minimal constaint-solving?

[RyanCavanaugh]

True, there is one level of back-propagation on optional chains

[Hazmi35]

Not sure if this is related or not. TypeScript 5.1.3. Found this issue when working on Maps with class that has a function as values, tried playground and got it reproduced.

Playground Link

class Hello extends Map<string, World> {
    doStuff(key: string) {
        const value = this.get(key);

        const one = value?.doStuffOne();
        if (!one) return undefined;

        value.doStuffTwo(); // <-- ts(18048) 'value' is possibly undefined.

        if (one) {
            value.doStuffTwo();  // <-- ts(18048) 'value' is possibly undefined.
        }

    }
}

class World {
    doStuffOne() {
        return true;
    }

    doStuffTwo() {
        return true;
    }
}

I'm sure that value won't be undefined after the guard clause, but tsc reports it possibly can, but not on this code:

Playground Link

class Hello extends Map<string, World> {
    doStuff(key: string) {
        const value = this.get(key);

        if(value?.doStuffOne()) value.doStuffTwo();
    }
}

class World {
    doStuffOne() {
        return true;
    }

    doStuffTwo() {
        return true;
    }
}

[birgersp]

Just wanted to chime in an another example that would perhaps illustrate the problem an an even more obvious manner:

function foobar(x: number | undefined) {
	throw new Error()
	if (x != undefined) {
		return x + 1 // <-- Compiler error TS18048: 'x' is possibly 'undefined'. False positive error.
	}
}

Playground link

I would suggest that the title of this issue could be changed to:

Type narrowing disrupted by preceding "throw" statement (TS18048)

[RyanCavanaugh]

@birgersp see #26914