add util functionality for evaluating code in a frame

Author: KristofferC

docs/src/dev_reference.md

@@ -96,6 +96,7 @@ JuliaInterpreter.compiled_modules
 ## Utilities
 
 ```@docs
+JuliaInterpreter.eval_code
 JuliaInterpreter.@lookup
 JuliaInterpreter.is_wrapper_call
 JuliaInterpreter.is_doc_expr

src/utils.jl

@@ -364,6 +364,46 @@ function print_vars(io::IO, vars::Vector{Variable})
     end
 end
 
+"""
+    eval_code(frame::Frame, code::Union{String, Expr})
+
+Evaluate `code` in the context of `frame`, updating any local variables
+(including type parameters) that are reassigned in `code`. New local variables
+cannot be introduced.
+"""
+function eval_code end
+
+eval_code(frame::Frame, command::AbstractString) = eval_code(frame, Base.parse_input_line(command))
+function eval_code(frame::Frame, expr)
+    maybe_quote(x) = (isa(x, Expr) || isa(x, Symbol)) ? QuoteNode(x) : x
+
+    isexpr(expr, :toplevel) && (expr = expr.args[end])
+
+    if isexpr(expr, :toplevel)
+      expr = Expr(:block, expr.args...)
+    end
+    # see https://github.com/JuliaLang/julia/issues/31255 for the Symbol("") check
+    vars = filter(v -> v.name != Symbol(""), locals(frame))
+    res = gensym()
+    eval_expr = Expr(:let,
+        Expr(:block, map(x->Expr(:(=), x...), [(v.name, maybe_quote(v.value)) for v in vars])...),
+        Expr(:block,
+            Expr(:(=), res, expr),
+            Expr(:tuple, res, Expr(:tuple, [v.name for v in vars]...))
+        ))
+    eval_res, res = Core.eval(moduleof(frame), eval_expr)
+    j = 1
+    for (i, v) in enumerate(vars)
+        if v.isparam
+            frame.framedata.sparams[j] = res[i]
+            j += 1
+        else
+            frame.framedata.locals[frame.framedata.last_reference[v.name]] = Some{Any}(res[i])
+        end
+    end
+    eval_res
+end
+
 function show_stackloc(io::IO, frame)
     indent = ""
     fr = root(frame)

test/eval_code.jl

@@ -0,0 +1,42 @@
+import JuliaInterpreter.eval_code
+
+# Simple evaling of function argument
+function evalfoo1(x,y)
+    x+y
+end
+frame = JuliaInterpreter.enter_call(evalfoo1, 1, 2)
+@test eval_code(frame, "x") == 1
+@test eval_code(frame, "y") == 2
+
+# Evaling with sparams
+evalsparams(x::T) where T = x
+frame = JuliaInterpreter.enter_call(evalsparams, 1)
+@test eval_code(frame, "x") == 1
+eval_code(frame, "x = 3")
+@test eval_code(frame, "x") == 3
+@test eval_code(frame, "T") == Int
+eval_code(frame, "T = Float32")
+@test eval_code(frame, "T") == Float32
+
+# Evaling with keywords
+evalkw(x; bar=true) = x
+frame = JuliaInterpreter.enter_call(evalkw, 2)
+frame = JuliaInterpreter.maybe_step_through_wrapper!(frame)
+@test eval_code(frame, "x") == 2
+@test eval_code(frame, "bar") == true
+eval_code(frame, "bar = false")
+@test eval_code(frame, "bar") == false
+
+# Evaling with symbols
+evalsym() = (x = :foo)
+frame = JuliaInterpreter.enter_call(evalsym)
+# Step until the local actually end up getting defined
+JuliaInterpreter.step_expr!(frame)
+JuliaInterpreter.step_expr!(frame)
+@test eval_code(frame, "x") == :foo
+
+# Evaling multiple statements (https://github.com/JuliaDebug/Debugger.jl/issues/188)
+frame = JuliaInterpreter.enter_call(evalfoo1, 1, 2)
+@test eval_code(frame, "x = 1; y = 2") == 2
+@test eval_code(frame, "x") == 1
+@test eval_code(frame, "y") == 2

test/runtests.jl

@@ -13,6 +13,7 @@ JuliaInterpreter.debug_recycle[] = true
     include("interpret.jl")
     include("toplevel.jl")
     include("limits.jl")
+    include("eval_code.jl")
     include("breakpoints.jl")
     remove()
     include("debug.jl")