Fixing constructors from 0-element arrays (#831)

* fixing constructors from 0-element arrays

* avoiding some Julia 1.0 bug

* typo

* Update src/SArray.jl

Co-authored-by: Chris Foster <chris42f@gmail.com>

* Update src/MArray.jl

Co-authored-by: Chris Foster <chris42f@gmail.com>

Author: mateuszbaran

src/MArray.jl

@@ -71,7 +71,7 @@ end
     end
 end
 
-@inline MArray(a::StaticArray) = MArray{size_tuple(Size(a))}(Tuple(a))
+@inline MArray(a::StaticArray{S,T}) where {S<:Tuple,T} = MArray{S,T}(Tuple(a))
 
 ####################
 ## MArray methods ##

src/MMatrix.jl

@@ -52,7 +52,7 @@ end
 end
 
 @inline convert(::Type{MMatrix{S1,S2}}, a::StaticArray{<:Tuple, T}) where {S1,S2,T} = MMatrix{S1,S2,T}(Tuple(a))
-@inline MMatrix(a::StaticMatrix) = MMatrix{size(typeof(a),1),size(typeof(a),2)}(Tuple(a))
+@inline MMatrix(a::StaticMatrix{N,M,T}) where {N,M,T} = MMatrix{N,M,T}(Tuple(a))
 
 # Some more advanced constructor-like functions
 @inline one(::Type{MMatrix{N}}) where {N} = one(MMatrix{N,N})

src/MVector.jl

@@ -16,6 +16,7 @@ compiler (the element type may optionally also be specified).
 """
 const MVector{S, T} = MArray{Tuple{S}, T, 1, S}
 
+@inline MVector(a::StaticVector{N,T}) where {N,T} = MVector{N,T}(a)
 @inline MVector(x::NTuple{S,Any}) where {S} = MVector{S}(x)
 @inline MVector{S}(x::NTuple{S,T}) where {S, T} = MVector{S, T}(x)
 @inline MVector{S}(x::NTuple{S,Any}) where {S} = MVector{S, promote_tuple_eltype(typeof(x))}(x)

src/SArray.jl

@@ -106,7 +106,7 @@ sacollect
 @inline (::Type{SA})(gen::Base.Generator) where {SA <: StaticArray} =
     sacollect(SA, gen)
 
-@inline SArray(a::StaticArray) = SArray{size_tuple(Size(a))}(Tuple(a))
+@inline SArray(a::StaticArray{S,T}) where {S<:Tuple,T} = SArray{S,T}(Tuple(a))
 
 ####################
 ## SArray methods ##

src/SMatrix.jl

@@ -58,7 +58,7 @@ end
     sacollect(SMatrix{M, N}, gen)
 
 @inline convert(::Type{SMatrix{S1,S2}}, a::StaticArray{<:Tuple, T}) where {S1,S2,T} = SMatrix{S1,S2,T}(Tuple(a))
-@inline SMatrix(a::StaticMatrix{S1, S2}) where {S1, S2} = SMatrix{S1, S2}(Tuple(a))
+@inline SMatrix(a::StaticMatrix{S1, S2, T}) where {S1, S2, T} = SMatrix{S1, S2, T}(Tuple(a))
 
 # Some more advanced constructor-like functions
 @inline one(::Type{SMatrix{N}}) where {N} = one(SMatrix{N,N})

src/SVector.jl

@@ -15,6 +15,7 @@ compiler (the element type may optionally also be specified).
 """
 const SVector{S, T} = SArray{Tuple{S}, T, 1, S}
 
+@inline SVector(a::StaticVector{N,T}) where {N,T} = SVector{N,T}(a)
 @inline SVector(x::NTuple{S,Any}) where {S} = SVector{S}(x)
 @inline SVector{S}(x::NTuple{S,T}) where {S, T} = SVector{S,T}(x)
 @inline SVector{S}(x::T) where {S, T <: Tuple} = SVector{S,promote_tuple_eltype(T)}(x)

src/SizedArray.jl

@@ -29,6 +29,10 @@ struct SizedArray{S<:Tuple,T,N,M,TData<:AbstractArray{T,M}} <: StaticArray{S,T,N
     end
 end
 
+# Julia v1.0 has some weird bug that prevents this from working
+@static if VERSION >= v"1.1"
+    @inline SizedArray(a::StaticArray{S,T,N}) where {S<:Tuple,T,N} = SizedArray{S,T,N}(a)
+end
 @inline function SizedArray{S,T,N}(
     a::TData,
 ) where {S,T,N,M,TData<:AbstractArray{T,M}}
@@ -123,6 +127,7 @@ Base.pointer(sa::SizedArray) = pointer(sa.data)
 
 const SizedVector{S,T} = SizedArray{Tuple{S},T,1,1}
 
+SizedVector(a::StaticVector{N,T}) where {N,T} = SizedVector{N,T}(a)
 @inline function SizedVector{S}(a::TData) where {S,T,TData<:AbstractVector{T}}
     return SizedArray{Tuple{S},T,1,1,TData}(a)
 end
@@ -142,6 +147,10 @@ end
 
 const SizedMatrix{S1,S2,T} = SizedArray{Tuple{S1,S2},T,2}
 
+# Julia v1.0 has some weird bug that prevents this from working
+@static if VERSION >= v"1.1"
+    SizedMatrix(a::StaticMatrix{N,M,T}) where {N,M,T} = SizedMatrix{N,M,T}(a)
+end
 @inline function SizedMatrix{S1,S2}(
     a::TData,
 ) where {S1,S2,T,M,TData<:AbstractArray{T,M}}

test/MArray.jl

@@ -32,6 +32,9 @@
         v = MArray{Tuple{2}}(1,2)
         @test MArray(v) !== v && MArray(v) == v
 
+        # test for #557-like issues
+        @test (@inferred MArray(SVector{0,Float64}()))::MVector{0,Float64} == MVector{0,Float64}()
+
         @test MArray{Tuple{}}(i for i in 1:1).data === (1,)
         @test MArray{Tuple{3}}(i for i in 1:3).data === (1,2,3)
         @test MArray{Tuple{3}}(float(i) for i in 1:3).data === (1.0,2.0,3.0)

test/MMatrix.jl

@@ -26,6 +26,9 @@
         @test MMatrix{2,2}((1,2,3,4)).data === (1,2,3,4)
         @test MMatrix{2}((1,2,3,4)).data === (1,2,3,4)
 
+        # test for #557-like issues
+        @test (@inferred MMatrix(SMatrix{0,0,Float64}()))::MMatrix{0,0,Float64} == MMatrix{0,0,Float64}()
+
         @test ((@MMatrix [1.0])::MMatrix{1,1}).data === (1.0,)
         @test ((@MMatrix [1 2])::MMatrix{1,2}).data === (1, 2)
         @test ((@MMatrix [1 ; 2])::MMatrix{2,1}).data === (1, 2)

test/MVector.jl

@@ -20,6 +20,9 @@
         v = MVector(1,2)
         @test MVector(v) !== v && MVector(v) == v
 
+        # test for #557-like issues
+        @test (@inferred MVector(SVector{0,Float64}()))::MVector{0,Float64} == MVector{0,Float64}()
+
         @test ((@MVector [1.0])::MVector{1}).data === (1.0,)
         @test ((@MVector [1, 2, 3])::MVector{3}).data === (1, 2, 3)
         @test ((@MVector Float64[1,2,3])::MVector{3}).data === (1.0, 2.0, 3.0)