update to JuliaInterpreter 0.10 (#701)

* update to JuliaInterpreter 0.10

* more adjustments

* update docs/benchmark Manifests

Author: aviatesk

Project.toml

@@ -33,11 +33,11 @@ Cthulhu = "2.17"
 Example = "0.5.3"
 InteractiveUtils = "1.10"
 JSON3 = "1"
-JuliaInterpreter = "0.9.46"
+JuliaInterpreter = "0.10"
 JuliaSyntax = "0.4.10, 1.0"
 Libdl = "1.10"
 Logging = "1.10"
-LoweredCodeUtils = "3.2.0"
+LoweredCodeUtils = "3.3"
 MacroTools = "0.5.6"
 Pkg = "1.10"
 # PrecompileTools = "1"
@@ -64,4 +64,4 @@ TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Aqua", "BenchmarkTools", "Cthulhu", "Example", "JSON3", "Libdl", "Logging", "Random", "Revise", "StaticArrays", "TOML", "Test"]
+test = ["Aqua", "BenchmarkTools", "Cthulhu", "Example", "JSON3", "Libdl", "Logging", "Random", "StaticArrays", "TOML", "Test"]

benchmark/Manifest.toml

@@ -42,7 +42,7 @@ using CodeTracking: CodeTracking
 
 using LoweredCodeUtils: LoweredCodeUtils, add_ssa_preds!, callee_matches
 
-using JuliaInterpreter: _INACTIVE_EXCEPTION, Frame, JuliaInterpreter, is_quotenode_egal
+using JuliaInterpreter: _INACTIVE_EXCEPTION, Frame, Interpreter, JuliaInterpreter
 
 using MacroTools: @capture, normalise, striplines
 

docs/Manifest.toml

@@ -1037,11 +1037,11 @@ end
 The trait to inject code into JuliaInterpreter's interpretation process; JET.jl overloads:
 - `JuliaInterpreter.step_expr!` to add error report pass for module usage expressions and
   support package analysis
-- `JuliaInterpreter.evaluate_call_recurse!` to special case `include` calls
+- `JuliaInterpreter.evaluate_call!` to special case `include` calls
 - `JuliaInterpreter.handle_err` to wrap an error happened during interpretation into
   `ActualErrorWrapped`
 """
-struct ConcreteInterpreter{F,Analyzer<:AbstractAnalyzer}
+struct ConcreteInterpreter{F,Analyzer<:AbstractAnalyzer} <: Interpreter
     filename::String
     lnn::LineNumberNode
     usemodule_with_err_handling::F
@@ -1195,7 +1195,7 @@ function is_known_getproperty(@nospecialize(stmt), func::Symbol, stmts::Vector{A
     if (callee_matches(f, Base, :getproperty) ||
         callee_matches(f, Core, :getproperty) ||
         callee_matches(f, CC, :getproperty))
-        if is_quotenode_egal(stmt.args[3], func)
+        if JuliaInterpreter.is_quotenode_egal(stmt.args[3], func)
             return true
         end
     end
@@ -1289,7 +1289,7 @@ function JuliaInterpreter.step_expr!(interp::ConcreteInterpreter, frame::Frame,
         return frame.pc += 1
     end
 
-    res = @invoke JuliaInterpreter.step_expr!(interp::Any, frame::Frame, node::Any, istoplevel::Bool)
+    res = @invoke JuliaInterpreter.step_expr!(interp::Interpreter, frame::Frame, node::Any, istoplevel::Bool)
 
     should_analyze_from_definitions(interp.config) && collect_toplevel_signature!(interp, frame, node)
 
@@ -1360,28 +1360,27 @@ function _to_simple_module_usages(x::Expr)
     return Expr[Expr(x.head, ex) for ex in Expr[Expr(arg.head, a, a′) for a′ in as]]
 end
 
-# adapted from https://github.com/JuliaDebug/JuliaInterpreter.jl/blob/2f5f80034bc287a60fe77c4e3b5a49a087e38f8b/src/interpret.jl#L188-L199
-# works almost same as `JuliaInterpreter.evaluate_call_compiled!`, but with few important tweaks:
-# - a special handling for `include` call to recursively apply JET's analysis on the included file
-# - some `@invokelatest` are added where we directly call an user expression
-#   since `_virtual_process!` iteratively interprets toplevel expressions but the world age
-#   is not updated at each iteration so we need to make sure the user expression is
-#   evaluated in the latest world age where newly defined functions are available.
-function JuliaInterpreter.evaluate_call_recurse!(interp::ConcreteInterpreter, frame::Frame, call_expr::Expr; enter_generated::Bool=false)
+# This overload performs almost the same work as
+# `JuliaInterpreter.evaluate_call!(::JuliaInterpreter.NonRecursiveInterpreter, ...)`
+# but includes a few important adjustments specific to JET's virtual process:
+# - Special handling for `include` calls: recursively apply JET analysis to included files.
+# - Ignore C-side function definitions created via `Base._ccallable`. These definitions
+#   are not namespaced in the module and can cause false-positive name conflict errors
+#   when running analysis multiple times (see aviatesk/JET.jl#597).
+function JuliaInterpreter.evaluate_call!(interp::ConcreteInterpreter, frame::Frame, call_expr::Expr, enter_generated::Bool)
     # @assert !enter_generated
     pc = frame.pc
     ret = JuliaInterpreter.bypass_builtins(interp, frame, call_expr, pc)
     isa(ret, Some{Any}) && return ret.value
-    ret = @invokelatest JuliaInterpreter.maybe_evaluate_builtin(frame, call_expr, false)
+    ret = JuliaInterpreter.maybe_evaluate_builtin(interp, frame, call_expr, false)
     isa(ret, Some{Any}) && return ret.value
     args = JuliaInterpreter.collect_args(interp, frame, call_expr)
     f = popfirst!(args) # now it's really just `args`
     isinclude(f) && return handle_include(interp, f, args)
     if f === Base._ccallable
-        # skip concrete-interpretation of `jl_extern_c` as the C-side function definition
-        # isn't really essential for Julia-level analysis
+        # skip concrete-interpretation of `jl_extern_c`
         if length(args) == 2 && args[1] isa Type && args[2] isa Type
-            # ignore it only if the method dispatch is successful
+            # ignore only if the method dispatch is successful
             return nothing
         else
             # otherwise just call it to trigger a method error
@@ -1469,7 +1468,7 @@ function JuliaInterpreter.handle_err(interp::ConcreteInterpreter, frame::Frame,
 
     # if the last error is from this file, it's likely to be a serious error of JET
     lastframe = last(st)
-    if lastframe.file === JET_VIRTUALPROCESS_FILE && lastframe.func === :evaluate_call_recurse!
+    if lastframe.file === JET_VIRTUALPROCESS_FILE && lastframe.func === :evaluate_call!
         rethrow(err)
     end
 
@@ -1483,9 +1482,9 @@ function JuliaInterpreter.handle_err(interp::ConcreteInterpreter, frame::Frame,
         end
 
         # find an error frame that happened at `@invokelatest f(fargs...)` in the overload
-        # `JuliaInterpreter.evaluate_call_recurse!(interp::ConcreteInterpreter, frame::Frame, call_expr::Expr; enter_generated::Bool=false)`
-        if frame.file === JET_VIRTUALPROCESS_FILE && frame.func === :evaluate_call_recurse!
-            i = j - 2 # offset: `evaluate_call_recurse` -> kwfunc (`evaluate_call_recurse`)
+        # `JuliaInterpreter.evaluate_call!(::ConcreteInterpreter, ::Frame, ::Expr, ::Bool)`
+        if frame.file === JET_VIRTUALPROCESS_FILE && frame.func === :evaluate_call!
+            i = j - 1 # offset: `evaluate_call!`
             break
         end
 

src/JETBase.jl

@@ -2736,6 +2736,9 @@ let old = Pkg.project().path
 
         res = report_package(JET597; toplevel_logger=nothing)
         @test isempty(res.res.toplevel_error_reports)
+
+        res = report_package(JET597; toplevel_logger=nothing)
+        @test isempty(res.res.toplevel_error_reports)
     finally
         Pkg.activate(old; io=devnull)
     end