From 02e4fe2cce00817c1721a5549b692a0263c014b3 Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki Date: Fri, 1 Aug 2025 03:42:12 +0900 Subject: [PATCH] remove no longer used `methodinfo` argument from `minimal_evaluation!` --- src/lowered.jl | 22 +++++++++++----------- src/precompile.jl | 2 +- test/backedges.jl | 3 +-- 3 files changed, 13 insertions(+), 14 deletions(-) diff --git a/src/lowered.jl b/src/lowered.jl index 2741be42..06dbe25d 100644 --- a/src/lowered.jl +++ b/src/lowered.jl @@ -108,7 +108,7 @@ function defines_function(@nospecialize(ci)) end """ - isrequired, evalassign = minimal_evaluation!([predicate,] methodinfo, src::Core.CodeInfo, mode::Symbol) + isrequired, evalassign = minimal_evaluation!([predicate,] src::Core.CodeInfo, mode::Symbol) Mark required statements in `src`: `isrequired[i]` is `true` if `src.code[i]` should be evaluated. Statements are analyzed by `isreq, haseval = predicate(stmt)`, and `predicate` defaults @@ -117,7 +117,7 @@ to `Revise.is_method_or_eval`. Since the contents of such expression are difficult to analyze, it is generally safest to execute all such evals. """ -function minimal_evaluation!(@nospecialize(predicate), methodinfo, mod::Module, src::Core.CodeInfo, mode::Symbol) +function minimal_evaluation!(@nospecialize(predicate), mod::Module, src::Core.CodeInfo, mode::Symbol) edges = CodeEdges(mod, src) # LoweredCodeUtils.print_with_code(stdout, src, edges) isrequired = fill(false, length(src.code)) @@ -177,11 +177,11 @@ function minimal_evaluation!(@nospecialize(predicate), methodinfo, mod::Module, # LoweredCodeUtils.print_with_code(stdout, src, isrequired) return isrequired, evalassign end -@noinline minimal_evaluation!(@nospecialize(predicate), methodinfo, frame::Frame, mode::Symbol) = - minimal_evaluation!(predicate, methodinfo, moduleof(frame), frame.framecode.src, mode) +@noinline minimal_evaluation!(@nospecialize(predicate), frame::Frame, mode::Symbol) = + minimal_evaluation!(predicate, moduleof(frame), frame.framecode.src, mode) -function minimal_evaluation!(methodinfo, frame::Frame, mode::Symbol) - minimal_evaluation!(methodinfo, frame, mode) do @nospecialize(stmt), code::Vector{Any} +function minimal_evaluation!(frame::Frame, mode::Symbol) + minimal_evaluation!(frame, mode) do @nospecialize(stmt), code::Vector{Any} ismeth, haseval, isinclude, isnamespace, istoplevel = categorize_stmt(stmt, code) isreq = ismeth | isinclude | istoplevel return mode === :sigs ? (isreq, haseval) : (isreq | isnamespace, haseval) @@ -190,7 +190,7 @@ end function methods_by_execution(mod::Module, ex::Expr; kwargs...) methodinfo = MethodInfo() - value, thk = methods_by_execution!(JuliaInterpreter.Compiled(), methodinfo, mod, ex; kwargs...) + _, thk = methods_by_execution!(JuliaInterpreter.Compiled(), methodinfo, mod, ex; kwargs...) return methodinfo, thk end @@ -252,7 +252,7 @@ function methods_by_execution!(interp::Interpreter, methodinfo, mod::Module, ex: frame = Frame(mod, lwr.args[1]::CodeInfo) mode === :eval || LoweredCodeUtils.rename_framemethods!(interp, frame) # Determine whether we need interpreted mode - isrequired, evalassign = minimal_evaluation!(methodinfo, frame, mode) + isrequired, evalassign = minimal_evaluation!(frame, mode) # LoweredCodeUtils.print_with_code(stdout, frame.framecode.src, isrequired) if !any(isrequired) && (mode===:eval || !evalassign) # We can evaluate the entire expression in compiled mode @@ -283,7 +283,7 @@ function methods_by_execution!(interp::Interpreter, methodinfo, mod::Module, ex: ret = try _methods_by_execution!(interp, methodinfo, frame, isrequired; mode, kwargs...) catch err - (always_rethrow || isa(err, InterruptException)) && (disablebp && foreach(enable, active_bp_refs); rethrow(err)) + (always_rethrow || isa(err, InterruptException)) && (@isdefined(active_bp_refs) && foreach(enable, active_bp_refs); rethrow(err)) loc = location_string(whereis(frame)) sfs = [] # crafted for interaction with Base.show_backtrace frame = JuliaInterpreter.leaf(frame) @@ -293,7 +293,7 @@ function methods_by_execution!(interp::Interpreter, methodinfo, mod::Module, ex: end throw(ReviseEvalException(loc, err, sfs)) end - if disablebp + if @isdefined active_bp_refs foreach(enable, active_bp_refs) end end @@ -327,7 +327,7 @@ function _methods_by_execution!(interp::Interpreter, methodinfo, frame::Frame, i ex isa Expr || continue value, _ = methods_by_execution!(interp, methodinfo, mod, ex; mode, disablebp=false, skip_include) end - isassign(frame, pc) && assign_this!(frame, value) + isassign(frame, pc) && @isdefined(value) && assign_this!(frame, value) pc = next_or_nothing!(frame) elseif head === :thunk && defines_function(only(stmt.args)) mode !== :sigs && Core.eval(mod, stmt) diff --git a/src/precompile.jl b/src/precompile.jl index da192d4c..9160f9d2 100644 --- a/src/precompile.jl +++ b/src/precompile.jl @@ -39,7 +39,7 @@ function _precompile_() @warnpcfail precompile(Tuple{typeof(setindex!), Dict{String,WatchList}, WatchList, String}) MI = CodeTrackingMethodInfo - @warnpcfail precompile(Tuple{typeof(minimal_evaluation!), Any, MI, Module, Core.CodeInfo, Symbol}) + @warnpcfail precompile(Tuple{typeof(minimal_evaluation!), Any, Module, Core.CodeInfo, Symbol}) @warnpcfail precompile(Tuple{typeof(methods_by_execution!), Compiled, MI, Module, Expr}) @warnpcfail precompile(Tuple{typeof(_methods_by_execution!), Compiled, MI, Frame, Vector{Bool}}) @warnpcfail precompile(Tuple{typeof(Core.kwfunc(methods_by_execution!)), diff --git a/test/backedges.jl b/test/backedges.jl index 349d3310..c705df7e 100644 --- a/test/backedges.jl +++ b/test/backedges.jl @@ -15,8 +15,7 @@ do_test("Backedges") && @testset "Backedges" begin # Find the inner struct def for the anonymous function idtype = findall(stmt->isexpr(stmt, :thunk) && isa(stmt.args[1], Core.CodeInfo), src.code)[end] src2 = src.code[idtype].args[1] - methodinfo = Revise.MethodInfo() - isrequired = Revise.minimal_evaluation!(methodinfo, frame, :sigs)[1] + isrequired = Revise.minimal_evaluation!(frame, :sigs)[1] laststmt = src.code[end] @assert isa(laststmt, Core.ReturnNode) to_skip = isa(laststmt.val, Revise.JuliaInterpreter.SSAValue) ? 2 : 1