Merge pull request #457 from JuliaArrays/fe/undef

[RFC] use undef for uninitialized MArray constructors

Author: andyferris

src/MArray.jl

@@ -30,10 +30,16 @@ mutable struct MArray{S <: Tuple, T, N, L} <: StaticArray{S, T, N}
         new{S,T,N,L}(convert_ntuple(T, x))
     end
 
-    function MArray{S,T,N,L}() where {S,T,N,L}
+    function MArray{S,T,N,L}(::UndefInitializer) where {S,T,N,L}
         check_array_parameters(S, T, Val{N}, Val{L})
         new{S,T,N,L}()
     end
+
+    # deprecated empty constructor
+    function MArray{S,T,N,L}() where {S,T,N,L}
+        Base.depwarn("`MArray{S,T,N,L}()` is deprecated, use `MArray{S,T,N,L}(undef)` instead", :MArray)
+        return MArray{S,T,N,L}(undef)
+    end
 end
 
 @generated function (::Type{MArray{S,T,N}})(x::Tuple) where {S,T,N}
@@ -57,17 +63,25 @@ end
     end
 end
 
-@generated function (::Type{MArray{S,T,N}})() where {S,T,N}
+function (::Type{MArray{S,T,N}})() where {S,T,N}
+    Base.depwarn("`MArray{S,T,N}()` is deprecated, use `MArray{S,T,N}(undef)` instead", :MArray)
+    return MArray{S,T,N}(undef)
+end
+@generated function (::Type{MArray{S,T,N}})(::UndefInitializer) where {S,T,N}
     return quote
         $(Expr(:meta, :inline))
-        MArray{S, T, N, $(tuple_prod(S))}()
+        MArray{S, T, N, $(tuple_prod(S))}(undef)
     end
 end
 
-@generated function (::Type{MArray{S,T}})() where {S,T}
+function (::Type{MArray{S,T}})() where {S,T}
+    Base.depwarn("`MArray{S,T}()` is deprecated, use `MArray{S,T}(undef)` instead", :MArray)
+    return MArray{S,T}(undef)
+end
+@generated function (::Type{MArray{S,T}})(::UndefInitializer) where {S,T}
     return quote
         $(Expr(:meta, :inline))
-        MArray{S, T, $(tuple_length(S)), $(tuple_prod(S))}()
+        MArray{S, T, $(tuple_length(S)), $(tuple_prod(S))}(undef)
     end
 end
 

src/MMatrix.jl

@@ -46,10 +46,14 @@ end
     end
 end
 
-@generated function (::Type{MMatrix{S1,S2,T}})() where {S1,S2,T}
+function (::Type{MMatrix{S1,S2,T}})() where {S1,S2,T}
+    Base.depwarn("`MMatrix{S1,S2,T}()` is deprecated, use `MMatrix{S1,S2,T}(undef)` instead", :MMatrix)
+    return MMatrix{S1,S2,T}(undef)
+end
+@generated function (::Type{MMatrix{S1,S2,T}})(::UndefInitializer) where {S1,S2,T}
     return quote
         $(Expr(:meta, :inline))
-        MMatrix{S1, S2, T, $(S1*S2)}()
+        MMatrix{S1, S2, T, $(S1*S2)}(undef)
     end
 end
 

src/abstractarray.jl

@@ -92,7 +92,7 @@ similar(::Type{A},s::Size{S}) where {A<:AbstractArray,S} = similar(A,eltype(A),s
 similar(::A,::Type{T},s::Size{S}) where {A<:AbstractArray,T,S} = similar(A,T,s)
 
 # defaults to built-in mutable types
-similar(::Type{A},::Type{T},s::Size{S}) where {A<:AbstractArray,T,S} = mutable_similar_type(T,s,length_val(s))()
+similar(::Type{A},::Type{T},s::Size{S}) where {A<:AbstractArray,T,S} = mutable_similar_type(T,s,length_val(s))(undef)
 
 # both SizedArray and Array return SizedArray
 similar(::Type{SA},::Type{T},s::Size{S}) where {SA<:SizedArray,T,S} = sizedarray_similar_type(T,s,length_val(s))()

test/MArray.jl

@@ -3,9 +3,9 @@
         @test MArray{Tuple{1},Int,1,1}((1,)).data === (1,)
         @test MArray{Tuple{1},Float64,1,1}((1,)).data === (1.0,)
         @test MArray{Tuple{2,2},Float64,2,4}((1, 1.0, 1, 1)).data === (1.0, 1.0, 1.0, 1.0)
-        @test isa(MArray{Tuple{1},Int,1,1}(), MArray{Tuple{1},Int,1,1})
-        @test isa(MArray{Tuple{1},Int,1}(), MArray{Tuple{1},Int,1,1})
-        @test isa(MArray{Tuple{1},Int}(), MArray{Tuple{1},Int,1,1})
+        @test isa(MArray{Tuple{1},Int,1,1}(undef), MArray{Tuple{1},Int,1,1})
+        @test isa(MArray{Tuple{1},Int,1}(undef), MArray{Tuple{1},Int,1,1})
+        @test isa(MArray{Tuple{1},Int}(undef), MArray{Tuple{1},Int,1,1})
 
         # Bad input
         @test_throws Exception MArray{Tuple{2},Int,1,2}((1,))
@@ -147,7 +147,7 @@
         @test_throws BoundsError setindex!(mm, 4, 82)
 
         # setindex with non-elbits type
-        m = MArray{Tuple{2,2,2}, String}()
+        m = MArray{Tuple{2,2,2}, String}(undef)
         @test_throws ErrorException setindex!(m, "a", 1, 1, 1)
     end
 

test/MMatrix.jl

@@ -3,8 +3,8 @@
         @test MMatrix{1,1,Int,1}((1,)).data === (1,)
         @test MMatrix{1,1,Float64,1}((1,)).data === (1.0,)
         @test MMatrix{2,2,Float64,4}((1, 1.0, 1, 1)).data === (1.0, 1.0, 1.0, 1.0)
-        @test isa(MMatrix{1,1,Int,1}(), MMatrix{1,1,Int,1})
-        @test isa(MMatrix{1,1,Int}(), MMatrix{1,1,Int,1})
+        @test isa(MMatrix{1,1,Int,1}(undef), MMatrix{1,1,Int,1})
+        @test isa(MMatrix{1,1,Int}(undef), MMatrix{1,1,Int,1})
 
         # Bad input
         @test_throws Exception MMatrix{2,1,Int,2}((1,))
@@ -106,7 +106,7 @@
         @test m.data === (11, 12, 13, 14)
 
         # setindex with non-elbits type
-        m = MMatrix{2,2,String}()
+        m = MMatrix{2,2,String}(undef)
         @test_throws ErrorException setindex!(m, "a", 1, 1)
     end
 end

test/MVector.jl

@@ -3,7 +3,7 @@
         @test MVector{1,Int}((1,)).data === (1,)
         @test MVector{1,Float64}((1,)).data === (1.0,)
         @test MVector{2,Float64}((1,1.0)).data === (1.0,1.0)
-        @test isa(MVector{1,Int}(), MVector{1,Int})
+        @test isa(MVector{1,Int}(undef), MVector{1,Int})
 
         @test_throws Exception MVector{2,Int}((1,))
         @test_throws Exception MVector{1,Int}(())
@@ -85,7 +85,7 @@
         @test_throws BoundsError setindex!(v, 4., 4)
 
         # setindex with non-elbits type
-        v = MVector{2,String}()
+        v = MVector{2,String}(undef)
         @test_throws ErrorException setindex!(v, "a", 1)
     end
 end

test/arraymath.jl

@@ -43,7 +43,7 @@ import StaticArrays.arithmetic_closure
     end
 
     @testset "fill!()" begin
-        m = MMatrix{4,16,Float64}()
+        m = MMatrix{4,16,Float64}(undef)
         fill!(m, 3)
         @test all(m .== 3.)
     end

test/indexing.jl

@@ -26,15 +26,15 @@ using StaticArrays, Test
         vec = @SVector [4,5,6,7]
 
         # SVector
-        mv = MVector{4,Int}()
+        mv = MVector{4,Int}(undef)
         @test (mv[SVector(1,2,3,4)] = vec; (@inferred getindex(mv, SVector(4,3,2,1)))::SVector{4,Int} == SVector((7,6,5,4)))
 
-        mv = MVector{4,Int}()
+        mv = MVector{4,Int}(undef)
         @test (mv[SVector(1,2,3,4)] = [4, 5, 6, 7]; (@inferred getindex(mv, SVector(4,3,2,1)))::SVector{4,Int} == SVector((7,6,5,4)))
         @test (mv[SVector(1,2,3,4)] = 2; (@inferred getindex(mv, SVector(4,3,2,1)))::SVector{4,Int} == SVector((2,2,2,2)))
 
         # Colon
-        mv = MVector{4,Int}()
+        mv = MVector{4,Int}(undef)
         @test (mv[:] = vec; (@inferred getindex(mv, :))::SVector{4,Int} == SVector((4,5,6,7)))
         @test (mv[:] = [4, 5, 6, 7]; (@inferred getindex(mv, :))::SVector{4,Int} == SVector((4,5,6,7)))
         @test (mv[:] = 2; (@inferred getindex(mv, :))::SVector{4,Int} == SVector((2,2,2,2)))
@@ -49,11 +49,11 @@ using StaticArrays, Test
         vec = @SVector [4,5,6,7]
 
         # SVector
-        mm = MMatrix{2,2,Int}()
+        mm = MMatrix{2,2,Int}(undef)
         @test (mm[SVector(1,2,3,4)] = vec; (@inferred getindex(mm, SVector(4,3,2,1)))::SVector{4,Int} == SVector((7,6,5,4)))
 
         # Colon
-        mm = MMatrix{2,2,Int}()
+        mm = MMatrix{2,2,Int}(undef)
         @test (mm[:] = vec; (@inferred getindex(mm, :))::SVector{4,Int} == SVector((4,5,6,7)))
     end
 
@@ -93,16 +93,16 @@ using StaticArrays, Test
         sm = @MMatrix [1 3; 2 4]
 
         # Tuple, scalar
-        @test (mm = MMatrix{2,2,Int}(); mm[SVector(2,1),SVector(2,1)] = sm[SVector(2,1),SVector(2,1)]; (@inferred getindex(mm, SVector(2,1), SVector(2,1)))::SMatrix == @SMatrix [4 2; 3 1])
-        @test (mm = MMatrix{2,2,Int}(); mm[1,SVector(1,2)] = sm[1,SVector(1,2)]; (@inferred getindex(mm, 1, SVector(1,2)))::SVector == @SVector [1,3])
-        @test (mm = MMatrix{2,2,Int}(); mm[SVector(1,2),1] = sm[SVector(1,2),1]; (@inferred getindex(mm, SVector(1,2), 1))::SVector == @SVector [1,2])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[SVector(2,1),SVector(2,1)] = sm[SVector(2,1),SVector(2,1)]; (@inferred getindex(mm, SVector(2,1), SVector(2,1)))::SMatrix == @SMatrix [4 2; 3 1])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[1,SVector(1,2)] = sm[1,SVector(1,2)]; (@inferred getindex(mm, 1, SVector(1,2)))::SVector == @SVector [1,3])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[SVector(1,2),1] = sm[SVector(1,2),1]; (@inferred getindex(mm, SVector(1,2), 1))::SVector == @SVector [1,2])
 
         # Colon
-        @test (mm = MMatrix{2,2,Int}(); mm[:,:] = sm[:,:]; (@inferred getindex(mm, :, :))::SMatrix == @MMatrix [1 3; 2 4])
-        @test (mm = MMatrix{2,2,Int}(); mm[SVector(2,1),:] = sm[SVector(2,1),:]; (@inferred getindex(mm, SVector(2,1), :))::SMatrix == @SMatrix [2 4; 1 3])
-        @test (mm = MMatrix{2,2,Int}(); mm[:,SVector(2,1)] = sm[:,SVector(2,1)]; (@inferred getindex(mm, :, SVector(2,1)))::SMatrix == @SMatrix [3 1; 4 2])
-        @test (mm = MMatrix{2,2,Int}(); mm[1,:] = sm[1,:]; (@inferred getindex(mm, 1, :))::SVector == @SVector [1,3])
-        @test (mm = MMatrix{2,2,Int}(); mm[:,1] = sm[:,1]; (@inferred getindex(mm, :, 1))::SVector == @SVector [1,2])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[:,:] = sm[:,:]; (@inferred getindex(mm, :, :))::SMatrix == @MMatrix [1 3; 2 4])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[SVector(2,1),:] = sm[SVector(2,1),:]; (@inferred getindex(mm, SVector(2,1), :))::SMatrix == @SMatrix [2 4; 1 3])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[:,SVector(2,1)] = sm[:,SVector(2,1)]; (@inferred getindex(mm, :, SVector(2,1)))::SMatrix == @SMatrix [3 1; 4 2])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[1,:] = sm[1,:]; (@inferred getindex(mm, 1, :))::SVector == @SVector [1,3])
+        @test (mm = MMatrix{2,2,Int}(undef); mm[:,1] = sm[:,1]; (@inferred getindex(mm, :, 1))::SVector == @SVector [1,2])
     end
 
     @testset "3D scalar indexing" begin
@@ -112,7 +112,7 @@ using StaticArrays, Test
         @test sa[1,2,1] === 9
         @test sa[2,1,1] === 12
 
-        ma = MArray{Tuple{2,2,2}, Int}()
+        ma = MArray{Tuple{2,2,2}, Int}(undef)
         @test (ma[1,1,2] = 8; ma[1,1,2] === 8)
         @test (ma[1,2,1] = 9; ma[1,2,1] === 9)
         @test (ma[2,1,1] = 12; ma[2,1,1] === 12)
@@ -126,7 +126,7 @@ using StaticArrays, Test
         @test sa[1,2,1,1] === 36
         @test sa[2,1,1,1] === 48
 
-        ma = MArray{Tuple{2,2,2,2}, Int}()
+        ma = MArray{Tuple{2,2,2,2}, Int}(undef)
         @test (ma[1,1,1,2] = 30; ma[1,1,1,2] === 30)
         @test (ma[1,1,2,1] = 32; ma[1,1,2,1] === 32)
         @test (ma[1,2,1,1] = 36; ma[1,2,1,1] === 36)

test/mapreduce.jl

@@ -7,7 +7,7 @@ end
     @testset "map and map!" begin
         v1 = @SVector [2,4,6,8]
         v2 = @SVector [4,3,2,1]
-        mv = MVector{4, Int}()
+        mv = MVector{4, Int}(undef)
 
         normal_v1 = [2,4,6,8]
         normal_v2 = [4,3,2,1]
@@ -19,10 +19,10 @@ end
 
         map!(+, mv, v1, v2)
         @test mv == @MVector [6, 7, 8, 9]
-        mv2 = MVector{4, Int}()
+        mv2 = MVector{4, Int}(undef)
         map!(x->x^2, mv2, v1)
         @test mv2 == @MVector [4, 16, 36, 64]
-        mv3 = MVector{4, Int}()
+        mv3 = MVector{4, Int}(undef)
         v3 = @SVector [1, 2, 3, 4]
         map!(+, mv3, v1, v2, v3)
         @test mv3 == @MVector [7, 9, 11, 13]
@@ -110,8 +110,8 @@ end
         c = 2
         v1 = @SVector [2,4,6,8]
         v2 = @SVector [4,3,2,1]
-        mv = MVector{4, Int}()
-        mm = MMatrix{4, 2, Int}()
+        mv = MVector{4, Int}(undef)
+        mm = MMatrix{4, 2, Int}(undef)
         M = @SMatrix [1 2; 3 4; 5 6; 7 8]
 
         @test_throws DimensionMismatch broadcast(+, v1, @SMatrix [4 3 2 1; 5 6 7 8])
@@ -126,7 +126,7 @@ end
         @test @inferred(broadcast(+, v1, v2)) === map(+, v1, v2)
         @test @inferred(broadcast(+, v1, M)) === @SMatrix [3 4; 7 8; 11 12; 15 16]
 
-        @test_throws DimensionMismatch broadcast!(-, MVector{5, Int}(), v1)
+        @test_throws DimensionMismatch broadcast!(-, MVector{5, Int}(undef), v1)
 
         broadcast!(-, mv, v1)
         @test mv == @MVector [-2, -4, -6, -8]

test/matrix_multiply.jl

@@ -226,22 +226,22 @@ using StaticArrays, Test, LinearAlgebra
         m = @SMatrix [1 2; 3 4]
         n = @SMatrix [2 3; 4 5]
 
-        outvec = MVector{2,Int}()
+        outvec = MVector{2,Int}(undef)
         mul!(outvec, m, v)
         @test outvec == @MVector [10,22]
         outvec2 = Vector{Int}(undef, 2)
         mul!(outvec2, m, v2)
         @test outvec2 == [10,22]
 
         # Bad dimensions
-        outvec_bad = MVector{3,Int}()
+        outvec_bad = MVector{3,Int}(undef)
         @test_throws DimensionMismatch mul!(outvec_bad, m, v)
 
-        a = MMatrix{2,2,Int,4}()
+        a = MMatrix{2,2,Int,4}(undef)
         mul!(a, m, n)
         @test a::MMatrix{2,2,Int,4} == @MMatrix [10 13; 22 29]
 
-        a = MMatrix{2,2,Int,4}()
+        a = MMatrix{2,2,Int,4}(undef)
         mul!(a, m', n)
         @test a::MMatrix{2,2,Int,4} == @MMatrix [14 18; 20 26]
         mul!(a, m, n')
@@ -255,7 +255,7 @@ using StaticArrays, Test, LinearAlgebra
         mul!(a, transpose(m), transpose(n))
         @test a::MMatrix{2,2,Int,4} == @MMatrix [11 19; 16 28]
 
-        a2 = MArray{Tuple{2,2},Int,2,4}()
+        a2 = MArray{Tuple{2,2},Int,2,4}(undef)
         mul!(a2, m, n)
         @test a2::MArray{Tuple{2,2},Int,2,4} == @MArray [10 13; 22 29]
 
@@ -266,7 +266,7 @@ using StaticArrays, Test, LinearAlgebra
 
         m_2 = MMatrix{10,10}(m_array_2)
         n_2 = MMatrix{10,10}(n_array_2)
-        a_2 = MMatrix{10,10,Int}()
+        a_2 = MMatrix{10,10,Int}(undef)
         mul!(a_2, m_2, n_2)
         @test a_2 == a_array_2
 
@@ -277,7 +277,7 @@ using StaticArrays, Test, LinearAlgebra
 
         m_3 = MMatrix{4,4}(m_array_3)
         n_3 = MMatrix{4,4}(n_array_3)
-        a_3 = MMatrix{4,4,Float64}()
+        a_3 = MMatrix{4,4,Float64}(undef)
         mul!(a_3, m_3, n_3)
         @test a_3 ≈ a_array_3
 
@@ -287,7 +287,7 @@ using StaticArrays, Test, LinearAlgebra
 
         m_4 = MMatrix{10,10}(m_array_4)
         n_4 = MMatrix{10,10}(n_array_4)
-        a_4 = MMatrix{10,10,Float64}()
+        a_4 = MMatrix{10,10,Float64}(undef)
         mul!(a_4, m_4, n_4)
         @test a_4 ≈ a_array_4
 
@@ -297,7 +297,7 @@ using StaticArrays, Test, LinearAlgebra
 
         m_5 = MMatrix{16,16}(m_array_5)
         n_5 = MMatrix{16,16}(n_array_5)
-        a_5 = MMatrix{16,16,Int}()
+        a_5 = MMatrix{16,16,Int}(undef)
         mul!(a_5, m_5, n_5)
         @test a_5 ≈ a_array_5
 
@@ -307,7 +307,7 @@ using StaticArrays, Test, LinearAlgebra
 
         m_6 = MMatrix{8,10}(m_array_6)
         n_6 = MMatrix{10,8}(n_array_6)
-        a_6 = MMatrix{8,8,Int}()
+        a_6 = MMatrix{8,8,Int}(undef)
         mul!(a_6, m_6, n_6)
         @test a_6 == a_array_6
 
@@ -316,7 +316,7 @@ using StaticArrays, Test, LinearAlgebra
         vf2 = [2.0, 4.0]
         mf = @SMatrix [1.0 2.0; 3.0 4.0]
 
-        outvecf = MVector{2,Float64}()
+        outvecf = MVector{2,Float64}(undef)
         mul!(outvecf, mf, vf)
         @test outvecf ≈ @MVector [10.0, 22.0]
         outvec2f = Vector{Float64}(undef, 2)