Improve struct revision handling with retry mechanism

Add retry logic for methods that fail to re-evaluate when struct
definitions change. Instead of immediately failing, these methods are
queued in `pending_eval_sigs` and retried in subsequent revise() calls.

Also enhance method detection with `hastype_by_name()` to catch methods
using old world-age versions of types by comparing TypeName module and
name rather than identity. We may want to unify `hastype` and
`hastype_by_name`.

Author: aviatesk

src/packagedef.jl

@@ -157,6 +157,9 @@ const __bpart__ = Base.VERSION >= v"1.12.0-DEV.2047"
 # Julia 1.12+: when bindings switch to a new type, we need to re-evaluate method
 # definitions using the new binding resolution.
 const reeval_methods = Set{Method}()
+# Track (signature, module, method) tuples for methods that failed to re-evaluate
+# due to type incompatibility and need retry when types become compatible again
+const pending_eval_sigs = Set{Tuple{MethodInfoKey, Module, Method}}()
 
 """
     Revise.NOPACKAGE
@@ -889,6 +892,26 @@ function revise(; throw::Bool=false)
                 queue_errors[(pkgdata, file)] = (err, catch_backtrace())
             end
         end
+        # Retry methods that previously failed to re-evaluate
+        if !isempty(pending_eval_sigs)
+            for (mt_sig, mod, m) in collect(pending_eval_sigs)
+                methinfo = get(CodeTracking.method_info, mt_sig, nothing)
+                if methinfo !== nothing && length(methinfo) == 1
+                    _, ex = methinfo[1]
+                    try
+                        invokelatest(eval_with_signatures, mod, ex; mode=:eval)
+                        # If successful, remove from both queues
+                        delete!(CodeTracking.method_info, mt_sig)
+                        delete!(pending_eval_sigs, (mt_sig, mod, m))
+                        with_logger(_debug_logger) do
+                            @debug "RetrySucceeded" _group="Action" time=time() deltainfo=(mod, ex)
+                        end
+                    catch
+                        # Keep in queue for later
+                    end
+                end
+            end
+        end
         # Handle binding invalidations
         if !isempty(reeval_methods)
             handled = Base.IdSet{Type}()
@@ -923,10 +946,17 @@ function revise(; throw::Bool=false)
                     !iszero(m.dispatch_status) && with_logger(_debug_logger) do
                         @debug "DeleteMethod" _group="Action" time=time() deltainfo=(m.sig, MethodSummary(m))
                         Base.delete_method(m)  # ensure that "old data" doesn't get run with "old methods"
-                        delete!(CodeTracking.method_info, mt_sig)
                         _, ex = methinfo[1]
-                        @debug "Eval" _group="Action" time=time() deltainfo=(mod, ex)
-                        invokelatest(eval_with_signatures, m.module, ex; mode=:eval)
+                        @debug "Eval" _group="Action" time=time() deltainfo=(m.module, ex)
+                        try
+                            invokelatest(eval_with_signatures, m.module, ex; mode=:eval)
+                            delete!(CodeTracking.method_info, mt_sig)
+                        catch err
+                            # Re-evaluation failed, likely due to type incompatibility
+                            # Store in pending_eval_sigs for retry when types become compatible
+                            push!(pending_eval_sigs, (mt_sig, m.module, m))
+                            @debug "EvalFailed" _group="Action" time=time() deltainfo=(m.module, ex, err)
+                        end
                     end
                     push!(handled, m.sig)
                 end

src/visit.jl

@@ -7,7 +7,9 @@ function methods_with(@nospecialize(T::Type))
         # condition commented out due to https://github.com/timholy/Revise.jl/pull/894#issuecomment-3274102493
         # see the "MoreConstructors" test case in test/runtests.jl
         # if method.module !== Tname.module || method.name !== Tname.name  # skip constructor
-            hastype(method.sig, T) && push!(meths, method)
+            if hastype(method.sig, T) || hastype_by_name(method.sig, Tname)
+                push!(meths, method)
+            end
         # end
     end
     return meths
@@ -44,3 +46,27 @@ function hassubtype(@nospecialize(S), @nospecialize(T))
     end
     return false
 end
+
+# Check if a type signature S contains a reference to a type with the given TypeName
+# This is useful for finding methods that reference old world-age versions of a type
+function hastype_by_name(@nospecialize(S), Tname::Core.TypeName)
+    isa(S, TypeVar) && return hastype_by_name(S.ub, Tname)
+    isa(S, Type) || return false
+    S_unwrapped = Base.unwrap_unionall(S)
+    isa(S_unwrapped, Core.TypeofBottom) && return false
+    if isa(S_unwrapped, Union)
+        return hastype_by_name(S_unwrapped.a, Tname) | hastype_by_name(S_unwrapped.b, Tname)
+    end
+    Base.isvarargtype(S_unwrapped) && return hastype_by_name(S_unwrapped.T, Tname)
+    if isa(S_unwrapped, DataType)
+        # Compare TypeNames by their module and name, not by identity (===)
+        # This is necessary because different world-age versions of a type have different TypeName objects
+        if S_unwrapped.name.module === Tname.module && S_unwrapped.name.name === Tname.name
+            return true
+        end
+        for P in S_unwrapped.parameters
+            hastype_by_name(P, Tname) && return true
+        end
+    end
+    return false
+end