Integrate with CodeTracking and support line numbers when setting breakpoints

If the user is running an appropriate version of Revise, reported
location will update as code moves around due to edits. Because methods
can move files as well as from line-to-line, `linenumber`
should not be used except internally. (Use `whereis` instead.)

If the user is not running Revise, CodeTracking will be harmless.

Author: timholy

Project.toml

@@ -3,6 +3,7 @@ uuid = "aa1ae85d-cabe-5617-a682-6adf51b2e16a"
 version = "0.1.1"
 
 [deps]
+CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

src/JuliaInterpreter.jl

@@ -10,6 +10,7 @@ using UUIDs
 # in Base and stdlib
 using Random.DSFMT
 using InteractiveUtils
+using CodeTracking
 
 export @interpret, Compiled, JuliaStackFrame,
        Breakpoints, breakpoint, @breakpoint, breakpoints, enable, disable, remove
@@ -1084,7 +1085,8 @@ macro interpret(arg)
             push!(stack, frame)
             return stack, BreakpointRef(frame.code, 1)
         end
-        finish_and_return!(stack, frame)
+        ret = finish_and_return!(stack, frame)
+        isa(ret, BreakpointRef) ? (stack, ret) : ret
     end
 end
 

src/breakpoints.jl

@@ -3,7 +3,7 @@ module Breakpoints
 using ..JuliaInterpreter
 using JuliaInterpreter: JuliaFrameCode, JuliaStackFrame, BreakpointState,
                         truecondition, falsecondition, prepare_framecode, get_framecode,
-                        sparam_syms, linenumber
+                        sparam_syms, linenumber, statementnumber
 using Base.Meta: isexpr
 using InteractiveUtils
 
@@ -91,18 +91,22 @@ function prepare_slotfunction(framecode::JuliaFrameCode, body::Union{Symbol,Expr
     return Expr(:function, Expr(:call, funcname, framename), Expr(:block, assignments..., body))
 end
 
+const Condition = Union{Nothing,Expr,Tuple{Module,Expr}}
+_unpack(condition) = isa(condition, Expr) ? (Main, condition) : condition
+
 ## The fundamental implementations of breakpoint-setting
-function breakpoint!(framecode::JuliaFrameCode, pc, condition::Union{Bool,Expr}=true)
+function breakpoint!(framecode::JuliaFrameCode, pc, condition::Condition=nothing)
     stmtidx = convert(Int, pc)
-    if isa(condition, Bool)
-        framecode.breakpoints[stmtidx] = BreakpointState(condition)
+    if condition === nothing
+        framecode.breakpoints[stmtidx] = BreakpointState()
     else
-        fex = prepare_slotfunction(framecode, condition)
-        framecode.breakpoints[stmtidx] = BreakpointState(true, eval(fex))
+        mod, cond = _unpack(condition)
+        fex = prepare_slotfunction(framecode, cond)
+        framecode.breakpoints[stmtidx] = BreakpointState(true, Core.eval(mod, fex))
     end
     return add_breakpoint(framecode, stmtidx)
 end
-breakpoint!(frame::JuliaStackFrame, pc=frame.pc[], condition::Union{Bool,Expr}=true) =
+breakpoint!(frame::JuliaStackFrame, pc=frame.pc[], condition::Condition=nothing) =
     breakpoint!(frame.code, pc, condition)
 
 enable(bp::BreakpointRef)  = bp[] = true
@@ -126,11 +130,16 @@ end
 
 """
     breakpoint(f, sig)
+    breakpoint(f, sig, line)
     breakpoint(f, sig, condition)
+    breakpoint(f, sig, line, condition)
     breakpoint(...; enter_generated=false)
 
-Add a breakpoint upon entry to `f` with the specified argument types `sig`.
-The first will break unconditionally, the second only if `condition` evaluates to `true`.
+Add a breakpoint to `f` with the specified argument types `sig`.
+Optionally specify an absolute line number `line` in the source file; the default
+is to break upon entry at the first line of the body.
+Without `condition`, the breakpoint will be triggered every time it is encountered;
+the second only if `condition` evaluates to `true`.
 `condition` should be written in terms of the arguments and local variables of `f`.
 
 # Example
@@ -142,19 +151,33 @@ end
 breakpoint(radius2, Tuple{Int,Int}, :(y > x))
 ```
 """
-function breakpoint(f, sig::Type, condition::Union{Bool,Expr}=true; enter_generated=false)
+function breakpoint(f, sig::Type, line::Integer, condition::Condition=nothing; enter_generated=false)
+    method = which(f, sig)
+    framecode, _ = prepare_framecode(method, sig; enter_generated=enter_generated)
+    # Don't use statementnumber(method, line) in case it's enter_generated
+    linec = line - whereis(method)[2] + method.line
+    stmtidx = statementnumber(framecode, linec)
+    breakpoint!(framecode, stmtidx, condition)
+end
+function breakpoint(f, sig::Type, condition::Condition=nothing; enter_generated=false)
     method = which(f, sig)
     framecode, _ = prepare_framecode(method, sig; enter_generated=enter_generated)
     breakpoint!(framecode, 1, condition)
 end
 
 """
     breakpoint(method::Method)
+    breakpoint(method::Method, line)
     breakpoint(method::Method, condition::Expr)
+    breakpoint(method::Method, line, condition::Expr)
 
-Add a breakpoint upon entry to `method`.
+Add a breakpoint to `method`.
 """
-function breakpoint(method::Method, condition::Union{Bool,Expr}=true)
+function breakpoint(method::Method, line::Integer, condition::Condition=nothing)
+    framecode, stmtidx = statementnumber(method, line)
+    breakpoint!(framecode, stmtidx, condition)
+end
+function breakpoint(method::Method, condition::Condition=nothing)
     framecode = get_framecode(method)
     breakpoint!(framecode, 1, condition)
 end
@@ -165,19 +188,69 @@ end
 
 Break-on-entry to all methods of `f`.
 """
-function breakpoint(f, condition::Union{Bool,Expr}=true)
+function breakpoint(f, condition::Condition=nothing)
     bps = BreakpointRef[]
     for method in methods(f)
         push!(bps, breakpoint(method, condition))
     end
     return bps
 end
 
-macro breakpoint(call_expr, condition)
+"""
+    @breakpoint f(args...) condition=nothing
+    @breakpoint f(args...) line condition=nothing
+
+Break upon entry, or at the specified line number, in the method called by `f(args...)`.
+Optionally supply a condition expressed in terms of the arguments and internal variables
+of the method.
+If `line` is supplied, it must be a literal integer.
+
+# Example
+
+Suppose a method `mysum` is defined as follows, where the numbers to the left are the line
+number in the file:
+
+```
+12 function mysum(A)
+13     s = zero(eltype(A))
+14     for a in A
+15         s += a
+16     end
+17     return s
+18 end
+```
+
+Then
+
+```
+@breakpoint mysum(A) 15 s>10
+```
+
+would cause execution of the loop to break whenever `s>10`.
+"""
+macro breakpoint(call_expr, args...)
     whichexpr = InteractiveUtils.gen_call_with_extracted_types(__module__, :which, call_expr)
-    return quote
-        local method = $whichexpr
-        $breakpoint(method, $(Expr(:quote, condition)))
+    haveline, line, condition = false, 0, nothing
+    while !isempty(args)
+        arg = first(args)
+        if isa(arg, Integer)
+            haveline, line = true, arg
+        else
+            condition = arg
+        end
+        args = Base.tail(args)
+    end
+    condexpr = condition === nothing ? nothing : Expr(:quote, condition)
+    if haveline
+        return quote
+            local method = $whichexpr
+            $breakpoint(method, $line, $condexpr)
+        end
+    else
+        return quote
+            local method = $whichexpr
+            $breakpoint(method, $condexpr)
+        end
     end
 end
 

src/interpret.jl

@@ -679,30 +679,54 @@ end
 isgotonode(node) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
 
 """
-    linenumber(frame, pc=frame.pc[])
+    loc = whereis(frame, pc=frame.pc[])
 
-Return line number for `frame` at `pc` or `nothing` if it cannot be determined.
+Return the file and line number for `frame` at `pc`.  If this cannot be
+determined, `loc == nothing`. Otherwise `loc == (filepath, line)`.
+
+When `frame` represents top-level code,
 """
-function linenumber(framecode::JuliaFrameCode, pc)
+function CodeTracking.whereis(framecode::JuliaFrameCode, pc)
     codeloc = framecode.code.codelocs[convert(Int, pc)]
     codeloc == 0 && return nothing
+    lineinfo = framecode.code.linetable[codeloc]
     return framecode.scope isa Method ?
-        framecode.code.linetable[codeloc].line :
-        codeloc
+        whereis(lineinfo, framecode.scope) : string(lineinfo.file), lineinfo.line
+end
+CodeTracking.whereis(frame::JuliaStackFrame, pc=frame.pc[]) = whereis(frame.code, pc)
+
+# Note: linenumber is now an internal method for use by `next_line!`
+# If you want to know the actual line number in a file, call `whereis`.
+function linenumber(framecode::JuliaFrameCode, pc)
+    codeloc = framecode.code.codelocs[convert(Int, pc)]
+    codeloc == 0 && return nothing
+    return framecode.code.linetable[codeloc].line
 end
 linenumber(frame::JuliaStackFrame, pc=frame.pc[]) = linenumber(frame.code, pc)
 
 """
-    statementnumber(frame, line)
+    stmtidx = statementnumber(frame, line)
 
 Return the index of the first statement in `frame`'s `CodeInfo` that corresponds to `line`.
 """
 function statementnumber(framecode::JuliaFrameCode, line)
-    lineidx = searchsortedfirst(framecode.code.linetable, line; by=lin->lin.line)
+    lineidx = searchsortedfirst(framecode.code.linetable, line; by=lin->isa(lin,Integer) ? lin : lin.line)
+    1 <= lineidx <= length(framecode.code.linetable) || throw(ArgumentError("line $line not found in $(framecode.scope)"))
     return searchsortedfirst(framecode.code.codelocs, lineidx)
 end
 statementnumber(frame::JuliaStackFrame, line) = statementnumber(frame.code, line)
 
+"""
+    framecode, stmtidx = statementnumber(method, line)
+
+Return the index of the first statement in `framecode` that corresponds to the given `line` in `method`.
+"""
+function statementnumber(method::Method, line; line1=whereis(method)[2])
+    linec = line - line1 + method.line  # line number at time of compilation
+    framecode = get_framecode(method)
+    return framecode, statementnumber(framecode, linec)
+end
+
 function next_line!(stack, frame, dbstack = nothing)
     initial = linenumber(frame)
     first = true

test/breakpoints.jl

@@ -44,15 +44,11 @@ end
 
     # Conditional breakpoints on local variables
     remove()
-    stack = JuliaStackFrame[]
-    frame = JuliaInterpreter.enter_call(loop_radius2, 10)
     halfthresh = loop_radius2(5)
-    JuliaInterpreter.next_line!(stack, frame)
-    JuliaInterpreter.next_line!(stack, frame)
-    pc = frame.pc[]
-    Breakpoints.breakpoint!(frame.code, pc, :(s > $halfthresh))
-    bp = JuliaInterpreter.finish_and_return!(stack, frame)
+    @breakpoint loop_radius2(10) 5 s>$halfthresh
+    stack, bp = @interpret loop_radius2(10)
     @test isa(bp, Breakpoints.BreakpointRef)
+    frame = stack[end]
     s_extractor = eval(Breakpoints.prepare_slotfunction(frame.code, :s))
     @test s_extractor(frame) == loop_radius2(6)
     JuliaInterpreter.finish_stack!(stack)

test/interpret.jl

@@ -1,6 +1,6 @@
 using JuliaInterpreter
 using JuliaInterpreter: enter_call_expr
-using Test, InteractiveUtils
+using Test, InteractiveUtils, CodeTracking
 
 pc = JuliaInterpreter.JuliaProgramCounter(2)
 @test convert(Int, pc) == 2
@@ -216,9 +216,9 @@ function f(x)
     return x*x
 end
 frame = JuliaInterpreter.enter_call(f, 3)
-@test JuliaInterpreter.linenumber(frame, JuliaInterpreter.JuliaProgramCounter(1)) == defline + 1
-@test JuliaInterpreter.linenumber(frame, JuliaInterpreter.JuliaProgramCounter(3)) == defline + 4
-@test JuliaInterpreter.linenumber(frame, JuliaInterpreter.JuliaProgramCounter(5)) == defline + 6
+@test whereis(frame, JuliaInterpreter.JuliaProgramCounter(1))[2] == defline + 1
+@test whereis(frame, JuliaInterpreter.JuliaProgramCounter(3))[2] == defline + 4
+@test whereis(frame, JuliaInterpreter.JuliaProgramCounter(5))[2] == defline + 6
 
 # issue #28
 let a = ['0'], b = ['a']