use subtyping instead of structural inspection for ambiguity exclusions

Should be slightly more robust, since subtyping already implements these
queries with much more finesse than is going to be true of a
re-implementation of the query here.

Author: vtjnash

src/ambiguities.jl

@@ -154,37 +154,6 @@ function reprpkgid(pkg::PkgId)
     return "Base.PkgId(Base.UUID($(repr(uuid.value))), $(repr(name)))"
 end
 
-struct _NoValue end
-
-function getobj(m::Method)
-    signature = Base.unwrap_unionall(m.sig)
-    ty = if is_kwcall(signature)
-        signature.parameters[3]
-    else
-        signature.parameters[1]
-    end
-    ty = Base.unwrap_unionall(ty)
-    if ty <: Function
-        try
-            return ty.instance  # this should work for functions
-        catch
-        end
-    end
-    try
-        if ty.name.wrapper === Type
-            return ty.parameters[1]
-        else
-            return ty.name.wrapper
-        end
-    catch err
-        @error(
-            "Failed to obtain a function from `Method`.",
-            exception = (err, catch_backtrace())
-        )
-    end
-    return _NoValue()
-end
-
 function test_ambiguities_impl(
     packages::Vector{PkgId},
     options::NamedTuple,
@@ -196,9 +165,26 @@ function test_ambiguities_impl(
     ambiguities = detect_ambiguities(modules...; options...)
 
     if !isempty(exspecs)
-        exclude_objs = getobj.(exspecs)
+        exclude_ft = Any[getobj(spec) for spec in exspecs]
+        exclude_sig = Any[]
+        for ft in exclude_ft
+            if ft isa Type
+                push!(exclude_sig, Tuple{ft, Vararg})
+                push!(exclude_sig, Tuple{Core.kwftype(ft), Any, ft, Vararg})
+                ft = Type{<:ft} # alternatively, Type{ft}
+            else
+                ft = typeof(ft)
+            end
+            push!(exclude_sig, Tuple{ft, Vararg})
+            push!(exclude_sig, Tuple{Core.kwftype(ft), Any, ft, Vararg})
+        end
         ambiguities = filter(ambiguities) do (m1, m2)
-            getobj(m1) ∉ exclude_objs && getobj(m2) ∉ exclude_objs
+            for excl in exclude_sig
+                if m1.sig <: excl || m2.sig <: excl
+                    return false
+                end
+            end
+            return true
         end
     end
 

src/piracies.jl

@@ -168,7 +168,7 @@ function is_pirate(meth::Method; treat_as_own = Union{Function,Type}[])
     signature = Base.unwrap_unionall(meth.sig)
 
     function_type_index = 1
-    if is_kwcall(signature)
+    if is_kwcall(meth.sig)
         # kwcall is a special case, since it is not a real function
         # but a wrapper around a function, the third parameter is the original
         # function, its positional arguments follow.

src/utils.jl

@@ -55,8 +55,9 @@ function checked_repr(obj)
     return code
 end
 
-function is_kwcall(signature::DataType)
+function is_kwcall(signature::Type)
     @static if VERSION < v"1.9"
+        signature = Base.unwrap_unionall(signature)::DataType
         try
             length(signature.parameters) >= 3 || return false
             signature <: Tuple{Function,Any,Any,Vararg} || return false
@@ -69,6 +70,6 @@ function is_kwcall(signature::DataType)
             return false
         end
     else
-        return signature.parameters[1] === typeof(Core.kwcall)
+        return signature <: Tuple{typeof(Core.kwcall), Any, Any, Vararg}
     end
 end

test/test_ambiguities.jl

@@ -30,6 +30,11 @@ include("preamble.jl")
         if broken
             @test_broken num_ambiguities_ == num_ambiguities
         else
+            if num_ambiguities_ != num_ambiguities
+                @show exclude
+                println(strout)
+                println(strerr)
+            end
             @test num_ambiguities_ == num_ambiguities
         end
     end
@@ -50,7 +55,7 @@ include("preamble.jl")
     check_testcase([PkgWithAmbiguities.ConcreteType], total - num_ambs_ConcreteType)
 
     # exclude abstract supertype without callables and constructors
-    check_testcase([PkgWithAmbiguities.AbstractType], total)
+    check_testcase([PkgWithAmbiguities.AbstractType], total - num_ambs_SingletonType - num_ambs_ConcreteType)
 
     @static if VERSION >= v"1.3-"
         # for ambiguities between abstract and concrete type callables, only one needs to be excluded