Passing never type as a function parameter does not fail type check

[bluepnume]

🔎 Search Terms

never parameter argument

🕗 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/FAMwrgdgxgLglgewgAhAhAKARgQwE7IBcyAzjHnBAOYCUyA3sMslEiQgDYCmAdBwlWz4aAbmABfYKEixEKKlxgA5LgDcueDHWIQ1Ghk2QwAFngQB3ZLssBRPGc0ADJQgAOXR6IlS0mBcr1NGlEgA

💻 Code

function foo(bar : string) {
  console.log(bar);
}

function getNever() : never {
  throw new Error(`Nope`);
}

foo(getNever());

🙁 Actual behavior

No type errors

🙂 Expected behavior

Type error: can not pass type never to function foo

Additional information about the issue

No response

[RyanCavanaugh]

never is the empty set; the subtype of all types. By definition, it is assignable to anything.

[bluepnume]

OK, understood -- but is there a reason it doesn't work a bit more like unknown? Would there be any downside to preventing a never value to be passed around since that seems to indicate an error case, or at least probably not what the code author intended.

[RyanCavanaugh]

I'm not sure what rule you're proposing. At best, you'd introduce many different inconsistencies where higher-order and zero-order forms disagreed about validity.

[bluepnume]

I'm arguing from a 'principle of least surprise' angle. If I try to pass a never value into a function, and that function doesn't explicitly accept never as a parameter type, there's like a 99% chance I'm doing something I shouldn't be, and a warning would help me fix that mistake.

My proposal is there would be some setting similar to noImplicitAny which makes never unusable. Once I have a never value, I would be unable to return it, pass it to any function, unless those functions explicitly have never types defined as inputs or outputs. Essentially how unknown behaves.

Is there a real world example where someone would actually want to be able to pass or return a never?

[RyanCavanaugh]

Sure, you might have something like this

declare function myRoundingFunc(n: number): number;
declare function doSomething(value: number, ifEven: () => string, ifOdd: () => string, ifFractional: () => string): string;

// Input from somewhere
declare let n: number
n = myRoundingFunc(n);
const p = doSomething(n, () => "n is even", () => "n is odd", () => { throw new Error("This can't happen") });
console.log(p);

[MichalMarsalek]

never is a subtype of all types while unknown is a supertype of all types. They are different by nature. I don't expect and don't want them to behave the same.

[typescript-bot]

This issue has been marked as "Working as Intended" and has seen no recent activity. It has been automatically closed for house-keeping purposes.