update to JuliaInterpreter 0.10

This commit implements the migration to the new JuliaInterpreter
interface proposed in JuliaDebug/JuliaInterpreter.jl#683.

It purely performs the migration to the new interface and does not
include any refactoring based on it.
`selective_eval!` could now be rewritten as follows using the new
interface, that change is not made in this commit for minimizing the
diff:
```diff
diff --git a/src/codeedges.jl b/src/codeedges.jl
index 3cf2a17..5eba604 100644
--- a/src/codeedges.jl
+++ b/src/codeedges.jl
@@ -1021,6 +1021,33 @@ function add_inplace!(isrequired, src, edges, norequire)
     return changed
 end

+struct SelectiveInterpreter{S<:Interpreter,T<:AbstractVector{Bool}} <: Interpreter
+    inner::S
+    isrequired::T
+end
+function JuliaInterpreter.step_expr!(interp::SelectiveInterpreter, frame::Frame, istoplevel::Bool)
+    pc = frame.pc
+    if interp.isrequired[pc]
+        step_expr!(interp.inner, frame::Frame, istoplevel::Bool)
+    else
+        next_or_nothing!(interp, frame)
+    end
+end
+function JuliaInterpreter.get_return(interp::SelectiveInterpreter, frame::Frame)
+    pc = frame.pc
+    node = pc_expr(frame, pc)
+    if is_return(node)
+        if interp.isrequired[pc]
+            return lookup_return(frame, node)
+        end
+    else
+        if isassigned(frame.framedata.ssavalues, pc)
+            return frame.framedata.ssavalues[pcexec]
+        end
+    end
+    return nothing
+end
+
 """
     selective_eval!([interp::Interpreter=RecursiveInterpreter()], frame::Frame, isrequired::AbstractVector{Bool}, istoplevel=false)

@@ -1037,27 +1064,10 @@ This will return either a `BreakpointRef`, the value obtained from the last exec
 Typically, assignment to a variable binding does not result in an ssa store by JuliaInterpreter.
 """
 function selective_eval!(interp::Interpreter, frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
-    pc = pcexec = pclast = frame.pc
-    while isa(pc, Int)
-        frame.pc = pc
-        pclast = pcexec::Int
-        if isrequired[pc]
-            pcexec = pc = step_expr!(interp, frame, istoplevel)
-        else
-            pc = next_or_nothing!(interp, frame)
-        end
-    end
-    isa(pc, BreakpointRef) && return pc
-    pcexec = (pcexec === nothing ? pclast : pcexec)::Int
-    frame.pc = pcexec
-    node = pc_expr(frame)
-    is_return(node) && return isrequired[pcexec] ? lookup_return(frame, node) : nothing
-    isassigned(frame.framedata.ssavalues, pcexec) && return frame.framedata.ssavalues[pcexec]
-    return nothing
+    return JuliaInterpreter.finish_and_return!(SelectiveInterpreter(interp, isrequired), frame, istoplevel)
 end
-function selective_eval!(frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
+selective_eval!(frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false) =
     selective_eval!(RecursiveInterpreter(), frame, isrequired, istoplevel)
-end

 """
     selective_eval_fromstart!([interp::Interpreter=RecursiveInterpreter()], frame, isrequired, istoplevel=false)
```

Author: aviatesk

Project.toml

@@ -1,13 +1,13 @@
 name = "LoweredCodeUtils"
 uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b"
 authors = ["Tim Holy <[email protected]>"]
-version = "3.2.1"
+version = "3.3.0"
 
 [deps]
 JuliaInterpreter = "aa1ae85d-cabe-5617-a682-6adf51b2e16a"
 
 [compat]
-JuliaInterpreter = "0.9.44"
+JuliaInterpreter = "0.10"
 julia = "1.10"
 
 [extras]

src/LoweredCodeUtils.jl

@@ -10,9 +10,9 @@ module LoweredCodeUtils
 # the VS Code extension integration.
 
 using JuliaInterpreter
-using JuliaInterpreter: SSAValue, SlotNumber, Frame
+using JuliaInterpreter: SSAValue, SlotNumber, Frame, Interpreter, RecursiveInterpreter
 using JuliaInterpreter: @lookup, moduleof, pc_expr, step_expr!, is_global_ref, is_global_ref_egal, is_quotenode_egal, whichtt,
-                        next_until!, finish_and_return!, get_return, nstatements, codelocation, linetable,
+                        next_until!, nstatements, codelocation, linetable,
                         is_return, lookup_return
 
 include("packagedef.jl")

src/codeedges.jl

@@ -1022,31 +1022,29 @@ function add_inplace!(isrequired, src, edges, norequire)
 end
 
 """
-    selective_eval!([recurse], frame::Frame, isrequired::AbstractVector{Bool}, istoplevel=false)
+    selective_eval!([interp::Interpreter=RecursiveInterpreter()], frame::Frame, isrequired::AbstractVector{Bool}, istoplevel=false)
 
 Execute the code in `frame` in the manner of `JuliaInterpreter.finish_and_return!`,
 but skipping all statements that are marked `false` in `isrequired`.
 See [`lines_required`](@ref). Upon entry, if needed the caller must ensure that `frame.pc` is
 set to the correct statement, typically `findfirst(isrequired)`.
 See [`selective_eval_fromstart!`](@ref) to have that performed automatically.
 
-The default value for `recurse` is `JuliaInterpreter.finish_and_return!`.
 `isrequired` pertains only to `frame` itself, not any of its callees.
 
 This will return either a `BreakpointRef`, the value obtained from the last executed statement
 (if stored to `frame.framedata.ssavlues`), or `nothing`.
 Typically, assignment to a variable binding does not result in an ssa store by JuliaInterpreter.
 """
-function selective_eval!(@nospecialize(recurse), frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
+function selective_eval!(interp::Interpreter, frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
     pc = pcexec = pclast = frame.pc
     while isa(pc, Int)
         frame.pc = pc
-        te = isrequired[pc]
         pclast = pcexec::Int
-        if te
-            pcexec = pc = step_expr!(recurse, frame, istoplevel)
+        if isrequired[pc]
+            pcexec = pc = step_expr!(interp, frame, istoplevel)
         else
-            pc = next_or_nothing!(recurse, frame)
+            pc = next_or_nothing!(interp, frame)
         end
     end
     isa(pc, BreakpointRef) && return pc
@@ -1058,22 +1056,22 @@ function selective_eval!(@nospecialize(recurse), frame::Frame, isrequired::Abstr
     return nothing
 end
 function selective_eval!(frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
-    selective_eval!(finish_and_return!, frame, isrequired, istoplevel)
+    selective_eval!(RecursiveInterpreter(), frame, isrequired, istoplevel)
 end
 
 """
-    selective_eval_fromstart!([recurse], frame, isrequired, istoplevel=false)
+    selective_eval_fromstart!([interp::Interpreter=RecursiveInterpreter()], frame, isrequired, istoplevel=false)
 
 Like [`selective_eval!`](@ref), except it sets `frame.pc` to the first `true` statement in `isrequired`.
 """
-function selective_eval_fromstart!(@nospecialize(recurse), frame, isrequired, istoplevel::Bool=false)
+function selective_eval_fromstart!(interp::Interpreter, frame, isrequired, istoplevel::Bool=false)
     pc = findfirst(isrequired)
     pc === nothing && return nothing
     frame.pc = pc
-    return selective_eval!(recurse, frame, isrequired, istoplevel)
+    return selective_eval!(interp, frame, isrequired, istoplevel)
 end
 function selective_eval_fromstart!(frame::Frame, isrequired::AbstractVector{Bool}, istoplevel::Bool=false)
-    selective_eval_fromstart!(finish_and_return!, frame, isrequired, istoplevel)
+    selective_eval_fromstart!(RecursiveInterpreter(), frame, isrequired, istoplevel)
 end
 
 """