make `noreturn` type more like the "zero" type

[vi]

• ?noreturn is not allowed instead of being void-equivalent (always null). Like u0 is currently void-equivalent.
• Empty unions are disallowed instead of being noreturn-equivalent.
• unreachable code error is too strict, preventing instantiating generic code with T=noreturn
• Using noreturn for union variant does still allocate a tag for such variant

---

Java gets unit and zero types wrong. Rust gets unit and zero types (relatively) right. Zig gets unit type right, but zero type wrong. Shall it be fixed?

[andrewrk]

Another use for this: anyerror!noreturn would be the return type of std.os.execve. When there is an explicit type, it could be used directly, e.g. anyerror, but when one wants to infer the type, !noreturn makes sense.

[daurnimator]

Empty unions are disallowed instead of being noreturn-equivalent.

I feel like this is the "right thing". @vi do you have an example use case for this one?

[vi]

@daurnimator , Obvious one is codegenerated Zig code where union variants are filled in by automatic algorithm.

Special cased error because of something happens to be empty leads to special cases and workarounds in code generator (i.e. removing the type altogether or adding a dummy variant).

If empty unions definitions and (also empty) switch statements on those unions are allowed, less corner cases need to be considered in code generator.

---

Another case is temporary commenting out some code. Commenting out the last union variant leads to bigger reorganisation. Think of "trailing comma, but in the world of types".

[vi]

@daurnimator

I feel like this is the "right thing"

Tagged union of 2 bools (union(enum) { var1: bool, var2: bool,}) has total 4 possible states. Remove var2 - now 2 possible states. Also remove var1 - now 0 possible states. Just like noreturn. So allowing it and making it like noreturn (at least with respect to code generation) seems like the right thing. Other noreturn features (like convertability to any other type) are probably not good although.

You need 2 switch branches to handle the original union. You need 1 branch to handle the union without var2. You need 0 switch branches to handle the final empty union. For code generation, that switch is just unreachable.

[tadeokondrak]

Rust originally special cased ! in return position, but then made it a real type:
https://github.com/rust-lang/rfcs/blob/master/text/1216-bang-type.md
Swift originally had a @noreturn attribute but changed it to its own type,
https://github.com/apple/swift-evolution/blob/master/proposals/0102-noreturn-bottom-type.md

In both of these cases, the languages already had a concept of an "uninhabited type", such as an enum with zero variants. I think Zig should also make empty enums/unions work, and make noreturn equivalent to them (and maybe rename it to never?).

noreturn already coerces to any type, but making empty enums and unions do that would be a footgun. Empty enums and unions should be convertable to noreturn by switching on them: switch (value) {}.