Fix some ambiguities on nightly (#191)

The new algorithm for detecting ambiguities picked up some real ones
that, surprisingly, were not detected previously.

Author: timholy

Project.toml

@@ -16,6 +16,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MappedArrays = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 TiledIteration = "06e1c1a7-607b-532d-9fad-de7d9aa2abac"

src/ImageFiltering.jl

@@ -7,6 +7,7 @@ using ColorVectorSpace  # for filtering RGB arrays
 using Base: Indices, tail, fill_to_length, @pure, depwarn, @propagate_inbounds
 using OffsetArrays: IdentityUnitRange   # using the one in OffsetArrays makes this work with multiple Julia versions
 using Requires
+using SparseArrays   # only needed to fix an ambiguity in borderarray
 
 export Kernel, KernelFactors,
     Pad, Fill, Inner, NA, NoPad,

src/border.jl

@@ -204,6 +204,7 @@ Pad(style::Symbol, lo::Dims{N}, hi::Tuple{}) where {N} = Pad(style, lo, ntuple(d
 Pad(style::Symbol, lo::Tuple{}, hi::Dims{N}) where {N} = Pad(style, ntuple(d->0,Val(N)), hi)
 Pad(style::Symbol, lo::AbstractVector{Int}, hi::AbstractVector{Int}) = Pad(style, (lo...,), (hi...,))
 
+Pad(style::Symbol, ::Tuple{}) = Pad(style, (), ())    # ambiguity resolution
 Pad(style::Symbol, inds::Indices) = Pad(style, map(lo,inds), map(hi,inds))
 
 """
@@ -706,6 +707,7 @@ struct Inner{N} <: AbstractBorder
 end
 
 Inner(both::Int...) = Inner(both, both)
+Inner(::Tuple{}) = Inner((), ())   # ambiguity resolution
 Inner(both::Dims{N}) where {N} = Inner(both, both)
 Inner(lo::Tuple{}, hi::Tuple{}) = Inner{0}(lo, hi)
 Inner(lo::Dims{N}, hi::Tuple{}) where {N} = Inner{N}(lo, ntuple(d->0,Val(N)))
@@ -856,6 +858,7 @@ zero.
 Fill(value::T, both::Dims{N}) where {T,N} = Fill{T,N}(value, both, both)
 
 Fill(value, lo::AbstractVector, hi::AbstractVector) = Fill(value, (lo...,), (hi...,))
+Fill(value::T, ::Tuple{}) where {T} = Fill{T,0}(value, (), ())   # ambiguity resolution
 Fill(value::T, inds::Base.Indices{N}) where {T,N} = Fill{T,N}(value, map(lo,inds), map(hi,inds))
 
 """

src/borderarray.jl

@@ -67,14 +67,17 @@ struct BorderArray{T,N,A,B} <: AbstractArray{T,N}
         new{T,N,A,B}(inner, border)
     end
 end
+BorderVector{T,A,B} = BorderArray{T,1,A,B}
 
-# these are adapted from OffsetArrays
 function Base.similar(A::BorderArray, ::Type{T}, dims::Dims) where T
     B = similar(A.inner, T, dims)
 end
-const OffsetAxis = Union{Integer, UnitRange, Base.OneTo, IdentityUnitRange}
-function Base.similar(A::BorderArray, ::Type{T}, inds::Tuple{OffsetAxis,Vararg{OffsetAxis}}) where T
-    similar(A.inner, T, inds)
+const BaseAxisTypes = Union{Integer, Base.OneTo}
+const OffsetAxisTypes = Union{StaticArrays.HeterogeneousShape, OffsetArrays.IdOffsetRange}
+for Ax in (BaseAxisTypes, StaticArrays.HeterogeneousShape, OffsetAxisTypes)
+    @eval function Base.similar(A::BorderArray, ::Type{T}, inds::Tuple{$Ax,Vararg{$Ax}}) where T
+        similar(A.inner, T, inds)
+    end
 end
 
 @inline function Base.axes(o::BorderArray)
@@ -156,6 +159,10 @@ function Base.checkbounds(::Type{Bool}, arr::BorderArray, index::CartesianIndex)
     end |> all
 end
 
+function Base.copy!(dst::SparseVector, src::BorderVector)   # ambiguity resolution
+    axes(dst) == axes(src) || throw(DimensionMismatch("axes(dst) == axes(src) must hold."))
+    _copy!(dst, src, src.border)
+end
 function Base.copy!(dst::AbstractArray, src::BorderArray)
     axes(dst) == axes(src) || throw(DimensionMismatch("axes(dst) == axes(src) must hold."))
     _copy!(dst, src, src.border)

test/runtests.jl

@@ -2,10 +2,15 @@ using ImageFiltering, Test
 import StaticArrays
 using Random
 
-aif = detect_ambiguities(ImageFiltering, Kernel, KernelFactors, Base)
-# Because StaticArrays has ambiguities with Base, we have to "subtract" these
-asa = detect_ambiguities(StaticArrays, Base)
-@test isempty(setdiff(aif, asa))
+# Ambiguity test
+if Base.VERSION >= v"1.6.0-DEV.1005"   # julia #37616
+    @test isempty(detect_ambiguities(ImageFiltering, Kernel, KernelFactors))
+else
+    # Because StaticArrays may have ambiguities with Base, we have to "subtract" these
+    aif = detect_ambiguities(ImageFiltering, Kernel, KernelFactors, Base)
+    asa = detect_ambiguities(StaticArrays, Base)
+    @test isempty(setdiff(aif, asa))
+end
 
 function typestring(::Type{T}) where T   # from https://github.com/JuliaImages/ImageCore.jl/pull/133
     buf = IOBuffer()