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

🔎 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

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

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.

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.

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?

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);

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.

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

Just recently had someone on the team vibe-coding stuff and casting every variable to never, passing as arguments to functions. Effectively bypassing typecheck and lint (we have linting rules to disallow explicit any).

Navigation Menu

Repository navigation

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

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Additional information about the issue

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

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

Description

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Additional information about the issue

Activity

RyanCavanaugh commented on Jan 4, 2024

bluepnume commented on Jan 4, 2024

RyanCavanaugh commented on Jan 4, 2024

bluepnume commented on Jan 4, 2024

RyanCavanaugh commented on Jan 4, 2024

MichalMarsalek commented on Jan 5, 2024

typescript-bot commented on Jan 8, 2024

ianldgs commented on Jul 1, 2025

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions