remove the new finish_nested_frame! interface (#686)

The additional logic implemented for `RecursiveInterpreter` seems to be
no longer necessary. I think we can simply call `finish!` instead,
since there is no strong reason to add `caller->callee` relation
to the nested `CodeInfo` frame within `:thunk` expression.

Confirmed LoweredCodeUtils/Revise/Debugger still pass their test suites
with this change.

Author: aviatesk

docs/src/dev_reference.md

@@ -44,7 +44,6 @@ JuliaInterpreter.step_expr!
 JuliaInterpreter.finish!
 JuliaInterpreter.finish_and_return!
 JuliaInterpreter.finish_stack!
-JuliaInterpreter.finish_nested_frame!
 JuliaInterpreter.get_return
 JuliaInterpreter.next_until!
 JuliaInterpreter.maybe_next_until!

src/interpret.jl

@@ -520,7 +520,7 @@ function step_expr!(interp::Interpreter, frame::Frame, @nospecialize(node), isto
                     end
                 elseif node.head === :thunk
                     newframe = Frame(moduleof(frame), node.args[1]::CodeInfo)
-                    finish_nested_frame!(interp, newframe, frame)
+                    finish!(interp, newframe, true)
                     return_from(newframe)
                 elseif node.head === :global
                     Core.eval(moduleof(frame), node)
@@ -613,28 +613,6 @@ step_expr!(interp::Interpreter, frame::Frame, istoplevel::Bool=false) =
     step_expr!(interp, frame, pc_expr(frame), istoplevel)
 step_expr!(frame::Frame, istoplevel::Bool=false) = step_expr!(RecursiveInterpreter(), frame, istoplevel)
 
-# TODO Is this interface really needed?
-
-"""
-    finish_nested_frame!(interp::Interpreter, newframe::Frame, frame::Frame)
-
-Finish evaluating `newframe` and return to `frame`.
-
-This function is used when `newframe` is a nested frame embedded within `frame`.
-Specifically, it applies when `frame` contains a top‐level `Expr(:thunk)` and needs to
-interpret the `CodeInfo` embedded in that thunk. Consequently, within this function
-`newframe` is also treated as a top‐level frame during interpretation.
-"""
-function finish_nested_frame!(interp::Interpreter, newframe::Frame, frame::Frame)
-    newframe.caller = frame
-    frame.callee = newframe
-    finish!(interp, newframe, true)
-    frame.callee = nothing
-end
-function finish_nested_frame!(interp::NonRecursiveInterpreter, newframe::Frame, ::Frame)
-    finish!(interp, newframe, true)
-end
-
 """
     loc = handle_err(interp, frame, err)
 

test/utils.jl

@@ -105,15 +105,8 @@ function evaluate_limited!(interp::Interpreter, frame::Frame, nstmts::Int, istop
                 else
                     limited_interp.nstmts = nstmts
                     newframe = Frame(moduleof(frame), stmt)
-                    if isa(interp, NonRecursiveInterpreter)
-                        finish!(interp, newframe, true)
-                    else
-                        newframe.caller = frame
-                        frame.callee = newframe
-                        ret = finish_and_return!(limited_interp, newframe, true)
-                        isa(ret, Aborted) && return ret, limited_interp.nstmts
-                        frame.callee = nothing
-                    end
+                    ret = finish_and_return!(limited_interp, newframe, true)
+                    isa(ret, Aborted) && return ret, limited_interp.nstmts
                     JuliaInterpreter.recycle(newframe)
                     # Because thunks may define new methods, return to toplevel
                     frame.pc = pc + 1