wip

Author: vtjnash

base/staticdata.jl

@@ -293,6 +293,51 @@ function get_method_from_edge(@nospecialize t)
     end
 end
 
+# Check if method2 is in method1's interferences set
+# Returns true if method2 is found (meaning !morespecific(method1, method2))
+function method_in_interferences(method1::Method, method2::Method)
+    interferences = method1.interferences
+    for k = 1:length(interferences)
+        isassigned(interferences, k) || break
+        interference_method = interferences[k]::Method
+        if interference_method === method2
+            return true
+        end
+    end
+    return false
+end
+
+# Check if method1 is more specific than method2 via the interference graph
+function method_morespecific_via_interferences(method1::Method, method2::Method)
+    if method1 === method2 || method_in_interferences(method1, method2)
+        return false
+    end
+    return method_in_interferences_recursive(method2, method1, IdSet{Method}())
+end
+
+# Returns true if method2 is in method1's interferences (meaning !morespecific(method2, method1))
+function method_in_interferences_recursive(method2::Method, method1::Method, visited::IdSet{Method})
+    @assert !method_in_interferences(method1, method2)
+    if method_in_interferences(method2, method1)
+        return true
+    end
+
+    # Recursively check through interference graph
+    push!(visited, method2)
+    interferences = method1.interferences
+    for k = 1:length(interferences)
+        isassigned(interferences, k) || break
+        method3 = interferences[k]::Method
+        if !(method3 in visited)
+            if method_in_interferences_recursive(method3, method1, visited)
+                return true # found method1 in the interference graph
+            end
+        end
+    end
+
+    return false
+end
+
 function verify_call(@nospecialize(sig), expecteds::Core.SimpleVector, i::Int, n::Int, world::UInt, fully_covers::Bool, matches::Vector{Any})
     # verify that these edges intersect with the same methods as before
     mi = nothing
@@ -344,14 +389,19 @@ function verify_call(@nospecialize(sig), expecteds::Core.SimpleVector, i::Int, n
         interference_fast_path_success = true
         if !fully_covers
             # If expected doesn't fully cover, then need to make sure that no new methods are possibly present
+            # by checking that either METHOD_SIG_LATEST_HAS_NOTMORESPECIFIC is set on each method,
+            # or that there is another method in the expecteds list that fully upwards-covered it.
             for j = 1:n
                 meth = get_method_from_edge(expecteds[i+j-1])
                 if !iszero(meth.dispatch_status & METHOD_SIG_LATEST_HAS_NOTMORESPECIFIC)
                     interference_fast_path_success = false
                     for j = reverse(1:n)
                         meth2 = get_method_from_edge(expecteds[i+j-1])
-                        if meth !== meth2 && typeintersect(sig, meth.sig) <: meth2.sig && !(meth2.sig <: meth.sig)
-                            interference_fast_path_success = true
+                        if method_morespecific_via_interferences(meth, meth2)
+                            if sig <: meth2.sig || (sig !== meth.sig && meth.sig <: meth2.sig) # eg. faster (but less precise) `typeintersect(sig, meth.sig) <: meth2.sig` test
+                                interference_fast_path_success = true
+                                break
+                            end
                         end
                     end
                     if !interference_fast_path_success
@@ -360,6 +410,7 @@ function verify_call(@nospecialize(sig), expecteds::Core.SimpleVector, i::Int, n
                 end
             end
         end
+        # If it didn't fail yet, then check that all interference methods are either expected, or not applicable.
         if interference_fast_path_success
             local interference_minworld::UInt = 1
             for j = 1:n
@@ -387,10 +438,10 @@ function verify_call(@nospecialize(sig), expecteds::Core.SimpleVector, i::Int, n
                     if !found_in_expecteds
                         ti = typeintersect(sig, interference_method.sig)
                         if !(ti === Union{})
-                            # try looking for a different expected method that fully hides the interference_method anyways
+                            # try looking for a different expected method that fully covers this interference_method anyways over their intersection
                             for j = 1:n
                                 meth2 = get_method_from_edge(expecteds[i+j-1])
-                                if meth2 !== interference_method && ti <: meth2.sig && morespecific(meth2, interference_method)
+                                if method_morespecific_via_interferences(meth2, interference_method) && ti <: meth2.sig
                                     found_in_expecteds = true
                                     break
                                 end