RFC: Add @will_specialize macro and will_specialize function to InteractiveUtils

[DilumAluthge]

See also: #33142

This pull request adds the InteractiveUtils.@will_specialize macro and the InteractiveUtils.will_specialize function.

• InteractiveUtils.@will_specialize f(x, y, z...) returns true if the call to f(x, y, z...) will be fully specialized on its arguments, and false otherwise.

• InteractiveUtils.will_specialize f(x, Tuple{R, S, T...} returns true if the call to f with argument types R, S, T... will be fully specialized on its arguments, and false otherwise.

Examples

julia> f1(x) = Base.typemax(x)
f1 (generic function with 1 method)

julia> @will_specialize f1(Int)
false

julia> g(x) = x + x
g (generic function with 1 method)

julia> @will_specialize g(1)
true

julia> foo(t::Type) = t
foo (generic function with 1 method)

julia> @will_specialize foo(Int)
false

julia> function foo2(t::Type)
           x = ones(t, 10)
           return sum(map(sin, x))
       end
foo2 (generic function with 1 method)

julia> @will_specialize foo2(Int)
false

Motivation

As discussed in #23749, #32834, and #32817:

@code_typed and friends will always show you specialized code, even if Julia
would not normally specialize that method call

The InteractiveUtils.@will_specialize macro and InteractiveUtils.will_specialize function introduced in this pull request provide a convenient way to find out whether or not Julia would normally specialize a given method call.

[nickrobinson251]

This seems cool! I am not well-placed to review the implementation (sorry), but some thoughts on docs below :)

[nickrobinson251]

I wonder if it is worth cross-referencing Base's at-specialize / at-nospecialize for extra context?

e.g.

Suggested change

	[`will_specialize`](@ref) on the resulting expression.
	[`will_specialize`](@ref) on the resulting expression.
	See also: [`specialize`](@ref), [`nospecialize`](@ref)

(^ I think at-ref to Base function will "just work" but not 100% sure if this is the right suntax for it)

[nickrobinson251]

Perhaps worth making even more explicit that this means "Returns true if the call will be specialized on all its arguments"?

I really like the explanation you gave in the opening post of the PR :)

Could some of the examples you give be included in the docstring (as doctests)?

[DilumAluthge]

This is a note to myself:

This pull request only deals with positional arguments. We will need to also find a way to deal with inaccurate specialization on keyword arguments.

[iamed2]

@DilumAluthge Was this work continued or replaced elsewhere or did you decide to stop working on it?