deprecate Array(shape...)-like constructors to Array(uninitialized, shape...)

NEWS.md

@@ -421,6 +421,14 @@ Deprecated or removed
     Instead, reshape the array or add trailing indices so the dimensionality and number of indices
     match ([#14770], [#23628]).
 
+  * Uninitialized `Array` constructors of the form
+    `Array[{T,N}](shape...)` have been deprecated in favor of equivalents
+    accepting `uninitialized` (an alias for `Uninitialized()`) as their first argument,
+    as in `Array[{T,N}](uninitialized, shape...)`. For example,
+    `Vector(3)` is now `Vector(uninitialized, 3)`, `Matrix{Int}((2, 4))` is now,
+    `Matrix{Int}(uninitialized, (2, 4))`, and `Array{Float32,3}(11, 13, 17)` is now
+    `Array{Float32,3}(uninitialized, 11, 13, 17)` ([#24781]).
+
   * `fill!(A::Diagonal, x)` and `fill!(A::AbstractTriangular, x)` have been deprecated
     in favor of `Base.LinAlg.fillslots!(A, x)` ([#24413]).
 

base/array.jl

@@ -251,6 +251,7 @@ similar(a::Array{T,2}, S::Type) where {T}           = Matrix{S}(uninitialized, s
 similar(a::Array{T}, m::Int) where {T}              = Vector{T}(uninitialized, m)
 similar(a::Array, T::Type, dims::Dims{N}) where {N} = Array{T,N}(uninitialized, dims)
 similar(a::Array{T}, dims::Dims{N}) where {T,N}     = Array{T,N}(uninitialized, dims)
+similar(::Type{T}, shape::Tuple) where {T<:Array}   = T(uninitialized, to_shape(shape))
 
 # T[x...] constructs Array{T,1}
 """
@@ -448,7 +449,7 @@ convert(::Type{Array{T}}, x::Array{T,n}) where {T,n} = x
 convert(::Type{Array{T,n}}, x::Array{T,n}) where {T,n} = x
 
 convert(::Type{Array{T}}, x::AbstractArray{S,n}) where {T,n,S} = convert(Array{T,n}, x)
-convert(::Type{Array{T,n}}, x::AbstractArray{S,n}) where {T,n,S} = copy!(Array{T,n}(size(x)), x)
+convert(::Type{Array{T,n}}, x::AbstractArray{S,n}) where {T,n,S} = copy!(Array{T,n}(uninitialized, size(x)), x)
 
 promote_rule(a::Type{Array{T,n}}, b::Type{Array{S,n}}) where {T,n,S} = el_same(promote_type(T,S), a, b)
 

base/boot.jl

@@ -373,20 +373,6 @@ Array{T}(::Uninitialized, d::NTuple{N,Int}) where {T,N} = Array{T,N}(uninitializ
 # empty vector constructor
 Array{T,1}() where {T} = Array{T,1}(uninitialized, 0)
 
-## preexisting Array constructors, i.e. without uninitialized, to deprecate
-# type and dimensionality specified, accepting dims as series of Ints
-Array{T,1}(m::Int) where {T} = Array{T,1}(uninitialized, m)
-Array{T,2}(m::Int, n::Int) where {T} = Array{T,2}(uninitialized, m, n)
-Array{T,3}(m::Int, n::Int, o::Int) where {T} = Array{T,3}(uninitialized, m, n, o)
-Array{T,N}(d::Vararg{Int,N}) where {T,N} = Array{T,N}(uninitialized, d)
-# type and dimensionality specified, accepting dims as tuples of Ints
-Array{T,N}(d::NTuple{N,Int}) where {T,N} = Array{T,N}(uninitialized, d)
-# type but not dimensionality specified
-Array{T}(m::Int) where {T} = Array{T}(uninitialized, m)
-Array{T}(m::Int, n::Int) where {T} = Array{T}(uninitialized, m, n)
-Array{T}(m::Int, n::Int, o::Int) where {T} = Array{T}(uninitialized, m, n, o)
-Array{T}(d::NTuple{N,Int}) where {T,N} = Array{T}(uninitialized, d)
-
 
 # primitive Symbol constructors
 function Symbol(s::String)

base/deprecated.jl

@@ -2043,6 +2043,27 @@ end
 # issue #24006
 @deprecate linearindices(s::AbstractString) eachindex(s)
 
+# deprecate Array(shape...)-like constructors to Array(uninitialized, shape...) equivalents
+# --> former primitive constructors
+@deprecate Array{T,1}(m::Int) where {T}                      Array{T,1}(uninitialized, m)
+@deprecate Array{T,2}(m::Int, n::Int) where {T}              Array{T,2}(uninitialized, m, n)
+@deprecate Array{T,3}(m::Int, n::Int, o::Int) where {T}      Array{T,3}(uninitialized, m, n, o)
+@deprecate Array{T,N}(d::Vararg{Int,N}) where {T,N}          Array{T,N}(uninitialized, d)
+@deprecate Array{T,N}(d::NTuple{N,Int}) where {T,N}          Array{T,N}(uninitialized, d)
+@deprecate Array{T}(m::Int) where {T}                        Array{T}(uninitialized, m)
+@deprecate Array{T}(m::Int, n::Int) where {T}                Array{T}(uninitialized, m, n)
+@deprecate Array{T}(m::Int, n::Int, o::Int) where {T}        Array{T}(uninitialized, m, n, o)
+@deprecate Array{T}(d::NTuple{N,Int}) where {T,N}            Array{T}(uninitialized, d)
+# --> former convenience constructors
+@deprecate Vector{T}(m::Integer) where {T}                          Vector{T}(uninitialized, m)
+@deprecate Matrix{T}(m::Integer, n::Integer) where {T}              Matrix{T}(uninitialized, m, n)
+@deprecate Array{T}(m::Integer) where {T}                           Array{T}(uninitialized, m)
+@deprecate Array{T}(m::Integer, n::Integer) where {T}               Array{T}(uninitialized, m, n)
+@deprecate Array{T}(m::Integer, n::Integer, o::Integer) where {T}   Array{T}(uninitialized, m, n, o)
+@deprecate Array{T}(d::Integer...) where {T}                        Array{T}(uninitialized, d)
+@deprecate Vector(m::Integer)                                       Vector(uninitialized, m)
+@deprecate Matrix(m::Integer, n::Integer)                           Matrix(uninitialized, m, n)
+
 # deprecate IntSet to BitSet
 @deprecate_binding IntSet BitSet
 

base/linalg/lapack.jl

@@ -4116,8 +4116,9 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty) in
         # .. Array Arguments ..
         # INTEGER            IPIV( * )
         # DOUBLE PRECISION   A( LDA, * ), E( * )
-        function syconvf_rook!(uplo::Char, way::Char, A::StridedMatrix{$elty},
-                               ipiv::StridedVector{BlasInt}, e::StridedVector{$elty} = Vector{$elty}(length(ipiv)))
+        function syconvf_rook!(uplo::Char, way::Char,
+                                A::StridedMatrix{$elty}, ipiv::StridedVector{BlasInt},
+                                e::StridedVector{$elty} = Vector{$elty}(uninitialized, length(ipiv)))
             # extract
             n = checksquare(A)
             lda = max(1, stride(A, 2))
@@ -4716,8 +4717,9 @@ for (sysv, sytrf, sytri, sytrs, syconvf, elty, relty) in
         # .. Array Arguments ..
         # INTEGER            IPIV( * )
         # COMPLEX*16         A( LDA, * ), E( * )
-        function syconvf_rook!(uplo::Char, way::Char, A::StridedMatrix{$elty},
-                               ipiv::StridedVector{BlasInt}, e::StridedVector{$elty} = Vector{$elty}(length(ipiv)))
+        function syconvf_rook!(uplo::Char, way::Char,
+                                A::StridedMatrix{$elty}, ipiv::StridedVector{BlasInt},
+                                e::StridedVector{$elty} = Vector{$elty}(uninitialized, length(ipiv)))
             # extract
             n   = checksquare(A)
             lda = stride(A, 2)

base/multidimensional.jl

@@ -1142,7 +1142,7 @@ julia> src = reshape(collect(1:16), (4,4))
  3  7  11  15
  4  8  12  16
 
-julia> dest = OffsetArray{Int}((0:3,2:5))
+julia> dest = OffsetArray{Int}(uninitialized, (0:3,2:5))
 
 julia> circcopy!(dest, src)
 OffsetArrays.OffsetArray{Int64,2,Array{Int64,2}} with indices 0:3×2:5:

base/pkg/resolve/interface.jl

@@ -82,7 +82,7 @@ mutable struct Interface
         end
 
         ## generate wveights:
-        vweight = Vector{Vector{VersionWeight}}(np)
+        vweight = Vector{Vector{VersionWeight}}(uninitialized, np)
         for p0 = 1:np
             pvers0 = pvers[p0]
             spp0 = spp[p0]

base/statistics.jl

@@ -608,7 +608,7 @@ function median!(v::AbstractVector)
     end
 end
 median!(v::AbstractArray) = median!(vec(v))
-median(v::AbstractArray{T}) where {T} = median!(copy!(Array{T,1}(_length(v)), v))
+median(v::AbstractArray{T}) where {T} = median!(copy!(Array{T,1}(uninitialized, _length(v)), v))
 
 """
     median(v[, region])

base/strings/util.jl

@@ -492,7 +492,7 @@ julia> hex2bytes(a)
 function hex2bytes end
 
 hex2bytes(s::AbstractString) = hex2bytes(Vector{UInt8}(String(s)))
-hex2bytes(s::AbstractVector{UInt8}) = hex2bytes!(Vector{UInt8}(length(s) >> 1), s)
+hex2bytes(s::AbstractVector{UInt8}) = hex2bytes!(Vector{UInt8}(uninitialized, length(s) >> 1), s)
 
 """
     hex2bytes!(d::AbstractVector{UInt8}, s::AbstractVector{UInt8})

base/sysimg.jl

@@ -146,19 +146,6 @@ Matrix(::Uninitialized, m::Integer, n::Integer) = Matrix{Any}(uninitialized, Int
 # empty vector constructor
 Vector() = Vector{Any}(uninitialized, 0)
 
-## preexisting dims-type-converting Array constructors for convenience, i.e. without uninitialized, to deprecate
-# type and dimensionality specified, accepting dims as series of Integers
-Vector{T}(m::Integer) where {T} = Vector{T}(uninitialized, Int(m))
-Matrix{T}(m::Integer, n::Integer) where {T} = Matrix{T}(uninitialized, Int(m), Int(n))
-# type but not dimensionality specified, accepting dims as series of Integers
-Array{T}(m::Integer) where {T} = Vector{T}(uninitialized, Int(m))
-Array{T}(m::Integer, n::Integer) where {T} = Array{T,2}(uninitialized, Int(m), Int(n))
-Array{T}(m::Integer, n::Integer, o::Integer) where {T} = Array{T,3}(uninitialized, Int(m), Int(n), Int(o))
-Array{T}(d::Integer...) where {T} = Array{T}(uninitialized, convert(Tuple{Vararg{Int}}, d))
-# dimensionality but not type specified, accepting dims as series of Integers
-Vector(m::Integer) = Vector{Any}(uninitialized, Int(m))
-Matrix(m::Integer, n::Integer) = Matrix{Any}(uninitialized, Int(m), Int(n))
-
 
 include("associative.jl")
 

examples/lru.jl

@@ -39,7 +39,7 @@ mutable struct UnboundedLRU{K,V} <: LRU{K,V}
     ht::Dict
     q::Vector{CacheItem}
 
-    UnboundedLRU{K,V}() where {K,V} = new(Dict(), similar(Array{CacheItem}(1), 0))
+    UnboundedLRU{K,V}() where {K,V} = new(Dict(), similar(Vector{CacheItem}(uninitialized, 1), 0))
 end
 UnboundedLRU() = UnboundedLRU{Any, Any}()
 
@@ -48,7 +48,7 @@ mutable struct BoundedLRU{K,V} <: LRU{K,V}
     q::Vector{CacheItem}
     maxsize::Int
 
-    BoundedLRU{K,V}(m) where {K,V} = new(Dict(), similar(Array{CacheItem}(1), 0), m)
+    BoundedLRU{K,V}(m) where {K,V} = new(Dict(), similar(Vector{CacheItem}(uninitialized, 1), 0), m)
     BoundedLRU{K,V}() where {K,V} = BoundedLRU(__MAXCACHE)
 end
 BoundedLRU(m) = BoundedLRU{Any, Any}(m)

examples/ndgrid.jl

@@ -18,7 +18,7 @@ end
 function ndgrid(vs::AbstractVector{T}...) where T
     n = length(vs)
     sz = map(length, vs)
-    out = ntuple(i->Array{T}(sz), n)
+    out = ntuple(i->Array{T}(uninitialized, sz), n)
     s = 1
     for i=1:n
         a = out[i]::Array

src/julia-syntax.scm

@@ -410,7 +410,7 @@
          (block
           ,(scopenest (cdr names) (cdr vals) expr)))))
 
-(define empty-vector-any '(call (core AnyVector) 0))
+(define empty-vector-any '(call (core AnyVector) uninitialized 0))
 
 (define (keywords-method-def-expr name sparams argl body rett)
   (let* ((kargl (cdar argl))  ;; keyword expressions (= k v)
@@ -2569,7 +2569,7 @@
       ,.(map (lambda (v r) `(= ,v (call (top length) ,r))) lengths rv)
       (scope-block
        (block
-        (= ,result (call (curly Array ,atype ,(length lengths)) ,@lengths))
+        (= ,result (call (curly Array ,atype ,(length lengths)) uninitialized ,@lengths))
         (= ,ri 1)
         ,(construct-loops (reverse ranges) (reverse rv) states (reverse lengths))
         ,result)))))

stdlib/Mmap/test/runtests.jl

@@ -11,12 +11,12 @@ gc(); gc()
 gc(); gc()
 @test Mmap.mmap(file, Array{UInt8,3}, (1,1,11)) == reshape(t,(1,1,11))
 gc(); gc()
-@test Mmap.mmap(file, Array{UInt8,3}, (11,0,1)) == Array{UInt8}((0,0,0))
+@test Mmap.mmap(file, Array{UInt8,3}, (11,0,1)) == Array{UInt8}(uninitialized, (0,0,0))
 @test Mmap.mmap(file, Vector{UInt8}, (11,)) == t
 gc(); gc()
 @test Mmap.mmap(file, Array{UInt8,2}, (1,11)) == t'
 gc(); gc()
-@test Mmap.mmap(file, Array{UInt8,2}, (0,12)) == Array{UInt8}((0,0))
+@test Mmap.mmap(file, Array{UInt8,2}, (0,12)) == Array{UInt8}(uninitialized, (0,0))
 m = Mmap.mmap(file, Array{UInt8,3}, (1,2,1))
 @test m == reshape(b"He",(1,2,1))
 finalize(m); m=nothing; gc()

test/TestHelpers.jl

@@ -183,6 +183,8 @@ end
 
 Base.similar(f::Union{Function,Type}, shape::Tuple{UnitRange,Vararg{UnitRange}}) =
     OffsetArray(f(map(length, shape)), map(indsoffset, shape))
+Base.similar(::Type{T}, shape::Tuple{UnitRange,Vararg{UnitRange}}) where {T<:Array} =
+    OffsetArray(T(uninitialized, map(length, shape)), map(indsoffset, shape))
 Base.similar(::Type{T}, shape::Tuple{UnitRange,Vararg{UnitRange}}) where {T<:BitArray} =
     OffsetArray(T(uninitialized, map(length, shape)), map(indsoffset, shape))
 

test/arrayops.jl

@@ -1123,7 +1123,7 @@ end
     fill!(A, UInt8(3))
     @test A == [0x03, 0x03, 0x03]
     # Issue #9964
-    A = Array{Vector{Float64}}(2)
+    A = Array{Vector{Float64}}(uninitialized, 2)
     fill!(A, [1, 2])
     @test A[1] == [1, 2]
     @test A[1] === A[2]

test/core.jl

@@ -7,8 +7,8 @@ const Bottom = Union{}
 include("testenv.jl")
 
 f47(x::Vector{Vector{T}}) where {T} = 0
-@test_throws MethodError f47(Vector{Vector}(uninitialized, 0))
-@test f47(Array{Vector{Int}}(0)) == 0
+@test_throws MethodError f47(Vector{Vector}())
+@test f47(Vector{Vector{Int}}()) == 0
 
 # checking unionall and typevar components
 @test_throws TypeError ([] where T)
@@ -591,7 +591,7 @@ let
     @test !isassigned(a,1) && !isassigned(a,2)
     a[1] = 1
     @test isassigned(a,1) && !isassigned(a,2)
-    a = Array{Float64}(uninitialized,1)
+    a = Vector{Float64}(uninitialized,1)
     @test isassigned(a,1)
     @test isassigned(a)
     @test !isassigned(a,2)
@@ -1256,7 +1256,7 @@ let
 
     # issue #1886
     X = [1:4;]
-    r = Array{UnitRange{Int}}(uninitialized, 1)
+    r = Vector{UnitRange{Int}}(uninitialized, 1)
     r[1] = 2:3
     X[r...] *= 2
     @test X == [1,4,6,4]
@@ -1321,7 +1321,7 @@ struct Foo2509; foo::Int; end
 # issue #2517
 struct Foo2517; end
 @test repr(Foo2517()) == "$(curmod_prefix)Foo2517()"
-@test repr(Array{Foo2517}(uninitialized, 1)) == "$(curmod_prefix)Foo2517[$(curmod_prefix)Foo2517()]"
+@test repr(Vector{Foo2517}(uninitialized, 1)) == "$(curmod_prefix)Foo2517[$(curmod_prefix)Foo2517()]"
 @test Foo2517() === Foo2517()
 
 # issue #1474
@@ -1398,7 +1398,7 @@ end
 
 # issue #3471
 function f3471(y)
-    convert(Array{typeof(y[1]),1}, y)
+    convert(Vector{typeof(y[1])}, y)
 end
 @test isa(f3471(Any[1.0,2.0]), Vector{Float64})
 
@@ -1450,13 +1450,13 @@ end
 # issue #3167
 let
     function foo(x)
-        ret=Array{typeof(x[1])}(uninitialized, length(x))
+        ret=Vector{typeof(x[1])}(uninitialized, length(x))
         for j = 1:length(x)
             ret[j] = x[j]
         end
         return ret
     end
-    x = Array{Union{Dict{Int64,AbstractString},Array{Int64,3},Number,AbstractString,Void}}(3)
+    x = Vector{Union{Dict{Int64,AbstractString},Array{Int64,3},Number,AbstractString,Void}}(uninitialized, 3)
     x[1] = 1.0
     x[2] = 2.0
     x[3] = 3.0
@@ -1704,8 +1704,8 @@ end
 @test invalid_tupleref()==true
 
 # issue #5150
-f5150(T) = Array{Rational{T}}(uninitialized, 1)
-@test typeof(f5150(Int)) === Array{Rational{Int},1}
+f5150(T) = Vector{Rational{T}}(uninitialized, 1)
+@test typeof(f5150(Int)) === Vector{Rational{Int}}
 
 
 # issue #5165

test/linalg/diagonal.jl

@@ -409,8 +409,8 @@ end
         B = Diagonal(randn(T, 5, 5))
         DD = Diagonal([randn(T, 2, 2), rand(T, 2, 2)])
         BB = Diagonal([randn(T, 2, 2), rand(T, 2, 2)])
-        fullDD = copy!(Matrix{Matrix{T}}(2, 2), DD)
-        fullBB = copy!(Matrix{Matrix{T}}(2, 2), BB)
+        fullDD = copy!(Matrix{Matrix{T}}(uninitialized, 2, 2), DD)
+        fullBB = copy!(Matrix{Matrix{T}}(uninitialized, 2, 2), BB)
         for f in (*, Ac_mul_B, A_mul_Bc, Ac_mul_Bc, At_mul_B, A_mul_Bt, At_mul_Bt)
             @test f(D, B)::typeof(D) ≈ f(Matrix(D), Matrix(B)) atol=2 * eps()
             @test f(DD, BB)::typeof(DD) == f(fullDD, fullBB)

test/random.jl

@@ -366,8 +366,8 @@ for rng in ([], [MersenneTwister(0)], [RandomDevice()])
         a2 = rand(rng..., C, 2, 3)                   ::Array{T, 2}
         a3 = rand(rng..., C, (2, 3))                 ::Array{T, 2}
         a4 = rand(rng..., C, b2, u3)                 ::Array{T, 2}
-        a5 = rand!(rng..., Array{T}(5), C)           ::Vector{T}
-        a6 = rand!(rng..., Array{T}(2, 3), C)        ::Array{T, 2}
+        a5 = rand!(rng..., Array{T}(uninitialized, 5), C)           ::Vector{T}
+        a6 = rand!(rng..., Array{T}(uninitialized, 2, 3), C)        ::Array{T, 2}
         a7 = rand!(rng..., GenericArray{T}(uninitialized, 5), C)    ::GenericArray{T, 1}
         a8 = rand!(rng..., GenericArray{T}(uninitialized, 2, 3), C) ::GenericArray{T, 2}
         @test size(a1) == (5,)

test/show.jl

@@ -5,9 +5,9 @@ include("testenv.jl")
 
 replstr(x) = sprint((io,x) -> show(IOContext(io, :limit => true, :displaysize => (24, 80)), MIME("text/plain"), x), x)
 
-@test replstr(Array{Any}(2)) == "2-element Array{Any,1}:\n #undef\n #undef"
-@test replstr(Array{Any}(2,2)) == "2×2 Array{Any,2}:\n #undef  #undef\n #undef  #undef"
-@test replstr(Array{Any}(2,2,2)) == "2×2×2 Array{Any,3}:\n[:, :, 1] =\n #undef  #undef\n #undef  #undef\n\n[:, :, 2] =\n #undef  #undef\n #undef  #undef"
+@test replstr(Array{Any}(uninitialized, 2)) == "2-element Array{Any,1}:\n #undef\n #undef"
+@test replstr(Array{Any}(uninitialized, 2,2)) == "2×2 Array{Any,2}:\n #undef  #undef\n #undef  #undef"
+@test replstr(Array{Any}(uninitialized, 2,2,2)) == "2×2×2 Array{Any,3}:\n[:, :, 1] =\n #undef  #undef\n #undef  #undef\n\n[:, :, 2] =\n #undef  #undef\n #undef  #undef"
 @test replstr([1f10]) == "1-element Array{Float32,1}:\n 1.0f10"
 
 struct T5589