add until_line! to step to next line lower down in source code (#266)

Author: KristofferC

docs/src/dev_reference.md

@@ -46,6 +46,7 @@ JuliaInterpreter.maybe_evaluate_builtin
 JuliaInterpreter.next_call!
 JuliaInterpreter.maybe_next_call!
 JuliaInterpreter.next_line!
+JuliaInterpreter.until_line!
 JuliaInterpreter.maybe_reset_frame!
 JuliaInterpreter.maybe_step_through_wrapper!
 JuliaInterpreter.maybe_step_through_kwprep!

src/commands.jl

@@ -180,6 +180,25 @@ function next_line!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=false
 end
 next_line!(frame::Frame, istoplevel::Bool=false) = next_line!(finish_and_return!, frame, istoplevel)
 
+"""
+    pc = until_line!(recurse, frame, line=nothing istoplevel=false)
+    pc = until_line!(frame, line=nothing, istoplevel=false)
+
+Execute until the current frame reaches a line greater than `line`. If `line == nothing`
+execute until the current frame reaches any line greater than the current line.
+"""
+function until_line!(@nospecialize(recurse), frame::Frame, line::Union{Nothing, Integer}=nothing, istoplevel::Bool=false)
+    pc = frame.pc
+    initialline, initialfile = linenumber(frame, pc), getfile(frame, pc)
+    line === nothing && (line = initialline + 1)
+    predicate(frame) = isexpr(pc_expr(frame), :return) || (linenumber(frame) >= line && getfile(frame) == initialfile)
+    pc = next_until!(predicate, frame, istoplevel)
+    (pc === nothing || isa(pc, BreakpointRef)) && return pc
+    maybe_step_through_kwprep!(recurse, frame, istoplevel)
+    maybe_next_call!(recurse, frame, istoplevel)
+end
+until_line!(frame::Frame, line::Union{Nothing, Integer}=nothing, istoplevel::Bool=false) = until_line!(finish_and_return!, frame, line, istoplevel)
+
 """
     cframe = maybe_step_through_wrapper!(recurse, frame)
     cframe = maybe_step_through_wrapper!(frame)
@@ -343,13 +362,15 @@ function unwind_exception(frame::Frame, exc)
 end
 
 """
-    ret = debug_command(recurse, frame, cmd, rootistoplevel=false)
-    ret = debug_command(frame, cmd, rootistoplevel=false)
+    ret = debug_command(recurse, frame, cmd, rootistoplevel=false; line=nothing)
+    ret = debug_command(frame, cmd, rootistoplevel=false; line=nothing)
 
-Perform one "debugger" command. `cmd` should be one of:
+Perform one "debugger" command. The keyword arguments are not used for all debug commands.
+`cmd` should be one of:
 
 - `:n`: advance to the next line
 - `:s`: step into the next call
+- `:until`: advance the frame to line `line` if given, otherwise advance to the line after the current line
 - `:c`: continue execution until termination or reaching a breakpoint
 - `:finish`: finish the current frame and return to the parent
 
@@ -362,7 +383,7 @@ or one of the 'advanced' commands
 
 `rootistoplevel` and `ret` are as described for [`JuliaInterpreter.maybe_reset_frame!`](@ref).
 """
-function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootistoplevel::Bool=false)
+function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootistoplevel::Bool=false; line=nothing)
     function nicereturn!(@nospecialize(recurse), frame, pc, rootistoplevel)
         if pc === nothing || isa(pc, BreakpointRef)
             return maybe_reset_frame!(recurse, frame, pc, rootistoplevel)
@@ -383,6 +404,7 @@ function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootis
         cmd == :nc && return nicereturn!(recurse, frame, next_call!(recurse, frame, istoplevel), rootistoplevel)
         cmd == :n && return maybe_reset_frame!(recurse, frame, next_line!(recurse, frame, istoplevel), rootistoplevel)
         cmd == :se && return maybe_reset_frame!(recurse, frame, step_expr!(recurse, frame, istoplevel), rootistoplevel)
+        cmd == :until && return maybe_reset_frame!(recurse, frame, until_line!(recurse, frame, line, istoplevel), rootistoplevel)
 
         enter_generated = false
         if cmd == :sg
@@ -434,5 +456,5 @@ function debug_command(@nospecialize(recurse), frame::Frame, cmd::Symbol, rootis
     end
     throw(ArgumentError("command $cmd not recognized"))
 end
-debug_command(frame::Frame, cmd::Symbol, rootistoplevel::Bool=false) =
-    debug_command(finish_and_return!, frame, cmd, rootistoplevel)
+debug_command(frame::Frame, cmd::Symbol, rootistoplevel::Bool=false; kwargs...) =
+    debug_command(finish_and_return!, frame, cmd, rootistoplevel; kwargs...)

test/debug.jl

@@ -2,7 +2,7 @@ using JuliaInterpreter, Test
 using JuliaInterpreter: enter_call, enter_call_expr, get_return, @lookup
 using Base.Meta: isexpr
 
-const ALL_COMMANDS = (:n, :s, :c, :finish, :nc, :se, :si)
+const ALL_COMMANDS = (:n, :s, :c, :finish, :nc, :se, :si, :until)
 
 function step_through_command(fr::Frame, cmd::Symbol)
     while true
@@ -85,6 +85,27 @@ struct B{T} end
         @test step_through(:($(gcd)(10,20))) == gcd(10, 20)
     end
 
+    @testset "until" begin
+        function f_with_lines(s)
+            sin(2.0)
+            cos(2.0)
+            for i in 1:100
+                s += i
+            end
+            sin(2.0)
+        end
+        meth_def = @__LINE__() - 8
+
+        frame = enter_call(f_with_lines, 0)
+        @test whereis(frame)[2] == meth_def + 1
+        debug_command(frame, :until)
+        @test whereis(frame)[2] == meth_def + 2
+        debug_command(frame, :until; line=(meth_def + 4))
+        @test whereis(frame)[2] == meth_def + 4
+        debug_command(frame, :until; line=(meth_def + 6))
+        @test whereis(frame)[2] == meth_def + 6
+    end
+
     @testset "generated" begin
         frame = enter_call_expr(:($(callgenerated)()))
         f, pc = debug_command(frame, :s)