Control flow analysis broken for `never` returning class methods

[gordonmleigh]

🔎 Search Terms

"control flow analysis", "never return"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about never

⏯ Playground Link

https://www.typescriptlang.org/play?#code/MYGwhgzhAEDC5WgbwLAChrQC4AsBOA9gO4CyAprgQCYAUAlAFzQB2ZAbmXsupproUWgAiAEZhmAcyEBuHtAC+6RWnQAzAK7NgWAJYFm2fMQBim7Xub0mrDl1QZDA4WMkyl6NWd37oeMgAdCAEYaMDwJJggsPB1JaAAfaE0qMlVYsio6bgcdVWgaAEIwiSz7XhYyQXhICHoAOn5ickpaOlkHZUw-LHU8A2K6kDJJXHblTy1vAz9AggAmUPDI6NiJBKTmFLTWTOzMXPyi8NK5PiMiU0mLenbMTt8KXv7wweGJUfc0IA

💻 Code

class Class {
  throwMethod(): never {
    throw "bang";
  }
}

function throwFunction(): never {
  throw "bang";
}

function repro1(arg: string | undefined) {
  if (!arg) {
    new Class().throwMethod();
  }
  return arg.length;
}

function repro2(arg: string | undefined) {
  if (!arg) {
    throwFunction();
  }
  return arg.length;
}

🙁 Actual behavior

When a class method has a never return type (see repro1 function), the control flow analysis ignores this.

When a function method has a never return type (see repro2 function), the control flow analysis correctly identifies that this execution branch will end.

🙂 Expected behavior

I expected that the function and class method would be treated in the same way by the CFA, because I can't find an obvious reason why they should differ.

Additional information about the issue

No response

[MartinJohns]

This is working as intended. For performance reasons only specific calls are analyzed. Check #32695 for details.

If you change your code according to the requirements it works:

 const c: Class = new Class();
 if (!arg) {
   c.throwMethod();
 }

[jcalz]

Also duplicates #46254

[gordonmleigh]

Martin Johns (@MartinJohns) thanks for the quick reply.

Relevant quote from #32695 is:

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.

Another workaround is as follows:

function repro1(arg: string | undefined): number {
  if (!arg) {
    // compatible with return type because the type is `never`, even if the CFA doesn't work
    return new Class().throwMethod();
  }
  return arg.length;
}