deprecate @lookup macro in favor of lookup function (#685)

The `@lookup frame node` macro effectively inlines code in the caller’s
context to choose lookup subroutines based on the type of `node`, but
there’s no performance benefit to doing this.
A regular function call should deliver equivalent performance, and using
a function improves maintainability. Below are the benchmark results:
> master (49220f9)
```
julia> run(SUITE["recursive self 1_000"])
BenchmarkTools.Trial: 1254 samples with 1 evaluation per sample.
 Range (min … max):  3.634 ms …  13.210 ms  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     3.845 ms               ┊ GC (median):    0.00%
 Time  (mean ± σ):   3.979 ms ± 514.632 μs  ┊ GC (mean ± σ):  2.15% ± 6.18%

    ▄▇▆█▆▂▁
  ▃▇███████▇▇▇▅▄▅▄▄▄▃▃▂▂▂▂▁▁▁▁▂▂▁▂▂▂▂▂▂▂▂▁▂▂▂▂▂▂▂▃▂▂▃▂▂▂▂▂▁▂▂ ▃
  3.63 ms         Histogram: frequency by time        5.54 ms <

 Memory estimate: 1.33 MiB, allocs estimate: 44348.

julia> run(SUITE["tight loop 10_000"])
BenchmarkTools.Trial: 29 samples with 1 evaluation per sample.
 Range (min … max):  170.913 ms … 188.887 ms  ┊ GC (min … max): 0.00% … 0.46%
 Time  (median):     176.319 ms               ┊ GC (median):    0.70%
 Time  (mean ± σ):   176.275 ms ±   3.806 ms  ┊ GC (mean ± σ):  0.61% ± 0.42%

  ▁▁▁▁ ▁ █ █▁▁▁   █ █  █▁▁█▁▁ ▁▁ ▁     ▁                      ▁
  ████▁█▁█▁████▁▁▁█▁█▁▁██████▁██▁█▁▁▁▁▁█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█ ▁
  171 ms           Histogram: frequency by time          189 ms <

 Memory estimate: 24.09 MiB, allocs estimate: 1386513.

julia> run(SUITE["throw long 1_000"])
BenchmarkTools.Trial: 157 samples with 1 evaluation per sample.
 Range (min … max):  29.388 ms … 151.134 ms  ┊ GC (min … max): 0.00% … 13.02%
 Time  (median):     30.651 ms               ┊ GC (median):    0.00%
 Time  (mean ± σ):   31.861 ms ±   9.778 ms  ┊ GC (mean ± σ):  0.94% ±  2.53%

     ▂▅▇█ ▁
  ▃██████▆█▆▆▃▁▃▁▃▁▃▁▁▃▃▁▁▃▁▃▁▃▁▁▁▁▁▃▃▁▁▁▁▁▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▃ ▃
  29.4 ms         Histogram: frequency by time         42.2 ms <

 Memory estimate: 3.75 MiB, allocs estimate: 85380.
```

> this PR
```
julia> run(SUITE["recursive self 1_000"])
BenchmarkTools.Trial: 1277 samples with 1 evaluation per sample.
 Range (min … max):  3.662 ms …   7.569 ms  ┊ GC (min … max): 0.00% … 49.27%
 Time  (median):     3.809 ms               ┊ GC (median):    0.00%
 Time  (mean ± σ):   3.908 ms ± 341.900 μs  ┊ GC (mean ± σ):  1.76% ±  5.62%

    ▃▅█▄▂▂
  ▄▇██████▇▄▄▃▃▃▃▃▃▃▃▃▃▂▂▂▁▂▂▂▂▁▂▁▁▁▁▁▁▁▂▁▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂ ▃
  3.66 ms         Histogram: frequency by time        5.27 ms <

 Memory estimate: 1.33 MiB, allocs estimate: 44348.

julia> run(SUITE["tight loop 10_000"])
BenchmarkTools.Trial: 29 samples with 1 evaluation per sample.
 Range (min … max):  170.863 ms … 178.231 ms  ┊ GC (min … max): 0.57% … 2.61%
 Time  (median):     173.559 ms               ┊ GC (median):    0.56%
 Time  (mean ± σ):   173.568 ms ±   1.643 ms  ┊ GC (mean ± σ):  0.55% ± 0.57%

  ▁█   ▁   █ ▁ ▁▁   ▁▁▁█▁▁▁█ ██▁   ▁   ▁  ▁   ▁               ▁
  ██▁▁▁█▁▁▁█▁█▁██▁▁▁████████▁███▁▁▁█▁▁▁█▁▁█▁▁▁█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█ ▁
  171 ms           Histogram: frequency by time          178 ms <

 Memory estimate: 24.09 MiB, allocs estimate: 1386514.

julia> run(SUITE["throw long 1_000"])
BenchmarkTools.Trial: 175 samples with 1 evaluation per sample.
 Range (min … max):  27.760 ms … 37.426 ms  ┊ GC (min … max): 0.00% … 20.80%
 Time  (median):     28.402 ms              ┊ GC (median):    0.00%
 Time  (mean ± σ):   28.698 ms ±  1.185 ms  ┊ GC (mean ± σ):  0.65% ±  2.76%

     ▄█▄▁  ▄
  ▃▅█████▇▇█▄▄▂▃▂▂▃▁▂▁▁▁▁▁▁▁▁▂▁▁▁▁▁▁▁▁▂▁▁▁▁▁▁▂▂▁▁▁▁▁▂▁▁▁▁▁▁▁▂ ▂
  27.8 ms         Histogram: frequency by time        34.3 ms <

 Memory estimate: 3.75 MiB, allocs estimate: 85380.
```

Author: aviatesk

bin/generate_builtins.jl

@@ -90,7 +90,7 @@ function generate_fcall_nargs(fname, minarg, maxarg; requires_world::Bool=false)
         wrapper *= "$nargs\n            "
         argcall = ""
         for i = 1:nargs
-            argcall *= "@lookup(frame, args[$(i+1)])"
+            argcall *= "lookup(frame, args[$(i+1)])"
             if i < nargs
                 argcall *= ", "
             end
@@ -144,7 +144,7 @@ function getargs(args, frame)
     nargs = length(args)-1  # skip f
     callargs = resize!(frame.framedata.callargs, nargs)
     for i = 1:nargs
-        callargs[i] = @lookup(frame, args[i+1])
+        callargs[i] = lookup(frame, args[i+1])
     end
     return callargs
 end
@@ -175,7 +175,7 @@ function maybe_evaluate_builtin(frame, call_expr, expand::Bool)
     if isa(fex, QuoteNode)
         f = fex.value
     else
-        f = @lookup(frame, fex)
+        f = lookup(frame, fex)
     end
 
     if f isa Core.OpaqueClosure
@@ -208,7 +208,7 @@ function maybe_evaluate_builtin(frame, call_expr, expand::Bool)
             print(io,
 """
     $head f === tuple
-        return Some{Any}(ntupleany(i->@lookup(frame, args[i+1]), length(args)-1))
+        return Some{Any}(ntupleany(i::Int->lookup(frame, args[i+1]), length(args)-1))
 """)
             continue
         elseif f === Core._apply_iterate
@@ -293,13 +293,13 @@ function maybe_evaluate_builtin(frame, call_expr, expand::Bool)
         if nargs == 1
             call_expr = copy(call_expr)
             args2 = args[2]
-            call_expr.args[2] = isa(args2, QuoteNode) ? args2 : @lookup(frame, args2)
+            call_expr.args[2] = isa(args2, QuoteNode) ? args2 : lookup(frame, args2)
             return Some{Any}(Core.eval(moduleof(frame), call_expr))
         elseif nargs == 2
             call_expr = copy(call_expr)
             args2 = args[2]
-            call_expr.args[2] = isa(args2, QuoteNode) ? args2 : @lookup(frame, args2)
-            call_expr.args[3] = @lookup(frame, args[3])
+            call_expr.args[2] = isa(args2, QuoteNode) ? args2 : lookup(frame, args2)
+            call_expr.args[3] = lookup(frame, args[3])
             return Some{Any}(Core.eval(moduleof(frame), call_expr))
         end
 """)

docs/src/dev_reference.md

@@ -99,7 +99,7 @@ JuliaInterpreter.interpreted_methods
 
 ```@docs
 JuliaInterpreter.eval_code
-JuliaInterpreter.@lookup
+JuliaInterpreter.lookup
 JuliaInterpreter.is_wrapper_call
 JuliaInterpreter.is_doc_expr
 JuliaInterpreter.is_global_ref

src/builtins.jl

@@ -9,6 +9,33 @@ function lookup_var(frame::Frame, slot::SlotNumber)
     throw(UndefVarError(frame.framecode.src.slotnames[slot.id]))
 end
 
+"""
+    lookup(frame::Frame, node)
+
+Looks up previously-computed values referenced as `SSAValue`, `SlotNumber`,
+`GlobalRef`, sparam or exception reference expression.
+It will also lookup `Symbol`s as global reference in the context of `moduleof(frame)::Module`.
+If none of the above apply, the value of `node` will be returned.
+"""
+function lookup(frame::Frame, @nospecialize(node))
+    if isa(node, SSAValue)
+        return lookup_var(frame, node)
+    elseif isa(node, GlobalRef)
+        return lookup_var(frame, node)
+    elseif isa(node, SlotNumber)
+        return lookup_var(frame, node)
+    elseif isa(node, Symbol)
+        return @invokelatest getglobal(moduleof(frame), node)
+    elseif isa(node, Expr)
+        return lookup_expr(frame, node)
+    else # fallback
+        if isa(node, QuoteNode)
+            return node.value
+        end
+        return node
+    end
+end
+
 function gen_lookup_ex(frame, node)
     :(let node = $(esc(node))
         isa(node, SSAValue) ? lookup_var($(esc(frame)), node) :
@@ -20,21 +47,13 @@ function gen_lookup_ex(frame, node)
         node # fallback
     end)
 end
-
-"""
-    rhs = @lookup(frame, node)
-
-This macro looks up previously-computed values referenced as SSAValues, SlotNumbers,
-GlobalRefs, QuoteNode, sparam or exception reference expression.
-It will also lookup symbols in `moduleof(frame)`.
-If none of the above apply, the value of `node` itself will be returned.
-"""
 macro lookup(frame, node)
+    @warn "`@lookup` at $f:$l is deprecated, use `lookup(frame, node)` instead."
     return gen_lookup_ex(frame, node)
 end
 macro lookup(_, frame, node)
     f, l = __source__.file, __source__.line
-    @warn "`@lookup(mod, frame, node)` at $f:$l is deprecated, use `@lookup(frame, node)` instead."
+    @warn "`@lookup(mod, frame, node)` at $f:$l is deprecated, use `lookup(frame, node)` instead."
     return gen_lookup_ex(frame, node)
 end
 
@@ -52,13 +71,13 @@ function lookup_expr(frame::Frame, e::Expr)
     end
     head === :boundscheck && length(e.args) == 0 && return true
     if head === :call
-        f = @lookup frame e.args[1]
+        f = lookup(frame, e.args[1])
         if (@static VERSION < v"1.11.0-DEV.1180" && true) && f === Core.svec
             # work around for a linearization bug in Julia (https://github.com/JuliaLang/julia/pull/52497)
-            return f(Any[@lookup(frame, e.args[i]) for i in 2:length(e.args)]...)
+            return f(Any[lookup(frame, e.args[i]) for i in 2:length(e.args)]...)
         elseif f === Core.tuple
             # handling for ccall literal syntax
-            return f(Any[@lookup(frame, e.args[i]) for i in 2:length(e.args)]...)
+            return f(Any[lookup(frame, e.args[i]) for i in 2:length(e.args)]...)
         end
     end
     error("invalid lookup expr ", e)
@@ -143,12 +162,12 @@ end
 function collect_args(@nospecialize(recurse), frame::Frame, call_expr::Expr; isfc::Bool=false)
     args = frame.framedata.callargs
     resize!(args, length(call_expr.args))
-    args[1] = isfc ? resolvefc(frame, call_expr.args[1]) : @lookup(frame, call_expr.args[1])
+    args[1] = isfc ? resolvefc(frame, call_expr.args[1]) : lookup(frame, call_expr.args[1])
     for i = 2:length(args)
         if isexpr(call_expr.args[i], :call)
             args[i] = lookup_or_eval(recurse, frame, call_expr.args[i])
         else
-            args[i] = @lookup(frame, call_expr.args[i])
+            args[i] = lookup(frame, call_expr.args[i])
         end
     end
     return args
@@ -318,17 +337,17 @@ function evaluate_methoddef(frame::Frame, node::Expr)
         end
     end
     length(node.args) == 1 && return f
-    sig = @lookup(frame, node.args[2])::SimpleVector
-    body = @lookup(frame, node.args[3])::Union{CodeInfo, Expr}
+    sig = lookup(frame, node.args[2])::SimpleVector
+    body = lookup(frame, node.args[3])::Union{CodeInfo, Expr}
     method = ccall(:jl_method_def, Any, (Any, Ptr{Cvoid}, Any, Any), sig, C_NULL, body, moduleof(frame)::Module)::Method
     return method
 end
 
 function evaluate_overlayed_methoddef(frame::Frame, node::Expr, mt::MethodTable)
     # Overlaying an empty function such as `function f end` is not legal, and `f` must
     # already be defined so we don't need to do as much work as in `evaluate_methoddef`.
-    sig = @lookup(frame, node.args[2])::SimpleVector
-    body = @lookup(frame, node.args[3])::Union{CodeInfo, Expr}
+    sig = lookup(frame, node.args[2])::SimpleVector
+    body = lookup(frame, node.args[3])::Union{CodeInfo, Expr}
     method = ccall(:jl_method_def, Any, (Any, Any, Any, Any), sig, mt, body, moduleof(frame)::Module)::Method
     return method
 end
@@ -382,13 +401,13 @@ maybe_assign!(frame::Frame, @nospecialize(val)) = maybe_assign!(frame, pc_expr(f
 function eval_rhs(@nospecialize(recurse), frame::Frame, node::Expr)
     head = node.head
     if head === :new
-        args = Any[@lookup(frame, arg) for arg in node.args]
+        args = Any[lookup(frame, arg) for arg in node.args]
         T = popfirst!(args)::DataType
         rhs = ccall(:jl_new_structv, Any, (Any, Ptr{Any}, UInt32), T, args, length(args))
         return rhs
     elseif head === :splatnew  # Julia 1.2+
-        T = @lookup(frame, node.args[1])::DataType
-        args = @lookup(frame, node.args[2])::Tuple
+        T = lookup(frame, node.args[1])::DataType
+        args = lookup(frame, node.args[2])::Tuple
         rhs = ccall(:jl_new_structt, Any, (Any, Any), T, args)
         return rhs
     elseif head === :isdefined
@@ -484,7 +503,7 @@ function step_expr!(@nospecialize(recurse), frame::Frame, @nospecialize(node), i
                 if isa(rhs, Expr)
                     rhs = eval_rhs(recurse, frame, rhs)
                 else
-                    rhs = @lookup(frame, rhs)
+                    rhs = lookup(frame, rhs)
                 end
                 isa(rhs, BreakpointRef) && return rhs
                 do_assignment!(frame, lhs, rhs)
@@ -522,7 +541,7 @@ function step_expr!(@nospecialize(recurse), frame::Frame, @nospecialize(node), i
                 elseif node.head === :const || node.head === :globaldecl
                     g = node.args[1]
                     if length(node.args) == 2
-                        Core.eval(moduleof(frame), Expr(:block, Expr(node.head, g, @lookup(frame, node.args[2])), nothing))
+                        Core.eval(moduleof(frame), Expr(:block, Expr(node.head, g, lookup(frame, node.args[2])), nothing))
                     else
                         Core.eval(moduleof(frame), Expr(:block, Expr(node.head, g), nothing))
                     end
@@ -572,7 +591,7 @@ function step_expr!(@nospecialize(recurse), frame::Frame, @nospecialize(node), i
             @assert is_leaf(frame)
             return (frame.pc = node.label)
         elseif isa(node, GotoIfNot)
-            arg = @lookup(frame, node.cond)
+            arg = lookup(frame, node.cond)
             if !isa(arg, Bool)
                 throw(TypeError(nameof(frame), "if", Bool, arg))
             end
@@ -591,10 +610,10 @@ function step_expr!(@nospecialize(recurse), frame::Frame, @nospecialize(node), i
             rhs = node.catch_dest
             push!(data.exception_frames, rhs)
             if isdefined(node, :scope)
-                push!(data.current_scopes, @lookup(frame, node.scope))
+                push!(data.current_scopes, lookup(frame, node.scope))
             end
         else
-            rhs = @lookup(frame, node)
+            rhs = lookup(frame, node)
         end
     catch err
         return handle_err(recurse, frame, err)
@@ -670,7 +689,7 @@ function handle_err(@nospecialize(recurse), frame::Frame, @nospecialize(err))
     return pc
 end
 
-lookup_return(frame, node::ReturnNode) = @lookup(frame, node.val)
+lookup_return(frame::Frame, node::ReturnNode) = lookup(frame, node.val)
 
 """
     ret = get_return(frame)

src/interpret.jl

@@ -186,7 +186,7 @@ function build_compiled_llvmcall!(stmt::Expr, code::CodeInfo, idx::Int, evalmod:
             pc === nothing && error("this should never happen")
         end
     end
-    llvmir, RetType, ArgType = @lookup(frame, stmt.args[2]), @lookup(frame, stmt.args[3]), @lookup(frame, stmt.args[4])::DataType
+    llvmir, RetType, ArgType = lookup(frame, stmt.args[2]), lookup(frame, stmt.args[3]), lookup(frame, stmt.args[4])::DataType
     args = stmt.args[5:end]
     argnames = Any[Symbol(:arg, i) for i = 1:length(args)]
     cc_key = (llvmir, RetType, ArgType, evalmod)  # compiled call key

src/optimize.jl

@@ -1,5 +1,5 @@
 using CodeTracking, JuliaInterpreter, Test
-using JuliaInterpreter: enter_call, enter_call_expr, get_return, @lookup
+using JuliaInterpreter: enter_call, enter_call_expr, get_return
 using Base.Meta: isexpr
 include("utils.jl")
 
@@ -275,7 +275,7 @@ end
         frame = fr = JuliaInterpreter.enter_call(f_va_outer, 1)
         # depending on whether this is in or out of a @testset, the first statement may differ
         stmt1 = fr.framecode.src.code[1]
-        if isexpr(stmt1, :call) && @lookup(frame, stmt1.args[1]) === getfield
+        if isexpr(stmt1, :call) && JuliaInterpreter.lookup(frame, stmt1.args[1]) === getfield
             fr, pc = debug_command(fr, :se)
         end
         fr, pc = debug_command(fr, :s)
@@ -462,7 +462,7 @@ end
         frame = JuliaInterpreter.enter_call(f, 2, 3) # at sin
         frame, pc = debug_command(frame, :n)
         # Check that we are at the kw call to g
-        @test Core.kwfunc(g) == JuliaInterpreter.@lookup frame JuliaInterpreter.pc_expr(frame).args[1]
+        @test Core.kwfunc(g) == JuliaInterpreter.lookup(frame, JuliaInterpreter.pc_expr(frame).args[1])
         # Step into the inner g
         frame, pc = debug_command(frame, :s)
         # Finish the frame and make sure we step out of the wrapper
@@ -477,7 +477,7 @@ end
         frame = JuliaInterpreter.enter_call(h_1, 2, 1)
         frame, pc = debug_command(frame, :s)
         # Should have skipped the kwprep in h_2 and be at call to kwfunc h_3
-        @test Core.kwfunc(h_3) == JuliaInterpreter.@lookup frame JuliaInterpreter.pc_expr(frame).args[1]
+        @test Core.kwfunc(h_3) == JuliaInterpreter.lookup(frame, JuliaInterpreter.pc_expr(frame).args[1])
     end
 
     @testset "si should not step through wrappers or kwprep" begin

test/debug.jl

@@ -1,5 +1,5 @@
 using JuliaInterpreter
-using JuliaInterpreter: Frame, @lookup
+using JuliaInterpreter: Frame
 using JuliaInterpreter: finish_and_return!, evaluate_call!, step_expr!, shouldbreak,
                         do_assignment!, SSAValue, isassign, pc_expr, handle_err, get_return,
                         moduleof