similar_type checks inside array wrappers (#830)

Author: mateuszbaran

src/abstractarray.jl

@@ -57,11 +57,11 @@ if they wish to overload the default behavior.
 """
 function similar_type end
 
-similar_type(::SA) where {SA<:StaticArray} = similar_type(SA,eltype(SA))
-similar_type(::Type{SA}) where {SA<:StaticArray} = similar_type(SA,eltype(SA))
+similar_type(::SA) where {SA<:StaticArrayLike} = similar_type(SA,eltype(SA))
+similar_type(::Type{SA}) where {SA<:StaticArrayLike} = similar_type(SA,eltype(SA))
 
-similar_type(::SA,::Type{T}) where {SA<:StaticArray,T} = similar_type(SA,T,Size(SA))
-similar_type(::Type{SA},::Type{T}) where {SA<:StaticArray,T} = similar_type(SA,T,Size(SA))
+similar_type(::SA,::Type{T}) where {SA<:StaticArrayLike,T} = similar_type(SA,T,Size(SA))
+similar_type(::Type{SA},::Type{T}) where {SA<:StaticArrayLike,T} = similar_type(SA,T,Size(SA))
 
 similar_type(::A,s::Size{S}) where {A<:AbstractArray,S} = similar_type(A,eltype(A),s)
 similar_type(::Type{A},s::Size{S}) where {A<:AbstractArray,S} = similar_type(A,eltype(A),s)
@@ -79,6 +79,22 @@ similar_type(::A,::Type{T}, shape::Tuple{SOneTo, Vararg{SOneTo}}) where {A<:Abst
 similar_type(::Type{A},::Type{T}, shape::Tuple{SOneTo, Vararg{SOneTo}}) where {A<:AbstractArray,T} = similar_type(A, T, Size(last.(shape)))
 
 
+# unwrapping arrays (see issue #828)
+const SimilarTypeArrayWrapper{T,AW} = Union{
+    Transpose{T,AW},
+    Adjoint{T,AW},
+    Symmetric{T,AW},
+    Hermitian{T,AW},
+    UpperTriangular{T,AW},
+    LowerTriangular{T,AW},
+    UnitUpperTriangular{T,AW},
+    UnitLowerTriangular{T,AW},
+    Diagonal{T,AW}}
+
+function similar_type(::Type{A}, ::Type{T}, shape::Size) where {T,AW<:AbstractArray,A<:SimilarTypeArrayWrapper{<:Any,AW}}
+    return similar_type(AW, T, shape)
+end
+
 # Default types
 # Generally, use SArray
 similar_type(::Type{A},::Type{T},s::Size{S}) where {A<:AbstractArray,T,S} = default_similar_type(T,s,length_val(s))

test/abstractarray.jl

@@ -47,6 +47,12 @@ using StaticArrays, Test, LinearAlgebra
         @test @inferred(similar_type(MArray{Tuple{4,4,4},Int,3,64}, Float64)) == MArray{Tuple{4,4,4}, Float64, 3, 64}
         @test @inferred(similar_type(MVector{2,Int}, Size(3,3,3))) == MArray{Tuple{3,3,3}, Int, 3, 27}
         @test @inferred(similar_type(MVector{2,Int}, Float64, Size(3,3,3))) == MArray{Tuple{3,3,3}, Float64, 3, 27}
+
+        # wrapped mutable cases (issue #828)
+        for Wrapper in [Symmetric, Hermitian, Adjoint, Transpose, UpperTriangular, LowerTriangular, UnitUpperTriangular, UnitLowerTriangular]
+            @test @inferred(similar_type(Wrapper{Int,MArray{Tuple{4,4},Int,2,16}}, Float64)) === MArray{Tuple{4,4}, Float64, 2, 16}
+        end
+        @test @inferred(similar_type(Diagonal{Int,MArray{Tuple{4},Int,1,4}}, Float64)) === MArray{Tuple{4,4}, Float64, 2, 16}
     end
 
     @testset "similar" begin

test/matrix_multiply.jl

@@ -112,15 +112,15 @@ mul_wrappers = [
 
         cv = MMatrix{4,1}(cv_array)
         rv = MVector{4}(rv_array)
-        @test (cv*adjoint(rv))::SMatrix ≈ a_array
+        @test (cv*adjoint(rv))::MMatrix ≈ a_array
 
         cv = SMatrix{4,1}(cv_array)
         rv = SVector{4}(rv_array)
         @test (cv*transpose(rv))::SMatrix ≈ a_array
 
         cv = MMatrix{4,1}(cv_array)
         rv = MVector{4}(rv_array)
-        @test (cv*transpose(rv))::SMatrix ≈ a_array
+        @test (cv*transpose(rv))::MMatrix ≈ a_array
 
         cv_bad = @SMatrix rand(4,2)
         rv = @SVector rand(4)