Fix error-handling and get tests passing

Author: timholy

src/commands.jl

@@ -60,6 +60,7 @@ function finish_stack!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=fa
         recycle(frame)
         frame = caller(frame)
         frame === nothing && return ret
+        frame.callee = nothing
         pc = frame.pc
         if isassign(frame, pc)
             lhs = getlhs(pc)
@@ -69,16 +70,16 @@ function finish_stack!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=fa
         frame.pc = pc
         shouldbreak(frame) && return BreakpointRef(frame.framecode, pc)
     end
-    return frame
 end
 finish_stack!(frame::Frame, istoplevel::Bool=false) = finish_stack!(finish_and_return!, frame, istoplevel)
 
 """
-    next_until!(predicate, recurse, frame, istoplevel=false)
-    next_until!(predicate, frame, istoplevel=false)
+    pc = next_until!(predicate, recurse, frame, istoplevel=false)
+    pc = next_until!(predicate, frame, istoplevel=false)
 
 Execute the current statement. Then step through statements of `frame` until the next
-statement satifies `predicate(stmt)`.
+statement satifies `predicate(stmt)`. `pc` will be the index of the statement at which
+evaluation terminates, `nothing` (if the frame reached a `return`), or a `BreakpointRef`.
 """
 function next_until!(@nospecialize(predicate), @nospecialize(recurse), frame::Frame, istoplevel::Bool=false)
     pc = step_expr!(recurse, frame, istoplevel)

src/interpret.jl

@@ -208,13 +208,7 @@ function evaluate_call!(@nospecialize(recurse::Function), frame::Frame, call_exp
     end
     newframe = prepare_frame(frame, framecode, fargs, lenv)
     shouldbreak(newframe) && return BreakpointRef(newframe.framecode, newframe.pc)
-    ret = try
-        recurse(recurse, newframe)
-    catch e
-        frame.callee == nothing
-        recycle(newframe)
-        rethrow(e)
-    end
+    ret = recurse(recurse, newframe)  # if this errors, handle_err will pop the stack and recycle newframe
     isa(ret, BreakpointRef) && return ret
     frame.callee = nothing
     recycle(newframe)
@@ -358,6 +352,10 @@ end
 
 function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplevel::Bool)
     pc, code, data = frame.pc, frame.framecode, frame.framedata
+    if !is_leaf(frame)
+        show_stackloc(frame)
+        @show node
+    end
     @assert is_leaf(frame)
     local rhs
     # show_stackloc(frame)
@@ -525,19 +523,24 @@ function handle_err(@nospecialize(recurse), frame, err)
             return BreakpointRef(frame.framecode, frame.pc, err)
         end
     end
-    # Check for world age errors, which generally indicate a failure to go back to toplevel
-    if isa(err, MethodError)
-        is_arg_types = isa(err.args, DataType)
-        arg_types = is_arg_types ? err.args : Base.typesof(err.args...)
-        if (err.world != typemax(UInt) &&
-            hasmethod(err.f, arg_types) &&
-            !hasmethod(err.f, arg_types, world = err.world))
-            @warn "likely failure to return to toplevel, try JuliaInterpreter.split_expressions"
-            rethrow(err)
+    data = frame.framedata
+    if isempty(data.exception_frames)
+        if frame.caller !== nothing
+            frame.caller.callee = nothing
+            recycle(frame)
         end
+        # Check for world age errors, which generally indicate a failure to go back to toplevel
+        if isa(err, MethodError)
+            is_arg_types = isa(err.args, DataType)
+            arg_types = is_arg_types ? err.args : Base.typesof(err.args...)
+            if (err.world != typemax(UInt) &&
+                hasmethod(err.f, arg_types) &&
+                !hasmethod(err.f, arg_types, world = err.world))
+                @warn "likely failure to return to toplevel, try JuliaInterpreter.split_expressions"
+            end
+        end
+        rethrow(err)
     end
-    data = frame.framedata
-    isempty(data.exception_frames) && rethrow(err)
     data.last_exception[] = err
     return (frame.pc = data.exception_frames[end])
 end

src/types.jl

@@ -226,9 +226,9 @@ struct Unassigned end
 A reference to a breakpoint at a particular statement index `stmtidx` in `framecode`.
 If the break was due to an error, supply that as well.
 
-Commands that execute complex control-flow may also return a `BreakpointRef` to indicate
-that the execution stack switched frames, even when no breakpoint has been set at the
-corresponding statement.
+Commands that execute complex control-flow (e.g., `next_line!`) may also return a
+`BreakpointRef` to indicate that the execution stack switched frames, even when no
+breakpoint has been set at the corresponding statement.
 """
 struct BreakpointRef
     framecode::FrameCode