cleanup old builtins (#57532)

The `_apply_pure` function only has one user, and that user is unsound
anyways and should not be used, so replace that with equivalent
`_call_in_world_total` call and remove unnecessary definitions.

The awkward distinction between `invokelatest` and `_call_latest` has
not been relevant (and indeed causes performance issues) since kwfunc
was introduced in #47157.

Author: vtjnash

Compiler/src/abstractinterpretation.jl

@@ -778,7 +778,7 @@ function edge_matches_sv(interp::AbstractInterpreter, frame::AbsIntState,
         # If the method defines a recursion relation, give it a chance
         # to tell us that this recursion is actually ok.
         if isdefined(method, :recursion_relation)
-            if Core._apply_pure(method.recursion_relation, Any[method, callee_method2, sig, frame_instance(frame).specTypes])
+            if Core._call_in_world_total(get_world_counter(), method.recursion_relation, method, callee_method2, sig, frame_instance(frame).specTypes)
                 return false
             end
         end

Compiler/src/ssair/show.jl

@@ -67,7 +67,7 @@ function builtin_call_has_dispatch(
                 return true
             end
         end
-    elseif (f === Core._apply_pure || f === Core._call_in_world || f === Core._call_in_world_total || f === Core._call_latest)
+    elseif (f === Core.invoke_in_world || f === Core._call_in_world_total || f === Core.invokelatest)
         # These apply-like builtins are effectively dynamic calls
         return true
     end

Compiler/src/verifytrim.jl

@@ -153,11 +153,10 @@ function may_dispatch(@nospecialize ftyp)
         # other builtins (including the IntrinsicFunctions) are good
         return Core._apply isa ftyp ||
                Core._apply_iterate isa ftyp ||
-               Core._apply_pure isa ftyp ||
-               Core._call_in_world isa ftyp ||
                Core._call_in_world_total isa ftyp ||
-               Core._call_latest isa ftyp ||
                Core.invoke isa ftyp ||
+               Core.invoke_in_world isa ftyp ||
+               Core.invokelatest isa ftyp ||
                Core.finalizer isa ftyp ||
                Core.modifyfield! isa ftyp ||
                Core.modifyglobal! isa ftyp ||

base/Base_compiler.jl

@@ -202,6 +202,63 @@ function Core._hasmethod(@nospecialize(f), @nospecialize(t)) # this function has
     return Core._hasmethod(tt)
 end
 
+"""
+    invokelatest(f, args...; kwargs...)
+
+Calls `f(args...; kwargs...)`, but guarantees that the most recent method of `f`
+will be executed.   This is useful in specialized circumstances,
+e.g. long-running event loops or callback functions that may
+call obsolete versions of a function `f`.
+(The drawback is that `invokelatest` is somewhat slower than calling
+`f` directly, and the type of the result cannot be inferred by the compiler.)
+
+!!! compat "Julia 1.9"
+    Prior to Julia 1.9, this function was not exported, and was called as `Base.invokelatest`.
+"""
+const invokelatest = Core.invokelatest
+
+# define invokelatest(f, args...; kwargs...), without kwargs wrapping
+# to forward to invokelatest
+function Core.kwcall(kwargs::NamedTuple, ::typeof(invokelatest), f, args...)
+    @inline
+    return Core.invokelatest(Core.kwcall, kwargs, f, args...)
+end
+setfield!(typeof(invokelatest).name.mt, :max_args, 2, :monotonic) # invokelatest, f, args...
+
+"""
+    invoke_in_world(world, f, args...; kwargs...)
+
+Call `f(args...; kwargs...)` in a fixed world age, `world`.
+
+This is useful for infrastructure running in the user's Julia session which is
+not part of the user's program. For example, things related to the REPL, editor
+support libraries, etc. In these cases it can be useful to prevent unwanted
+method invalidation and recompilation latency, and to prevent the user from
+breaking supporting infrastructure by mistake.
+
+The current world age can be queried using [`Base.get_world_counter()`](@ref)
+and stored for later use within the lifetime of the current Julia session, or
+when serializing and reloading the system image.
+
+Technically, `invoke_in_world` will prevent any function called by `f` from
+being extended by the user during their Julia session. That is, generic
+function method tables seen by `f` (and any functions it calls) will be frozen
+as they existed at the given `world` age. In a sense, this is like the opposite
+of [`invokelatest`](@ref).
+
+!!! note
+    It is not valid to store world ages obtained in precompilation for later use.
+    This is because precompilation generates a "parallel universe" where the
+    world age refers to system state unrelated to the main Julia session.
+"""
+const invoke_in_world = Core.invoke_in_world
+
+function Core.kwcall(kwargs::NamedTuple, ::typeof(invoke_in_world), world::UInt, f, args...)
+    @inline
+    return Core.invoke_in_world(world, Core.kwcall, kwargs, f, args...)
+end
+setfield!(typeof(invoke_in_world).name.mt, :max_args, 3, :monotonic) # invoke_in_world, world, f, args...
+
 # core operations & types
 include("promotion.jl")
 include("tuple.jl")

base/boot.jl

@@ -1014,8 +1014,11 @@ _parse = nothing
 
 _setparser!(parser) = setglobal!(Core, :_parse, parser)
 
-# support for deprecated uses of internal _apply function
-_apply(x...) = Core._apply_iterate(Main.Base.iterate, x...)
+# support for deprecated uses of builtin functions
+_apply(x...) = _apply_iterate(Main.Base.iterate, x...)
+_apply_pure(x...) = invoke_in_world_total(typemax_UInt, x...)
+const _call_latest = invokelatest
+const _call_in_world = invoke_in_world
 
 struct Pair{A, B}
     first::A

base/essentials.jl

@@ -1070,63 +1070,6 @@ end
 
 Val(x) = Val{x}()
 
-"""
-    invokelatest(f, args...; kwargs...)
-
-Calls `f(args...; kwargs...)`, but guarantees that the most recent method of `f`
-will be executed.   This is useful in specialized circumstances,
-e.g. long-running event loops or callback functions that may
-call obsolete versions of a function `f`.
-(The drawback is that `invokelatest` is somewhat slower than calling
-`f` directly, and the type of the result cannot be inferred by the compiler.)
-
-!!! compat "Julia 1.9"
-    Prior to Julia 1.9, this function was not exported, and was called as `Base.invokelatest`.
-"""
-function invokelatest(@nospecialize(f), @nospecialize args...; kwargs...)
-    @inline
-    kwargs = merge(NamedTuple(), kwargs)
-    if isempty(kwargs)
-        return Core._call_latest(f, args...)
-    end
-    return Core._call_latest(Core.kwcall, kwargs, f, args...)
-end
-
-"""
-    invoke_in_world(world, f, args...; kwargs...)
-
-Call `f(args...; kwargs...)` in a fixed world age, `world`.
-
-This is useful for infrastructure running in the user's Julia session which is
-not part of the user's program. For example, things related to the REPL, editor
-support libraries, etc. In these cases it can be useful to prevent unwanted
-method invalidation and recompilation latency, and to prevent the user from
-breaking supporting infrastructure by mistake.
-
-The current world age can be queried using [`Base.get_world_counter()`](@ref)
-and stored for later use within the lifetime of the current Julia session, or
-when serializing and reloading the system image.
-
-Technically, `invoke_in_world` will prevent any function called by `f` from
-being extended by the user during their Julia session. That is, generic
-function method tables seen by `f` (and any functions it calls) will be frozen
-as they existed at the given `world` age. In a sense, this is like the opposite
-of [`invokelatest`](@ref).
-
-!!! note
-    It is not valid to store world ages obtained in precompilation for later use.
-    This is because precompilation generates a "parallel universe" where the
-    world age refers to system state unrelated to the main Julia session.
-"""
-function invoke_in_world(world::UInt, @nospecialize(f), @nospecialize args...; kwargs...)
-    @inline
-    kwargs = Base.merge(NamedTuple(), kwargs)
-    if isempty(kwargs)
-        return Core._call_in_world(world, f, args...)
-    end
-    return Core._call_in_world(world, Core.kwcall, kwargs, f, args...)
-end
-
 """
     inferencebarrier(x)
 

base/reflection.jl

@@ -1283,9 +1283,9 @@ function invokelatest_gr(gr::GlobalRef, @nospecialize args...; kwargs...)
     @inline
     kwargs = merge(NamedTuple(), kwargs)
     if isempty(kwargs)
-        return Core._call_latest(apply_gr, gr, args...)
+        return invokelatest(apply_gr, gr, args...)
     end
-    return Core._call_latest(apply_gr_kw, kwargs, gr, args...)
+    return invokelatest(apply_gr_kw, kwargs, gr, args...)
 end
 
 """

contrib/generate_precompile.jl

@@ -46,7 +46,6 @@ precompile(Tuple{typeof(Base.Threads.atomic_sub!), Base.Threads.Atomic{Int}, Int
 precompile(Tuple{Type{Base.Val{x} where x}, Module})
 precompile(Tuple{Type{NamedTuple{(:honor_overrides,), T} where T<:Tuple}, Tuple{Bool}})
 precompile(Tuple{typeof(Base.unique!), Array{String, 1}})
-precompile(Tuple{typeof(Base.invokelatest), Any})
 precompile(Tuple{typeof(Base.vcat), Array{String, 1}, Array{String, 1}})
 
 # Pkg loading

contrib/juliac-buildscript.jl

@@ -38,17 +38,8 @@ end
     init_active_project() = nothing
     disable_library_threading() = nothing
     start_profile_listener() = nothing
-    @inline function invokelatest(f::F, args...; kwargs...) where F
-        return f(args...; kwargs...)
-    end
-    @inline function invokelatest_gr(gr::GlobalRef, @nospecialize args...; kwargs...)
-        @inline
-        kwargs = merge(NamedTuple(), kwargs)
-        if isempty(kwargs)
-            return apply_gr(gr, args...)
-        end
-        return apply_gr_kw(kwargs, gr, args...)
-    end
+    invokelatest_trimmed(f, args...; kwargs...) = f(args...; kwargs...)
+    const invokelatest = invokelatest_trimmed
     function sprint(f::F, args::Vararg{Any,N}; context=nothing, sizehint::Integer=0) where {F<:Function,N}
         s = IOBuffer(sizehint=sizehint)
         if context isa Tuple

src/builtin_proto.h

@@ -22,10 +22,9 @@ extern "C" {
 #endif
 
 DECLARE_BUILTIN(_apply_iterate);
-DECLARE_BUILTIN(_apply_pure);
-DECLARE_BUILTIN(_call_in_world);
+DECLARE_BUILTIN(invoke_in_world);
 DECLARE_BUILTIN(_call_in_world_total);
-DECLARE_BUILTIN(_call_latest);
+DECLARE_BUILTIN(invokelatest);
 DECLARE_BUILTIN(_compute_sparams);
 DECLARE_BUILTIN(_expr);
 DECLARE_BUILTIN(_svec_ref);