`undefined` is acting like `any` in generics extension checks

Bug Report

🔎 Search Terms

generic function call

🕗 Version & Regression Information

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

⏯ Playground Link

playground link

💻 Code

type IfAny<T> = 0 extends (1 & T) ? true : never

declare function bool<T extends IfAny<T>>(value?: T): 'caught';
declare function bool<T>(value?: T): 'not caught';

declare function bool2<T extends {['gibberish']: T}>(value?: T): 'caught';
declare function bool2<T>(value?: T): 'not caught';

const A = bool(undefined);  // caught ???
const B = bool2(undefined); // caught ???
const C = bool();           // caught ???
const D = bool2();          // caught ???

🙁 Actual behavior

both implicit and explicit undefined arguments seems to act like any when used in a generic when the argument is optional. This behavior is not seen when the argument is required

🙂 Expected behavior

undefined shouldn't extend everything

[MartinJohns]

Your function argument value is typed T | undefined because it's an optional parameter. So when you call it passing undefined or without an argument, there's nothing to infer T from, so T resolves to never, and never extends every type.

[ConnorJamesLow]

That's expected. See Everyday Types and More on Functions from the handbook.

never extends every type.

This seems incredibly strange! What's the logic here?

[fatcerberus]

never is the bottom type which is the opposite of the top type unknown. It conceptually represents the result of operations that never complete (a function that throws, e.g.), so you can treat it as any type you want. In set-theoretical terms, never is an empty set (because there are no values of that type)--which is a subset of every other set.

Since you asked for logical justification 🤓, the relevant logical concept is the principle of explosion - you can prove anything from a contradiction. From the point of view of the code holding a value of type never, anything can be "proven" (computed) from it because taking a value from a set with no values is a logical contradiction. In type systems, this usually manifests as the bottom type being the universal subtype, just as unknown is the universal supertype.

Thanks for the thorough explanation!!