Export at-invoke and make it use Core.Typeof instead of Any

The macro was introduced in Julia 1.7 but was not exported. Previously,
when an argument's type was unspecified, the type used was `Any`. This
doesn't play well with types passed as arguments: for example, `x % T`
has different meanings for `T` a type or a value, so if `T` is left
untyped in `at-invoke rem(x::S, T)`, the method to call is ambiguous. On
the other hand, if the macro expands `rem(x::S, T)` to use
`Core.Typeof(T)`, the resulting expression will interpret `T` as a type
and the likelihood of method ambiguities is significantly decreased.

NEWS.md

@@ -21,6 +21,9 @@ Language changes
   binary minus falls back to addition `-(x, y) = x + (-y)`, and, at the most generic level,
   left- and right-division fall back to multiplication with the inverse from left and right,
   respectively, as stated in the docstring. ([#44564])
+* The `@invoke` macro introduced in 1.7 is now exported. Additionally, it now uses `Core.Typeof(x)`
+  rather than `Any` when a type annotation is omitted for an argument `x` so that types passed
+  as arguments are handled correctly. ([#45807])
 
 Compiler/Runtime improvements
 -----------------------------

base/compiler/ssair/show.jl

@@ -10,7 +10,7 @@ length(s::String) = Base.length(s)
 end
 
 import Base: show_unquoted
-using Base: printstyled, with_output_color, prec_decl
+using Base: printstyled, with_output_color, prec_decl, @invoke
 
 function Base.show(io::IO, cfg::CFG)
     for (idx, block) in enumerate(cfg.blocks)
@@ -817,7 +817,7 @@ function Base.show(io::IO, t::TriState)
     if s !== nothing
         printstyled(io, s; color = tristate_color(t))
     else # unknown state, redirect to the fallback printing
-        Base.@invoke show(io::IO, t::Any)
+        @invoke show(io::IO, t::Any)
     end
 end
 

base/exports.jl

@@ -1047,4 +1047,5 @@ export
     @goto,
     @view,
     @views,
-    @static
+    @static,
+    @invoke

base/reflection.jl

@@ -1855,30 +1855,45 @@ hasproperty(x, s::Symbol) = s in propertynames(x)
 """
     @invoke f(arg::T, ...; kwargs...)
 
-Provides a convenient way to call [`invoke`](@ref);
-`@invoke f(arg1::T1, arg2::T2; kwargs...)` will be expanded into `invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...)`.
-When an argument's type annotation is omitted, it's specified as `Any` argument, e.g.
-`@invoke f(arg1::T, arg2)` will be expanded into `invoke(f, Tuple{T,Any}, arg1, arg2)`.
+Provides a convenient way to call [`invoke`](@ref) by expanding
+`@invoke f(arg1::T1, arg2::T2; kwargs...)` to `invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...)`.
+When an argument's type annotation is omitted, it's replaced with `Core.Typeof` that argument.
+To invoke a method where an argument is untyped or explicitly typed as `Any`, annotate the
+argument with `::Any`.
+
+# Examples
+
+```jldoctest
+julia> @macroexpand @invoke f(x::T, y)
+:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))
+
+julia> @invoke 420::Integer % Unsigned
+0x00000000000001a4
+```
 
 !!! compat "Julia 1.7"
     This macro requires Julia 1.7 or later.
+
+!!! compat "Julia 1.9"
+    This macro is exported as of Julia 1.9.
 """
 macro invoke(ex)
     f, args, kwargs = destructure_callex(ex)
-    newargs, newargtypes = Any[], Any[]
-    for i = 1:length(args)
-        x = args[i]
-        if isexpr(x, :(::))
-            a = x.args[1]
-            t = x.args[2]
+    types = Expr(:curly, :Tuple)
+    out = Expr(:call, GlobalRef(Core, :invoke))
+    isempty(kwargs) || push!(out.args, Expr(:parameters, kwargs...))
+    push!(out.args, f)
+    push!(out.args, types)
+    for arg in args
+        if isexpr(arg, :(::))
+            push!(out.args, arg.args[1])
+            push!(types.args, arg.args[2])
         else
-            a = x
-            t = GlobalRef(Core, :Any)
+            push!(out.args, arg)
+            push!(types.args, Expr(:call, GlobalRef(Core, :Typeof), arg))
         end
-        push!(newargs, a)
-        push!(newargtypes, t)
     end
-    return esc(:($(GlobalRef(Core, :invoke))($(f), Tuple{$(newargtypes...)}, $(newargs...); $(kwargs...))))
+    return esc(out)
 end
 
 """

stdlib/LinearAlgebra/src/diagonal.jl

@@ -756,8 +756,8 @@ end
 /(u::AdjointAbsVec, D::Diagonal) = adjoint(adjoint(D) \ u.parent)
 /(u::TransposeAbsVec, D::Diagonal) = transpose(transpose(D) \ u.parent)
 # disambiguation methods: Call unoptimized version for user defined AbstractTriangular.
-*(A::AbstractTriangular, D::Diagonal) = Base.@invoke *(A::AbstractMatrix, D::Diagonal)
-*(D::Diagonal, A::AbstractTriangular) = Base.@invoke *(D::Diagonal, A::AbstractMatrix)
+*(A::AbstractTriangular, D::Diagonal) = @invoke *(A::AbstractMatrix, D::Diagonal)
+*(D::Diagonal, A::AbstractTriangular) = @invoke *(D::Diagonal, A::AbstractMatrix)
 
 dot(x::AbstractVector, D::Diagonal, y::AbstractVector) = _mapreduce_prod(dot, x, D, y)
 

stdlib/LinearAlgebra/src/generic.jl

@@ -1501,7 +1501,7 @@ function axpy!(α::Number,
     y::StridedVecLike{T}, ry::AbstractRange{<:Integer},
 ) where {T<:BlasFloat}
     if Base.has_offset_axes(rx, ry)
-        return Base.@invoke axpy!(α,
+        return @invoke axpy!(α,
             x::AbstractArray, rx::AbstractArray{<:Integer},
             y::AbstractArray, ry::AbstractArray{<:Integer},
         )

test/compiler/AbstractInterpreter.jl

@@ -49,31 +49,31 @@ strangesin(x) = sin(x)
     strangesin(x)
 end |> only === Union{Float64,Nothing}
 @test Base.return_types((Any,); interp=MTOverlayInterp()) do x
-    Base.@invoke strangesin(x::Float64)
+    @invoke strangesin(x::Float64)
 end |> only === Union{Float64,Nothing}
 
 # effect analysis should figure out that the overlayed method is used
 @test Base.infer_effects((Float64,); interp=MTOverlayInterp()) do x
     strangesin(x)
 end |> !Core.Compiler.is_nonoverlayed
 @test Base.infer_effects((Any,); interp=MTOverlayInterp()) do x
-    Base.@invoke strangesin(x::Float64)
+    @invoke strangesin(x::Float64)
 end |> !Core.Compiler.is_nonoverlayed
 
 # but it should never apply for the native compilation
 @test Base.infer_effects((Float64,)) do x
     strangesin(x)
 end |> Core.Compiler.is_nonoverlayed
 @test Base.infer_effects((Any,)) do x
-    Base.@invoke strangesin(x::Float64)
+    @invoke strangesin(x::Float64)
 end |> Core.Compiler.is_nonoverlayed
 
 # fallback to the internal method table
 @test Base.return_types((Int,); interp=MTOverlayInterp()) do x
     cos(x)
 end |> only === Float64
 @test Base.return_types((Any,); interp=MTOverlayInterp()) do x
-    Base.@invoke cos(x::Float64)
+    @invoke cos(x::Float64)
 end |> only === Float64
 
 # not fully covered overlay method match

test/compiler/EscapeAnalysis/EAUtils.jl

@@ -156,7 +156,7 @@ function CC.cache_result!(interp::EscapeAnalyzer, caller::InferenceResult)
     if haskey(interp.cache, caller)
         GLOBAL_ESCAPE_CACHE[caller.linfo] = interp.cache[caller]
     end
-    return Base.@invoke CC.cache_result!(interp::AbstractInterpreter, caller::InferenceResult)
+    return @invoke CC.cache_result!(interp::AbstractInterpreter, caller::InferenceResult)
 end
 
 const GLOBAL_ESCAPE_CACHE = IdDict{MethodInstance,EscapeCache}()
@@ -276,7 +276,7 @@ end
 function Base.show(io::IO, x::EscapeInfo)
     name, color = get_name_color(x)
     if isnothing(name)
-        Base.@invoke show(io::IO, x::Any)
+        @invoke show(io::IO, x::Any)
     else
         printstyled(io, name; color)
     end

test/compiler/EscapeAnalysis/interprocedural.jl

@@ -79,12 +79,12 @@ let result = code_escapes((SafeRef{String},); optimize=false) do x
 end
 # InvokeCallInfo
 let result = code_escapes((SafeRef{String},); optimize=false) do x
-        return Base.@invoke noescape(x::Any)
+        return @invoke noescape(x::Any)
     end
     @test has_no_escape(ignore_argescape(result.state[Argument(2)]))
 end
 let result = code_escapes((SafeRef{String},); optimize=false) do x
-        return Base.@invoke conditional_escape!(false::Any, x::Any)
+        return @invoke conditional_escape!(false::Any, x::Any)
     end
     @test has_no_escape(ignore_argescape(result.state[Argument(2)]))
 end

test/compiler/inference.jl

@@ -2129,7 +2129,7 @@ end
     # `InterConditional` handling: `abstract_invoke`
     ispositive(a) = isa(a, Int) && a > 0
     @test Base.return_types((Any,)) do a
-        if Base.@invoke ispositive(a::Any)
+        if @invoke ispositive(a::Any)
             return a
         end
         return 0
@@ -2297,7 +2297,7 @@ end
 
     # work with `invoke`
     @test Base.return_types((Any,Any)) do x, y
-        Base.@invoke ifelselike(isa(x, Int), x, y::Int)
+        @invoke ifelselike(isa(x, Int), x::Any, y::Int)
     end |> only == Int
 
     # don't be confused with vararg method
@@ -3766,16 +3766,16 @@ end
         f(a::Number, sym::Bool) = sym ? Number : :number
     end
     @test (@eval m Base.return_types((Any,)) do a
-        Base.@invoke f(a::Any, true::Bool)
+        @invoke f(a::Any, true::Bool)
     end) == Any[Type{Any}]
     @test (@eval m Base.return_types((Any,)) do a
-        Base.@invoke f(a::Number, true::Bool)
+        @invoke f(a::Number, true::Bool)
     end) == Any[Type{Number}]
     @test (@eval m Base.return_types((Any,)) do a
-        Base.@invoke f(a::Any, false::Bool)
+        @invoke f(a::Any, false::Bool)
     end) == Any[Symbol]
     @test (@eval m Base.return_types((Any,)) do a
-        Base.@invoke f(a::Number, false::Bool)
+        @invoke f(a::Number, false::Bool)
     end) == Any[Symbol]
 
     # https://github.com/JuliaLang/julia/issues/41024
@@ -3790,7 +3790,7 @@ end
         abstract type AbstractInterfaceExtended <: AbstractInterface end
         Base.getproperty(x::AbstractInterfaceExtended, sym::Symbol) =
             sym === :y ? getfield(x, sym)::Rational{Int} :
-            return Base.@invoke getproperty(x::AbstractInterface, sym::Symbol)
+            return @invoke getproperty(x::AbstractInterface, sym::Symbol)
     end
     @test (@eval m Base.return_types((AbstractInterfaceExtended,)) do x
         x.x
@@ -4110,7 +4110,7 @@ end
 # https://github.com/JuliaLang/julia/issues/44763
 global x44763::Int = 0
 increase_x44763!(n) = (global x44763; x44763 += n)
-invoke44763(x) = Base.@invoke increase_x44763!(x)
+invoke44763(x) = @invoke increase_x44763!(x)
 @test Base.return_types() do
     invoke44763(42)
 end |> only === Int

test/compiler/inline.jl

@@ -992,7 +992,7 @@ Base.@constprop :aggressive function conditional_escape!(cnd, x)
     return nothing
 end
 @test fully_eliminated((String,)) do x
-    Base.@invoke conditional_escape!(false::Any, x::Any)
+    @invoke conditional_escape!(false::Any, x::Any)
 end
 
 @testset "strides for ReshapedArray (PR#44027)" begin
@@ -1066,12 +1066,12 @@ let src = code_typed1() do
     @test count(isnew, src.code) == 1
 end
 let src = code_typed1() do
-        Base.@invoke FooTheRef(nothing::Any)
+        @invoke FooTheRef(nothing::Any)
     end
     @test count(isnew, src.code) == 1
 end
 let src = code_typed1() do
-        Base.@invoke FooTheRef(0::Any)
+        @invoke FooTheRef(0::Any)
     end
     @test count(isnew, src.code) == 1
 end
@@ -1084,11 +1084,11 @@ end
     nothing
 end
 @test fully_eliminated() do
-    Base.@invoke FooTheRef(nothing::Any)
+    @invoke FooTheRef(nothing::Any)
     nothing
 end
 @test fully_eliminated() do
-    Base.@invoke FooTheRef(0::Any)
+    @invoke FooTheRef(0::Any)
     nothing
 end
 

test/misc.jl

@@ -896,7 +896,7 @@ end
     # test against `invoke` doc example
     let
         f(x::Real) = x^2
-        f(x::Integer) = 1 + Base.@invoke f(x::Real)
+        f(x::Integer) = 1 + @invoke f(x::Real)
         @test f(2) == 5
     end
 
@@ -908,17 +908,22 @@ end
         _f2(_) = Real
         @test f1(1) === Integer
         @test f2(1) === Integer
-        @test Base.@invoke(f1(1::Real)) === Real
-        @test Base.@invoke(f2(1::Real)) === Integer
+        @test @invoke(f1(1::Real)) === Real
+        @test @invoke(f2(1::Real)) === Integer
     end
 
-    # when argment's type annotation is omitted, it should be specified as `Any`
+    # when argment's type annotation is omitted, it should be specified as `Core.Typeof(x)`
     let
         f(_) = Any
         f(x::Integer) = Integer
         @test f(1) === Integer
-        @test Base.@invoke(f(1::Any)) === Any
-        @test Base.@invoke(f(1)) === Any
+        @test @invoke(f(1::Any)) === Any
+        @test @invoke(f(1)) === Integer
+
+        😎(x, y) = 1
+        😎(x, ::Type{Int}) = 2
+        # Without `Core.Typeof`, the first method would be called
+        @test @invoke(😎(1, Int)) == 2
     end
 
     # handle keyword arguments correctly
@@ -927,8 +932,7 @@ end
         f(::Integer; kwargs...) = error("don't call me")
 
         @test_throws Exception f(1; kw1 = 1, kw2 = 2)
-        @test 3 == Base.@invoke f(1::Any; kw1 = 1, kw2 = 2)
-        @test 3 == Base.@invoke f(1; kw1 = 1, kw2 = 2)
+        @test 3 == @invoke f(1::Any; kw1 = 1, kw2 = 2)
     end
 end