Empty intersections as function return types are not treated as never

[lowr]

Bug Report

🔎 Search Terms

empty intersections, never, return type

🕗 Version & Regression Information

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

⏯ Playground Link

strictNullChecks: false

strictNullChecks: true

💻 Code

type A = { p: "A" };
type B = { p: "B" };

function f1(): never {
  return;
}

function f2(): A & B {
  return;
}

function g1(): never {}

function g2(): A & B {}

🙁 Actual behavior

f1: Type 'undefined' is not assignable to type 'never'. (expected)
f2 w/ strictNullChecks: false: no error emitted
f2 w/ strictNullChecks: true: Type 'undefined' is not assignable to type 'never'. The intersection 'A & B' was reduced to 'never' because property 'p' has conflicting types in some constituents. (expected)

g1: A function returning 'never' cannot have a reachable end point. (expected)
g2: A function whose declared type is neither 'void' nor 'any' must return a value.

🙂 Expected behavior

f2 and g2 should generate the same errors as f1 and g1 respectively other than elaboration on empty intersection types.

Note: I was suggested to separate fix from #47751 and I'm ready to submit another PR if this is really a bug.

[RyanCavanaugh]

I don't really see a defect per se here, g2 still has an error. We don't give it the special-cased error message about never but the error is effectively telling you the same thing, and why would someone write code like this on purpose?

[lowr]

Is it really telling you the same thing? If I see the current error message on g2 I'd try to return something until I notice the return type is never. Worse, if I try adding return; at the end of the function just to try to please the compiler (which I shouldn't, of course!), g2 becomes f2, which under strictNullChecks: false wouldn't emit any error.

I understand that the above code is contrived, but this may emerge in larger code bases with generics, possibly by unintentionally declaring a function's return type as an empty intersection. Quote from #36696 (comment):

It is obviously uncommon to have type annotations that explicitly intersect disjoint types, as in the examples above. The root cause of empty intersections is typically instantiations of generic types that intersect type parameters.

Seeing no one else has ever reported this as a bug, I can argue that no one would actually confront something like this, but I'd say "fixing" this would make the compiler a bit more friendly to the users.

[RyanCavanaugh]

It's correct to not error under snc: false because { p: undefined } is a legal return value

[RyanCavanaugh]

If it's straightforward to make this better we can take a PR, but if it's complicated or has other side effects I'd consider this "not a defect"

[lowr]

It's correct to not error under snc: false because { p: undefined } is a legal return value

I thought with #36696 A & B is equivalent never so all of the four functions aren't allowed to return anything even under snc: false? Just double checking.