Breakpoint setting for inverted linetable (#673)

Author: timholy

Project.toml

@@ -9,7 +9,7 @@ Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [compat]
-CodeTracking = "0.5.9, 1"
+CodeTracking = "1.3.9"
 julia = "1.10"
 
 [extras]

src/utils.jl

@@ -269,7 +269,7 @@ function linetable(arg, i::Integer; macro_caller::Bool=false, def=:var"n/a")::Un
     # TODO: decode the linetable at this frame efficiently by reimplementing this here
     nodes = Base.IRShow.buildLineInfoNode(lt, def, i)
     isempty(nodes) && return nothing
-    return nodes[1] # ignore all inlining / macro expansion / etc :(
+    return nodes[macro_caller ? 1 : end]
     else # VERSION < v"1.12.0-DEV.173"
     lin = lt[i]::Union{Expr,LineTypes}
     if macro_caller
@@ -450,60 +450,36 @@ function statementnumbers(framecode::FrameCode, line::Integer, file::Symbol)
         0
     end
 
-    lt = linetable(framecode)
-
-    # Check if the exact line number exist
-    idxs = findall(entry::Union{LineInfoNode,LineNumberNode} -> entry.line + offset == line && entry.file == file, lt)
-    locs = codelocs(framecode)
-    if !isempty(idxs)
-        stmtidxs = Int[]
-        stmtidx = 1
-        while stmtidx <= length(locs)
-            loc = locs[stmtidx]
-            if loc in idxs
-                push!(stmtidxs, stmtidx)
-                stmtidx += 1
-                # Skip continous statements that are on the same line
-                while stmtidx <= length(locs) && loc == locs[stmtidx]
-                    stmtidx += 1
-                end
-            else
-                stmtidx += 1
-            end
-        end
-        return stmtidxs
+    linetarget = line - offset
+
+    lts = CodeTracking.linetable_scopes(framecode.src, scope)
+    for lt in lts
+        filter!(l -> l.file === file, lt) # filter out line scopes that do not match the file we are looking for
     end
 
-    # If the exact line number does not exist in the line table, take the one that is closest after that line
-    # restricted to the line range of the current scope.
-    scope = framecode.scope
-    range = (scope isa Method && !is_generated(scope)) ? compute_corrected_linerange(scope) : compute_linerange(framecode)
-    if line in range
-        closest = nothing
-        closest_idx = nothing
-        for (i, entry) in enumerate(lt)
-            entry = entry::Union{LineInfoNode,LineNumberNode}
-            if entry.file == file && entry.line in range && entry.line >= line
-                if closest === nothing
-                    closest = entry
-                    closest_idx = i
-                else
-                    if entry.line < closest.line
-                        closest = entry
-                        closest_idx = i
-                    end
-                end
-            end
+    stmtidxs = Int[] # will store the statement indices that match the line
+    first_in_block, block_recorded = nothing, false
+    for (i, lt) in enumerate(lts)
+        # If someone asks for a breakpoint on, e.g., `end`, there may not be a line that matches exactly.
+        # In this case, we should make sure that the scope encompasses the requested line and then return the first statement index
+        # immediately after.
+        if isempty(lt)
+            first_in_block = nothing   # start new block
+            continue
+        end
+        thisscope = first(lt)
+        if first_in_block === nothing && !iszero(thisscope.line)
+            first_in_block, block_recorded = thisscope.line, false
         end
-        if closest_idx !== nothing
-            idx = let closest_idx=closest_idx    # julia #15276
-                findfirst(i-> i==closest_idx, locs)
+        if !block_recorded   # only record the first match in a contiguous block
+            # if it's either an exact match or it's the first larger line in a block that spans the requested line, store it
+            if thisscope.line == linetarget || (thisscope.line > linetarget && something(first_in_block, typemax(typeof(thisscope.line))) < linetarget)
+                push!(stmtidxs, i)
+                block_recorded = true
             end
-            return idx === nothing ? nothing : Int[idx]
         end
     end
-
-    return nothing
+    return stmtidxs
 end
 
 ## Printing

test/breakpoints.jl

@@ -20,7 +20,8 @@ end
 close(io)
 include(tmppath)
 
-using JuliaInterpreter, CodeTracking, Test
+# Don't move these to the top, because line numbers matter for the tests below
+using JuliaInterpreter, CodeTracking, Test, Logging
 
 function stacklength(frame)
     n = 1
@@ -215,7 +216,7 @@ struct Squarer end
     end
     fr, bp = @interpret f_outer_bp(3)
     @test leaf(fr).framecode.scope.name === :g_inner_bp
-    @test bp.stmtidx == (@static VERSION >= v"1.11-" ? 4 : 3)
+    @test bp.stmtidx == (@static VERSION >= v"1.12-" ? 5 : VERSION >= v"1.11-" ? 4 : 3)
 
     # Breakpoints on types
     remove()
@@ -247,25 +248,25 @@ mktemp() do path, io
     include(path)
     frame, bp = @interpret somefunc(2, 3)
     @test bp isa BreakpointRef
-    @test JuliaInterpreter.whereis(frame) == (path, 3)
+    @test whereis(frame) == (path, 3)
     breakpoint(path, 2)
     frame, bp = @interpret somefunc(2, 3)
     @test bp isa BreakpointRef
-    @test JuliaInterpreter.whereis(frame) == (path, 2)
+    @test whereis(frame) == (path, 2)
     remove()
     # Test relative paths
     mktempdir(dirname(path)) do tmp
         cd(tmp) do
             breakpoint(joinpath("..", basename(path)), 3)
             frame, bp = @interpret somefunc(2, 3)
             @test bp isa BreakpointRef
-            @test JuliaInterpreter.whereis(frame) == (path, 3)
+            @test whereis(frame) == (path, 3)
             remove()
             breakpoint(joinpath("..", basename(path)), 3)
             cd(homedir()) do
                 frame, bp = @interpret somefunc(2, 3)
                 @test bp isa BreakpointRef
-                @test JuliaInterpreter.whereis(frame) == (path, 3)
+                @test whereis(frame) == (path, 3)
             end
         end
     end
@@ -302,7 +303,7 @@ using Dates
         breakpoint(f, l)
         frame, bp = @interpret now() - Month(2)
         @test bp isa BreakpointRef
-        @test JuliaInterpreter.whereis(frame)[2] == l
+        @test whereis(frame)[2] == l
     end
 end
 
@@ -315,7 +316,7 @@ end
         breakpoint(f, l)
         frame, bp = @interpret sin(2.0)
         @test bp isa BreakpointRef
-        @test JuliaInterpreter.whereis(frame)[2] == l
+        @test whereis(frame)[2] == l
     end
 end
 
@@ -499,7 +500,7 @@ end
     bp = breakpoint(@__FILE__, ln + 4)
     frame, bpref = @interpret f_emptylines()
     @test bpref isa BreakpointRef
-    @test JuliaInterpreter.whereis(frame) == (@__FILE__, ln + 6)
+    @test whereis(frame) == (@__FILE__, ln + 6)
     remove(bp)
 
     # Don't break if the line is outside the function
@@ -518,23 +519,27 @@ end
     frame = JuliaInterpreter.enter_call(f_macro)
     file_logging = String(only(methods(var"@info")).file)
     line_logging = 0
-    for entry in frame.framecode.src.linetable
-        if entry.file === Symbol(file_logging)
-            line_logging = entry.line
-            break
+    lts = CodeTracking.linetable_scopes(JuliaInterpreter.scopeof(frame))
+    for lt in lts
+        for entry in lt
+            if entry.file === Symbol(file_logging)
+                line_logging = entry.line
+                break
+            end
         end
+        line_logging > 0 && break
     end
+    @assert line_logging > 0
     bp_log = breakpoint(file_logging, line_logging)
     with_logger(NullLogger()) do
         frame, bp = @interpret f_macro()
         @test bp isa BreakpointRef
-        file, ln = JuliaInterpreter.whereis(frame)
+        file, ln = whereis(frame)
         @test ln == line_logging
         @test basename(file) == basename(file_logging)
         bp = JuliaInterpreter.finish_stack!(frame)
         @test bp isa BreakpointRef
-        frame = leaf(frame)
-        ret = JuliaInterpreter.finish_stack!(frame)
+        ret = JuliaInterpreter.finish_stack!(leaf(frame))
         @test ret == 2
     end
 
@@ -565,14 +570,14 @@ end
 
         with_logger(NullLogger()) do
             frame, bp = @interpret f_check(1)
-            file, ln = JuliaInterpreter.whereis(frame)
+            file, ln = whereis(frame)
             @test file == path # Should not have stopped in logging.jl at line `line_logging`
             @test ln == line_logging
             remove(bp_f)
             @test (@interpret f_check(1)) == 1
             breakpoint(f_check, line_logging)
             frame, bp = @interpret f_check(1)
-            file, ln = JuliaInterpreter.whereis(frame)
+            file, ln = whereis(frame)
             @test file == path # Should not have stopped in logging.jl at line `line_logging`
             @test ln == line_logging
         end