Add Base.invoke_in_world

Add internal, experimental function invoke_in_world() in analogy to
applylatest(). This makes Core._apply_in_world easier to call,
(especially for keyword args) and gives us a place to hang the
documentation.

Author: c42f

base/essentials.jl

@@ -714,6 +714,41 @@ function invokelatest(@nospecialize(f), @nospecialize args...; kwargs...)
     Core._apply_latest(inner)
 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::Integer, @nospecialize(f), @nospecialize args...; kwargs...)
+    world = convert(UInt, world)
+    if isempty(kwargs)
+        return Core._apply_in_world(world, f, args)
+    end
+    inner() = f(args...; kwargs...)
+    Core._apply_in_world(world, inner)
+end
+
 # TODO: possibly make this an intrinsic
 inferencebarrier(@nospecialize(x)) = Ref{Any}(x)[]
 

test/worlds.jl

@@ -200,10 +200,15 @@ notify(c26506_1)
 wait(c26506_2)
 @test result26506[1] == 3
 
-# _apply_in_world builtin
-f_aiw(x) = "world one; x=$x"
+# invoke_in_world
+f_inworld(x) = "world one; x=$x"
+g_inworld(x; y) = "world one; x=$x, y=$y"
 wc_aiw1 = get_world_counter()
-f_aiw(x) = "world two; x=$x"
+f_inworld(x) = "world two; x=$x"
+g_inworld(x; y) = "world two; x=$x, y=$y"
 wc_aiw2 = get_world_counter()
-@test Core._apply_in_world(wc_aiw1, f_aiw, (2,)) == "world one; x=2"
-@test Core._apply_in_world(wc_aiw2, f_aiw, (2,)) == "world two; x=2"
+@test Base.invoke_in_world(wc_aiw1, f_inworld, 2) == "world one; x=2"
+@test Base.invoke_in_world(wc_aiw2, f_inworld, 2) == "world two; x=2"
+@test Base.invoke_in_world(wc_aiw1, g_inworld, 2, y=3) == "world one; x=2, y=3"
+@test Base.invoke_in_world(wc_aiw2, g_inworld, 2, y=3) == "world two; x=2, y=3"
+