Typescript still checks return type in a lamba that calls a function returning 'never'

[kwasimensah]

🔎 Search Terms

lambda never return type match

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries (didn't find a relevent one)

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=6.0.0-dev.20260416#code/FAYwNghgzlAEBiB7RBJAtgBzLA3sWBsARhAE4AUApqaYqQFywCiNdAlIwHaUBu1u+QkIAuAC1oB3WNVqkA3IIIBfYMBWhEnKMNgBLTNgC8sblKSoD5NguBhKOgGaxjVrgFc0RfoYB8AoQD0AWKSJpRSLLJWcrBBEnQA1nASopScsGK6cGC63HpwnIg6IIhoaGnClAAminoGAHQkFKbMrBRs1mqqwEA

💻 Code

class FooImpl {
    bar(error: Error): never {
        throw error;
    }

}

const impl = new FooImpl();

let f = (): number => {
    //throw new Error(); //works when this line is not commented
    impl.bar(new Error());
}

🙁 Actual behavior

the definition of f has the error

A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.

🙂 Expected behavior

the definition of f is valid typescript

Additional information about the issue

This works if I throw he exception directly in the function instead of through a member function

[MartinJohns]

This is working as intended. See #32695:

A function call is analyzed as an assertion call or never-returning call when

• the call occurs as a top-level expression statement, and
• the call specifies a single identifier or a dotted sequence of identifiers for the function name, and
• each identifier in the function name references an entity with an explicit type, and
• the function name resolves to a function type with an asserts return type or an explicit never return type annotation.

[jcalz]

As mentioned above, to get the behavior you expect, you need to be sure that

each identifier in the function name references an entity with an explicit type

Since impl is implicitly typed, calling impl.bar won't affect control flow analysis. You can fix it like this:

class FooImpl {
    bar(error: Error): never {
        throw error;
    }
}

const impl: FooImpl = new FooImpl();
//        ^^^^^^^^^

let f = (): number => { // okay now
    impl.bar(new Error()); 
}

Playground link

Yes, such "spooky action at a distance" is unintuitive and annoying, but that's how it works. They did this to be sure this feature wouldn't cause new runaway control flow analysis (see #45385).

[RyanCavanaugh]

Added https://github.com/microsoft/TypeScript/wiki/FAQ#calls-to-cfa-affecting-require-explicitly-typed-names-to-affect-control-flow