Fails to perform type narrowing on functions that return "never"

[Zamiell]

Bug Report

🔎 Search Terms

type narrowing never

🕗 Version & Regression Information

• v4.5.2
• v4.4.4
• v4.3.5
• v4.2.3
• v4.1.5
• v4.0.5
• v3.9,7
• This is the behavior in every version I tried, and I reviewed the FAQ for entries about this.

⏯ Playground Link

Playground link with relevant code

💻 Code

type ShouldNeverReturnFunction = () => never;

let shouldNeverReturn: ShouldNeverReturnFunction | null = null;

function foo(): never {
  if (shouldNeverReturn === null) {
    throw new Error('The "shouldNeverReturn" function was not initialized.');
  }

  shouldNeverReturn();
}

🙁 Actual behavior

The TypeScript compiler refuses to compile this code.

🙂 Expected behavior

I expect the TypeScript compiler to compile this code.

The error message says that the foo function has "a reachable end point", but that is clearly false, so the TypeScript compiler seems to be drunk. 🍺🥴

[MartinJohns]

32695 mentions:

the function name resolves to a function type with an asserts return type or an explicit never return type annotation.

shouldNeverReturn does not resolve to such a function, it only is later on narrowed to one. Unfortunately the PR does not mention unions, so it's not clear whether this is intentional (my guess) or not.

[RyanCavanaugh]

I think it's in principle possible to expand the checking to cover unions, but this seems like a fairly rare case. The old workaround of return shouldNeverReturn(); works well here. We can look into it more if it's commonly encountered

[kherock]

I just ran into this while refactoring a logging function I have to throw error object passed to it. e.g. I had code that looked like this:

if (!obj.requiredProp) {
  const error = new Error('requiredProp is required');
  logger.error(error.message)
  throw error;
}

someFn(obj.requiredProp);

My new code adds a throw function that is used like this

declare const logger: { throw: (error: unknown) => never };

if (!obj.requiredProp) {
  logger.throw(new Error('requiredProp is required'));
}

someFn(obj.requiredProp); // argument of type 'string | null' is not assignable to parameter of type 'string'

Here I expect some type narrowing but I get the error that I've provided in the comment.

[Zamiell]

Today I ran into another issue along these lines. I am not 100% sure if it is the same thing, but it smells like it.

Consider the following code snippet:

function checkFoo(something: string): boolean {
  if (something === "foo") {
    return true;
  }

  if (something === "bar") {
    return false;
  }

  throw new Error("Unknown something.");
}

It works great! 👍

function error(msg: string): never {
  throw new Error(msg);
}

function checkFoo(something: string): boolean {
  if (something === "foo") {
    return true;
  }

  if (something === "bar") {
    return false;
  }

  error("Unknown something.");
}

This code fails with the "noImplicitReturns" compiler flag turned on. ❌ It says that "Not all code paths return a value", which is wrong, because all code paths do return in exactly the same way that the first code snippet does, but TypeScript isn't smart enough to realize that.

[Zamiell]

Ok, Retsam helped me realize that the code can compile if all you do is make a return type annotation on the error function to be never. And the reason why the TypeScript compiler can't do this automatically is discussed here by Ryan Cavanaugh.

So I guess disregard the "noImplicitReturns" thing. (But the type narrowing thing is still an issue.)

[adamsuskin]

@RyanCavanaugh does this strike you as something a community member can contribute? I'm particularly interested in solving for @kherock's use case above.