struct NoFutureWarn end

struct FutureFunction{F}
    f::F
end
function (f::FutureFunction)(args...)
   # try_advance_world_age! does not mutate anything in this version as those parts are stripped out here
   # I had some caching logic which only makes sense in the application this was used for so that
   # this code will never be called for f.f again if world age could be advanced
    fnew = try_advance_world_age!(f)
    if f.f === fnew
        # The world age has advanced and f.f is now safe to use
        return fnew(args...)
    end
    @warn  "Calling $(f.f) from a future world age. This is quite slow and should be avoided if possible.
            This warning will only display once." maxlog=1
    f(NoFutureWarn(), args...)
end
(f::FutureFunction)(::NoFutureWarn, args...) = Base.invokelatest(f.f, args...)
get_current_world() = ccall(:jl_get_tls_world_age, UInt, ())

try_advance_world_age!(x, args...) = x
function try_advance_world_age!(f::FutureFunction, currentworld=get_current_world())
    all(methods(f.f)) do fmethod
        fmethod.primary_world <= currentworld
    end && return f.f
    return f
end

const relevant_world_age = Ref(Base.get_world_counter())

function update_world_age!()
    relevant_world_age[] = Ref(Base.get_world_counter())
end

function invokerelevant(f, args...; kwargs...)
    fmethod = getmethod(f, args...; kwargs...) # help! this function is made up, I don't know what to do here
    if fmethod.primary_world < relevant_world_age[]
        Base.invokelatest(fmethod, args...; kwargs..)
    else
        fmethod(args...; kwargs...)
    end
end

help?> methods
search: methods methodswith Method MethodError hasmethod

  methods(f, [types], [module])

  Return the method table for f.

  If types is specified, return an array of methods whose types match.
  If module is specified, return an array of methods defined in that
  module. A list of modules can also be specified as an array.

  │ Julia 1.4
  │
  │  At least Julia 1.4 is required for specifying a module.

  See also: which and @which.

@generated function getmethod(::F, argtypes...) where { F <: Function }
    first(methods(F.instance, argtypes))
end

julia> methods(+, (Int, Int))
# 1 method for generic function "+" from Base:
 [1] +(x::T, y::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}
     @ int.jl:87

julia> kwfunc(x; args...) = args
kwfunc (generic function with 1 method)

julia> methods(kwfunc)
# 1 method for generic function "kwfunc" from Main:
 [1] kwfunc(x; args...)
     @ REPL[2]:1

julia> methods(kwfunc)[1].sig
Tuple{typeof(kwfunc), Any}

julia> methods(kwfunc, (Int,))
# 1 method for generic function "kwfunc" from Main:
 [1] kwfunc(x; args...)
     @ REPL[2]:1

function foobar()
    @use JSON3
    JSON3.read(source)
end

@benchmark @eval blargh() = 1
#+end_src

#+RESULTS:
: BenchmarkTools.Trial: 10000 samples with 1 evaluation.
:  Range (min … max):  169.600 μs …  7.494 ms  ┊ GC (min … max): 0.00% … 93.67%
:  Time  (median):     174.199 μs              ┊ GC (median):    0.00%
:  Time  (mean ± σ):   180.871 μs ± 80.589 μs  ┊ GC (mean ± σ):  0.39% ±  0.94%
:
:   ██▅▄▂▁                                                       ▂
:   ███████▇▇▇▇███▇█▇▅▄▃▁▁▁▁▁▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▁▁▁▁▃▄▅▃▁▄▃▄▅▁▄▄▅ █
:   170 μs        Histogram: log(frequency) by time       428 μs <
:
:  Memory estimate: 6.63 KiB, allocs estimate: 126.

#+begin_src julia
f() = 1
function advance_worldage()
    @eval blah() = 1
    Base.invokelatest(f)
end
@benchmark advance_worldage()
#+end_src

#+RESULTS:
: BenchmarkTools.Trial: 10000 samples with 1 evaluation.
:  Range (min … max):  168.360 μs …  9.291 ms  ┊ GC (min … max): 0.00% … 97.52%
:  Time  (median):     173.700 μs              ┊ GC (median):    0.00%
:  Time  (mean ± σ):   182.926 μs ± 98.141 μs  ┊ GC (mean ± σ):  0.50% ±  0.98%
:
:   ▇█▅▃▂▁▁    ▂▁▁▂▁▁                                            ▂
:   ██████████████████▆▆▅▃▄▁▁▁▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▅▆▄▃▄▄▃▃▄▅▄ █
:   168 μs        Histogram: log(frequency) by time       424 μs <
:
:  Memory estimate: 6.63 KiB, allocs estimate: 126.

julia> @benchmark sum([1,2,3])
BenchmarkTools.Trial: 10000 samples with 996 evaluations.
 Range (min … max):  23.710 ns …  2.325 μs  ┊ GC (min … max):  0.00% … 96.48%
 Time  (median):     28.759 ns              ┊ GC (median):     0.00%
 Time  (mean ± σ):   33.361 ns ± 93.276 ns  ┊ GC (mean ± σ):  11.35% ±  4.01%

      ▂▄▆▅▅▆██▅▁                             ▁▁▁              ▂
  ███████████████████▇▇▆▆▅▄▅▄▄▅▅▄▄▅▅▄▅▄▄▄▄▄▆████▇▇▆▅▅▄▄▃▄▇▇▇▇ █
  23.7 ns      Histogram: log(frequency) by time      51.7 ns <

 Memory estimate: 80 bytes, allocs estimate: 1.

julia> @benchmark Base.invokelatest(sum, [1,2,3])
BenchmarkTools.Trial: 10000 samples with 988 evaluations.
 Range (min … max):  46.141 ns …  2.463 μs  ┊ GC (min … max): 0.00% … 96.64%
 Time  (median):     49.425 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   54.329 ns ± 94.346 ns  ┊ GC (mean ± σ):  7.05% ±  3.97%

   ▃▅▅▅▆█▇▅▂▁▁▁▁                             ▁▁▁              ▂
  ▅██████████████▇█▇▇▆▆▇▆▆▅▆▆▄▄▃▃▁▄▃▄▁▃▄▄▃▁▆█████▇▆▅▆▅▄▅▆▇▇▇▇ █
  46.1 ns      Histogram: log(frequency) by time        76 ns <

 Memory estimate: 80 bytes, allocs estimate: 1.

julia> @benchmark invokerecent(sum, [1,2,3])
BenchmarkTools.Trial: 10000 samples with 989 evaluations.
 Range (min … max):  44.554 ns …  2.475 μs  ┊ GC (min … max): 0.00% … 96.14%
 Time  (median):     47.411 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   52.438 ns ± 94.743 ns  ┊ GC (mean ± σ):  7.34% ±  3.98%

   ▆▆▆▇██▇▆▄▃▃▂▁▁                            ▁▂▂▁             ▃
  ██████████████████▇▇▆▆▆▅▆▆▆▃▃▁▄▄▄▁▁▁▁▁▃▃▁▅█████▇█▆▅▃▄▃▅▇███ █
  44.6 ns      Histogram: log(frequency) by time      73.4 ns <

 Memory estimate: 80 bytes, allocs estimate: 1.

julia> @benchmark getmethod(sum, [1,2,3])
BenchmarkTools.Trial: 10000 samples with 997 evaluations.
 Range (min … max):  20.349 ns …  2.378 μs  ┊ GC (min … max):  0.00% … 97.64%
 Time  (median):     24.670 ns              ┊ GC (median):     0.00%
 Time  (mean ± σ):   29.012 ns ± 93.224 ns  ┊ GC (mean ± σ):  12.67% ±  3.90%

  ▁▃▄▅▅▅▄▃▆█▇▅▁  ▁                                            ▂
  █████████████▇█████▇▆▆▆▆▄▄▅▂▄▄▄▄▄▅▅▄▄▃▅▆▇█████▆▅▅▅▃▃▄▆▆▆▇▇▇ █
  20.3 ns      Histogram: log(frequency) by time      47.4 ns <

 Memory estimate: 80 bytes, allocs estimate: 1.

function invokerecent(f::Function, args...; kwargs...)
    method = getmethod(f, args...)
    try
        if method.primary_world >= RECENT_WORLD_AGE[]
            f(args...; kwargs...)
        else
            Base.invokelatest(f, args...; kwargs...)
        end
    catch e
        if e isa PkgRequiredRerunNeeded
            update_recency!()
            invokerecent(f, args...; kwargs...)
        else
            rethrow(e)
        end
    end
end

function invokerecent2(f::Function, args...; kwargs...)
    method = getmethod(f, args...)
    res = if method.primary_world >= RECENT_WORLD_AGE[]
            f(args...; kwargs...)
        else
            Base.invokelatest(f, args...; kwargs...)
        end
    if res isa PkgRequiredRerunNeeded
        update_recency!()
        invokerecent(f, args...; kwargs...)
    else
        res
    end
end

struct Foo end
(::Foo)(x::Int) = 2x

f = Foo()
getmethod(f, 1) # function I'd like to define

@generated function getmethod(::F, argtypes...) where { F <: Function }
    first(methods(F.instance, argtypes))
end

function getmethod(t, args...)
    first(methods(t, typeof.(args)))
end

@generated function getmethod(T, args...)
    if hasmethod(empty, Tuple{Type{T}})
        first(methods(empty(T), args))
    else
        :(first(methods(T, $(args))))
    end
end