Assert that exit never returns

[jakobnissen]

Typeassert exit()::Union{}, such that the compiler knows that exit never returns, and thus can refine types based on this information.

Edit: This has been changed to manually calling error() instead of typeasserting.

Closes #51856

Note to reviewers: I don't think the solution exit()::Union{} is particularly nice. For example, it shows up in JET as an error because exit() is still inferred to Nothing before the typeassert. But I don't know how to directly tell the compiler that this function doesn't return.

[giordano]

For the case reported in #51856 I get

julia> using JET

julia> function parse_plus_one(s::String)
           n = tryparse(Int, s)
           if isnothing(n)
               println(stderr, "Could not parse as `Int`: \"$(s)\"")
               exit()
           end
           n
       end
parse_plus_one (generic function with 1 method)

julia> Base.exit(n) = ccall(:jl_exit, Cvoid, (Int32,), n)::Union{}

julia> @report_call parse_plus_one("15")
═════ 1 possible error found ═════
┌ parse_plus_one(s::String) @ Main ./REPL[7]:5
│┌ exit() @ Base ./initdefs.jl:29
││┌ exit(n::Int64) @ Main ./REPL[8]:1
│││ invalid builtin function call: typeassert($(Expr(:foreigncall, :(:jl_exit), Nothing, svec(Int32), 0, :(:ccall), :(%2), :(%1))), Union{})
││└────────────────────

which doesn't look much better?

[jakobnissen]

No, it would be better if the compiler actually knew that exit returned Union{} instead of asserting it (which essentially is just like adding error - because the compiler "knows" that nothing::Union{} will error). So, the JET error is not improved.
But actual inference of the compiler IS improved, i.e. this change will allow the compiler to refine the return type of exit()

[KristofferC]

Why not just add the error()?

[jakobnissen]

I thought that the typeassert was more explicit and would achieve the same thing.

[KristofferC]

Except spurious static analysis warnings?

[jakobnissen]

Good point. I'll change it, but maybe @aviatesk should take a quick look at this, if he has time.

[aviatesk]

LGTM.

With this change, JET will emit another warning in a case when exit is called deterministically, but JET should probably have a special case to suppress it:

julia> myexit(n) = (@ccall jl_exit(n::Cint)::Cvoid; error())
myexit (generic function with 1 method)

julia> report_call((Int,)) do n
           myexit(n)
       end
[ Info: Loading JET...
═════ 1 possible error found ═════
┌ (::var"#10#11")(n::Int64) @ Main ./REPL[2]:2
│┌ myexit(n::Int64) @ Main ./REPL[1]:1
││┌ error() @ Base ./error.jl:42
│││ may throw: Base.throw(Base.ErrorException((Base).string::typeof(string)(s::Tuple{}...)::String)::ErrorException)
││└────────────────────

[Keno]

Why not do ccall(:jl_exit, Union{}, (Int32,), 1)?

[jakobnissen]

Of course! That's better. Done, and thanks!