Add a new macro @outline, and use it in @assert.

[NHDaly]

Adds a new macro @outline, and uses it in @assert.

This implements the simplest suggestion in #29688.
It would still be excellent if the compiler would automatically perform this optimization for any throw() statement, but it sounds like introducing automatic outlining for such cases would be a difficult implementation task in the Compiler.

And in either case, even if we had such an optimization, there may be cases where a human will want to perform this optimization themselves for a number of reasons, including code-size reduction, improving type stability, outlining rare branches, etc, and having this in a macro is a nice way to automate it, and make this optimization more accessible. 😊

---

Example macro usage:

  @boundscheck if !(i > 1 && i <= length(x))
      @outline throw(BoundsError(x, i))
  end

This commit applies this new macro @outline to @assert, producing essentially:

# @assert x == y
x == y ? nothing : @outline(throw(AssertionError("x == y"))

or in a more complete example:

julia> @macroexpand @assert x != x "x == x: $x"
:(if x != x
      nothing
  else
      #= REPL[3]:36 =#
      var"#17#outline"(x) = begin
              $(Expr(:meta, :noinline))
              #= REPL[3]:36 =#
              (throw)((AssertionError)(((Main).Base.inferencebarrier((Main).Base.string))("x == x: $(x)")))
          end
      #= REPL[3]:38 =#
      var"#17#outline"(x)
  end)

This can improve performance for fast code that uses assertions. For example, take this definition of getindex for WithoutMissingVector:

julia/base/sort.jl

Lines 597 to 601 in 5058dba

	Base.@propagate_inbounds function Base.getindex(v::WithoutMissingVector, i::Integer)
	out = v.data[i]
	@assert !(out isa Missing)
	out::eltype(v)
	end

Before:

julia> @btime Base.Sort.WithoutMissingVector($(Any[1]))[$1]
  3.041 ns (0 allocations: 0 bytes)
1

After:

julia> @btime Base.Sort.WithoutMissingVector($(Any[1]))[$1]
  2.250 ns (0 allocations: 0 bytes)
1

The number of instructions in that function according to @code_native (on an aarch64 M2 MacBook) reduced from ~90 to ~40.

[NHDaly]

I'm not sure if this file was the right place to put the @outline tests. It seems decent, but a bit oxymoronic. :D Please let me know if you have any better suggestions!

[adienes]

I think unique! is not defined yet so this fails to compile for me

although, what happens if you use outline as a zero-arg closure and don't pass the vars in explicitly at all? like

macro outline2(expr)
    local fname = gensym(:outlined_expr)
    quote
        @noinline $(fname)() = $(esc(expr))
        $(fname)()
    end
end

comparing the @code_native of

foo1() = @outline rand() > 0.5 || throw(AssertionError("abc"))
foo2() = @outline2 rand() > 0.5 || throw(AssertionError("abc"))

it seems a lot simpler, but I'm not an expert at these things so maybe I'm missing something