Make fallback similar methods less specific in axes (#1176)

* Make fallback similar methods less specific in axes

* Add 4 term test

* Fix test

Author: jishnub

src/abstractarray.jl

@@ -139,12 +139,8 @@ similar(::Type{A},::Type{T},s::Size{S}) where {A<:Array,T,S} = sizedarray_simila
 # by simply converting them to either a tuple of Ints or a Size, re-dispatching to either one
 # of the above methods (in the case of Size) or a base fallback (in the case of Ints).
 const HeterogeneousBaseShape = Union{Integer, Base.OneTo}
-const HeterogeneousShape = Union{Integer, Base.OneTo, SOneTo}
-const HeterogeneousShapeTuple = Union{
-    Tuple{SOneTo, Vararg{HeterogeneousShape}},
-    Tuple{HeterogeneousBaseShape, SOneTo, Vararg{HeterogeneousShape}},
-    Tuple{HeterogeneousBaseShape, HeterogeneousBaseShape, SOneTo, Vararg{HeterogeneousShape}}
-}
+const HeterogeneousShape = Union{HeterogeneousBaseShape, SOneTo}
+const HeterogeneousShapeTuple = Tuple{Vararg{HeterogeneousShape}}
 
 similar(A::AbstractArray, ::Type{T}, shape::HeterogeneousShapeTuple) where {T} = similar(A, T, homogenize_shape(shape))
 similar(::Type{A}, shape::HeterogeneousShapeTuple) where {A<:AbstractArray} = similar(A, homogenize_shape(shape))

test/abstractarray.jl

@@ -80,6 +80,38 @@ using StaticArrays, Test, LinearAlgebra
         @test isa(@inferred(similar(Diagonal{Int}, Size(2,2))), MArray{Tuple{2, 2}, Int, 2, 4})
         @test isa(@inferred(similar(SizedArray, Int, Size(2,2))), SizedArray{Tuple{2, 2}, Int, 2, 2})
         @test isa(@inferred(similar(Matrix{Int}, Int, Size(2,2))), SizedArray{Tuple{2, 2}, Int, 2, 2})
+
+        @testset "disambiguate similar" begin
+            struct CustomArray{T} <: AbstractVector{T}
+                sz :: Int
+            end
+
+            Base.size(C::CustomArray) = (C.sz,)
+            Base.getindex(C::CustomArray{T}, i::Int) where {T} = T(i)
+            Base.similar(C::CustomArray, ::Type{T}, ax::Tuple{Vararg{Int}}) where {T} =
+                Array{T}(undef, ax)
+            function Base.similar(C::CustomArray, ::Type{T}, ax::Tuple{Vararg{Union{Int, SOneTo, Base.OneTo{Int}}}}) where {T}
+                sz = last.(ax)
+                Array{T}(undef, sz)
+            end
+
+            c = CustomArray{Int}(4)
+            for (ax, sz) in (((SOneTo(2), Base.OneTo(3)), (2,3)),
+                                ((2, SOneTo(2), Base.OneTo(3)), (2,2,3)))
+                for A in (similar(c, Float64, ax), similar(c, Float64, ax...))
+                    @test A isa Array{Float64, length(sz)}
+                    @test size(A) == sz
+                end
+            end
+
+            @test similar(c, ()) isa Array{Int,0}
+            @test similar(c, Float64, ()) isa Array{Float64,0}
+
+            @test size(similar(zeros(), (1,1,1,SOneTo(1)))) == (1,1,1,1)
+
+            # ensure that the more specific Base method works
+            @test similar(1:2, ()) isa AbstractArray{Int,0}
+        end
     end
 
     @testset "similar and Base.Slice/IdentityUnitRange (issues #548, #556)" begin