Edits to function initially ignored, until unrelated edits happen

[topolarity]

Found on Revise v3.13.1 while developing JuliaLowering (commit b4da4fc3d4):

$ ./julia --project=JuliaLowering
               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.14.0-DEV.1549 (2026-01-11)
 _/ |\__'_|_|_|\__'_|  |  Commit b4da4fc3d4* (0 days old master)
|__/                   |

julia> using Revise

julia> using JuliaLowering

Making an edit and running a test case does not show the expected println output:

shell> nvim  ~/repos/julia/JuliaLowering/src/closure_conversion.jl

shell> git --no-pager diff
diff --git i/JuliaLowering/src/closure_conversion.jl w/JuliaLowering/src/closure_conversion.jl
index c9951a7b24..3b44b0fa86 100644
--- i/JuliaLowering/src/closure_conversion.jl
+++ w/JuliaLowering/src/closure_conversion.jl
@@ -193,6 +193,7 @@ end
 # When doing this, the original value needs to be preserved, to ensure the
 # expression `a=b` always returns exactly `b`.
 function convert_assignment(ctx, ex)
+    println(stderr, "converted assignment.")
     var = ex[1]
     rhs0 = _convert_closures(ctx, ex[2])
     if kind(var) == K"Placeholder"

julia> JuliaLowering.include_string(Main, """
       function download()
           local response = 2
           foo() do output
               response = nothing
           end
       end
       """)
download (generic function with 1 method)
# assignment was never printed

This appears to be a Revise bug. Adding another edit will trigger the printing:

shell> nvim  ~/repos/julia/JuliaLowering/src/closure_conversion.jl

shell> git --no-pager diff
diff --git i/JuliaLowering/src/closure_conversion.jl w/JuliaLowering/src/closure_conversion.jl
index c9951a7b24..c5d9697d1d 100644
--- i/JuliaLowering/src/closure_conversion.jl
+++ w/JuliaLowering/src/closure_conversion.jl
@@ -193,6 +193,7 @@ end
 # When doing this, the original value needs to be preserved, to ensure the
 # expression `a=b` always returns exactly `b`.
 function convert_assignment(ctx, ex)
+    println(stderr, "converted assignment.")
     var = ex[1]
     rhs0 = _convert_closures(ctx, ex[2])
     if kind(var) == K"Placeholder"
@@ -343,6 +344,7 @@ function map_cl_convert(ctx::ClosureConversionCtx, ex, toplevel_preserving)
             ]
         end
     else
+        println(stderr, "mapchildren(...)")
         mapchildren(e->_convert_closures(ctx, e), ctx, ex)
     end
 end

julia> JuliaLowering.include_string(Main, """
       function download()
           local response = 2
           foo() do output
               response = nothing
           end
       end
       """)
mapchildren(...)
mapchildren(...)
converted assignment.
mapchildren(...)
mapchildren(...)
mapchildren(...)
mapchildren(...)
mapchildren(...)
converted assignment.
mapchildren(...)
mapchildren(...)
converted assignment.
mapchildren(...)
mapchildren(...)
mapchildren(...)
converted assignment.
mapchildren(...)
mapchildren(...)
mapchildren(...)
mapchildren(...)
converted assignment.
mapchildren(...)
mapchildren(...)
mapchildren(...)
download (generic function with 1 method)

and then deleting the additional edit preserves the expected printing:

shell> nvim  ~/repos/julia/JuliaLowering/src/closure_conversion.jl

shell> git --no-pager diff
diff --git i/JuliaLowering/src/closure_conversion.jl w/JuliaLowering/src/closure_conversion.jl
index c9951a7b24..3b44b0fa86 100644
--- i/JuliaLowering/src/closure_conversion.jl
+++ w/JuliaLowering/src/closure_conversion.jl
@@ -193,6 +193,7 @@ end
 # When doing this, the original value needs to be preserved, to ensure the
 # expression `a=b` always returns exactly `b`.
 function convert_assignment(ctx, ex)
+    println(stderr, "converted assignment.")
     var = ex[1]
     rhs0 = _convert_closures(ctx, ex[2])
     if kind(var) == K"Placeholder"

julia> JuliaLowering.include_string(Main, """
       function download()
           local response = 2
           foo() do output
               response = nothing
           end
       end
       """)
converted assignment.
converted assignment.
converted assignment.
converted assignment.
converted assignment.
download (generic function with 1 method)

Once this state is reached, I can make more edits to convert_assignment including deleted / re-adding the println statement and they all take effect as expected.

Manifest

(@v1.14) pkg> status -m
Status `~/.julia/environments/v1.14/Manifest.toml`
  [da1fd8a2] CodeTracking v3.0.0
  [807dbc54] Compiler v0.1.1
  [aa1ae85d] JuliaInterpreter v0.10.9
  [6f1432cf] LoweredCodeUtils v3.5.0
  [bac558e1] OrderedCollections v1.8.1
  [21216c6a] Preferences v1.5.1
  [295af30f] Revise v3.13.1
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [7b1f6079] FileWatching v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0
  [76f85450] LibGit2 v1.11.0
  [8f399da3] Libdl v1.11.0
  [d6f4376e] Markdown v1.11.0
  [ca575930] NetworkOptions v1.3.0
  [de0858da] Printf v1.11.0
  [3fa0cd96] REPL v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v1.0.0
  [6462fe0b] Sockets v1.11.0
  [f489334b] StyledStrings v1.13.0
  [fa267f1f] TOML v1.0.3
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.3.0+1
  [e37daf67] LibGit2_jll v1.9.2+0
  [29816b5a] LibSSH2_jll v1.11.3+1
  [458c3c95] OpenSSL_jll v3.5.4+0
  [efcefdf7] PCRE2_jll v10.47.0+0
  [83775a58] Zlib_jll v1.3.1+2

[aviatesk]

This is very strange. I debugged Revise's internals, and it appears that Revise correctly tracks files and expression changes made for the local JuliaLowering checkout (although Revise.revise has an issue due to JuliaLowering's custom include definition).

What's really strange is that the method update for JuliaLowering.convert_assignment doesn't work even when we do it manually.

julia> methods(JuliaLowering.convert_assignment)
# 1 method for generic function "convert_assignment" from JuliaLowering:
 [1] convert_assignment(ctx, ex)
     @ ~/worktrees/julia/julia-JETLS-JSJL-head/usr/share/julia/JuliaLowering/src/closure_conversion.jl:195

julia> @eval JuliaLowering function convert_assignment(ctx, ex)
           throw("foo")
       end;

julia> methods(JuliaLowering.convert_assignment)
# 1 method for generic function "convert_assignment" from JuliaLowering:
 [1] convert_assignment(ctx, ex)
     @ ~/worktrees/julia/julia-JETLS-JSJL-head/usr/share/julia/JuliaLowering/src/closure_conversion.jl:195

Manual method overwrite works for other functions:

julia> methods(JuliaLowering.nothing_)
# 1 method for generic function "nothing_" from JuliaLowering:
 [1] nothing_(ctx, ex)
     @ ~/worktrees/julia/julia-JETLS-JSJL-head/JuliaLowering/src/ast.jl:135

julia> @eval JuliaLowering nothing_(ctx, ex, x) = nothing
nothing_ (generic function with 2 methods)

julia> methods(JuliaLowering.nothing_)
# 2 methods for generic function "nothing_" from JuliaLowering:
 [1] nothing_(ctx, ex, x)
     @ REPL[71]:1
 [2] nothing_(ctx, ex)
     @ ~/worktrees/julia/julia-JETLS-JSJL-head/JuliaLowering/src/ast.jl:135

---

UPDATE: Revise certainly seems to be doing something weird. Since I confirmed @eval JuliaLowering works as expected for closure_assignment without loading Revise.

[aviatesk]

As a workaround, I confirmed that Revise appears to work when JuliaLowering precompilation is disabled:
https://github.com/JuliaLang/JuliaLowering.jl/blob/65ecb793d4aa32b51098a2a820718cb081318543/src/precompile.jl#L2

[aviatesk]

Ok, so the issue reproduces even without Revise loaded:

➜ ../julia --startup-file=no -e 'using JuliaLowering

JuliaLowering.include_string(Main, """
function download()
    local response = 2
    foo() do output
        response = nothing
    end
end
""")

@eval JuliaLowering function convert_assignment(ctx, ex)
    error("foo")
end

JuliaLowering.include_string(Main, """
function download()
    local response = 2
    foo() do output
        response = nothing
    end
end
""") # should fail, but doesn't
'

UPDATED: It's so weird that this error doesn't happen deterministically, and the above MRE and Revise sometimes works fine, probably depending on the state of precompiled cache of JuliaLowering..

[mlechu]

I was looking into this a bit last week:

module MWE

# using Mapchildren: mapchildren

function mapchildren(f0::Function, ctx, l::Vector, unused)
    out = []
    for x in l
        push!(out, f0(x))
    end
    out
end

function mapchildren(f0::Function, ctx, l)
    mapchildren(f0, ctx, l, 0)
end

global false_ = false

@noinline function map_cl_convert(ctx::Vector, l)
    mapchildren(x->_convert_closures(ctx, x), ctx, l)
end

function _convert_closures(ctx::Vector, x)
    if false_
        map_cl_convert(ctx, [x])
    end
    if x isa Vector
        map_cl_convert(ctx, x)
    else
        convert_assignment(ctx, x)
    end
end

function convert_assignment(ctx, x)
    println("this convert_assignment should be invalidated")
    (ctx, x)
end

_convert_closures(["ctx", 1], [1,2,3]) # precompile

end

Above we should have edges map_cl_convert -> mapchildren(3-arg, specialized on #lam) -> mapchildren(4-arg, specialized on #lam) -> map_cl_convert#lam -> _convert_closures -> convert_assignment. The link from map_cl_convert to specialized mapchildren isn't a CodeInstance edge, though, even though it is invoked:

julia> methods(MWE.map_cl_convert)[1].specializations[1].cache.edges |> collect
4-element Vector{Any}:
 CodeInstance for MethodInstance for Core._typeof_captured_variable(::Vector{Any})
 MethodInstance for MWE.mapchildren(::MWE.var"#map_cl_convert##0#map_cl_convert##1"{Vector{Any}}, ::Vector{Any}, ::Vector{Vector{Int64}})
 Tuple{typeof(MWE.mapchildren), Function, Any, Any}
 CodeInstance for MethodInstance for MWE.mapchildren(::Function, ::Vector{Any}, ::Vector{Vector{Int64}}) # (note 1)

which I think is the reason precompilation doesn't save mapchildren(3)'s .cache or mapchildren(4)'s backedge to it (thanks @topolarity for this insight):

julia> mi_4arg = Base.method_instance(JuliaSyntax.mapchildren, Tuple{JuliaLowering.var"#map_cl_convert##0#map_cl_convert##1"{JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}}, JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}, JuliaSyntax.SyntaxTree{Dict{Symbol, Any}}, JuliaSyntax.var"#mapchildren##1#mapchildren##2"})
MethodInstance for JuliaSyntax.mapchildren(::JuliaLowering.var"#map_cl_convert##0#map_cl_convert##1"{JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}}, ::JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}, ::SyntaxTree{Dict{Symbol, Any}}, ::JuliaSyntax.var"#mapchildren##1#mapchildren##2")

julia> mi_4arg.backedges
ERROR: UndefRefError: access to undefined reference

# (note 1) method_instances instead of method_instance, as they return different answers
# one normalizes more, which may actually have something to do with the bug.
# the other answer is a proper CodeInstance edge from map_cl_convert.
julia> mi_3arg = Base.method_instances(JuliaSyntax.mapchildren, Tuple{JuliaLowering.var"#map_cl_convert##0#map_cl_convert##1"{JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}}, JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}, JuliaSyntax.SyntaxTree{Dict{Symbol, Any}}}, Base.get_world_counter())[1]
MethodInstance for JuliaSyntax.mapchildren(::JuliaLowering.var"#map_cl_convert##0#map_cl_convert##1"{JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}}, ::JuliaLowering.ClosureConversionCtx{Dict{Symbol, Any}}, ::SyntaxTree{Dict{Symbol, Any}})

julia> mi_3arg.cache
ERROR: UndefRefError: access to undefined reference

Hence changes to convert_assignment don't trigger enough invalidations. This also means running type inference on mapchildren(3) will repair everything.

To make the MWE above reproduce, first move both mapchildren functions to a separate package, then run

julia> begin
       @eval using MWE
       @eval MWE._convert_closures(["ctx", 1], [1,2,3])
       @eval(MWE, function convert_assignment(ctx, x)
       error("foo")
       end)
       println("invalidated")
       @eval MWE._convert_closures(["ctx", 1], [1,2,3])
       end
this convert_assignment should be invalidated
this convert_assignment should be invalidated
this convert_assignment should be invalidated
invalidated
this convert_assignment should be invalidated
this convert_assignment should be invalidated
this convert_assignment should be invalidated
3-element Vector{Any}:
 (Any["ctx", 1], 1)
 (Any["ctx", 1], 2)
 (Any["ctx", 1], 3)

I bisected it to JuliaLang/julia#59436, but am assuming the bug is with the edges and not that PR's use of them. cc-ing @vtjnash to correct any of my cluelessness; I'm still not sure when it's correct to have a MethodInstance edge.