use more precise structural inspection of types for ambiguity exclusions

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