Use Vector in more misc places

base/dates/periods.jl

@@ -211,7 +211,7 @@ julia> Dates.CompoundPeriod(Dates.Minute(50000))
 50000 minutes
 ```
 """
-CompoundPeriod(p::Vector{<:Period}) = CompoundPeriod(Array{Period}(p))
+CompoundPeriod(p::Vector{<:Period}) = CompoundPeriod(Vector{Period}(p))
 
 CompoundPeriod(t::Time) = CompoundPeriod(Period[Hour(t), Minute(t), Second(t), Millisecond(t),
                                                 Microsecond(t), Nanosecond(t)])

base/distributed/macros.jl

@@ -102,7 +102,7 @@ function splitrange(N::Int, np::Int)
     each = div(N,np)
     extras = rem(N,np)
     nchunks = each > 0 ? np : extras
-    chunks = Array{UnitRange{Int}}(nchunks)
+    chunks = Vector{UnitRange{Int}}(nchunks)
     lo = 1
     for i in 1:nchunks
         hi = lo + each - 1
@@ -203,4 +203,3 @@ macro parallel(args...)
     end
     thecall
 end
-

base/env.jl

@@ -97,7 +97,7 @@ if is_windows()
         pos = block[1]
         blk = block[2]
         len = ccall(:wcslen, UInt, (Ptr{UInt16},), pos)
-        buf = Array{UInt16}(len)
+        buf = Vector{UInt16}(len)
         unsafe_copy!(pointer(buf), pos, len)
         env = transcode(String, buf)
         m = match(r"^(=?[^=]+)=(.*)$"s, env)

base/grisu/bignums.jl

@@ -47,14 +47,14 @@ const kBigitSize = 28
 const kBigitMask = Chunk((1 << kBigitSize) - 1)
 # Every instance allocates kBigitLength chunks on the stack. Bignums cannot
 # grow. There are no checks if the stack-allocated space is sufficient.
-const kBigitCapacity = div(kMaxSignificantBits,kBigitSize)
+const kBigitCapacity = div(kMaxSignificantBits, kBigitSize)
 
 mutable struct Bignum
-    bigits::Array{UInt32,1}
+    bigits::Vector{UInt32}
     used_digits::Int32
     exponent::Int32
     function Bignum()
-        bigits = Array{UInt32}(kBigitCapacity)
+        bigits = Vector{UInt32}(kBigitCapacity)
         @inbounds for i = 1:kBigitCapacity
             bigits[i] = 0
         end

base/libc.jl

@@ -284,7 +284,7 @@ if is_windows()
                     C_NULL, e, 0, lpMsgBuf, 0, C_NULL)
         p = lpMsgBuf[]
         len == 0 && return ""
-        buf = Array{UInt16}(len)
+        buf = Vector{UInt16}(len)
         unsafe_copy!(pointer(buf), p, len)
         ccall(:LocalFree, stdcall, Ptr{Void}, (Ptr{Void},), p)
         return transcode(String, buf)

base/pkg/resolve/interface.jl

@@ -52,7 +52,7 @@ mutable struct Interface
         pdict = Dict{String,Int}(pkgs[i] => i for i = 1:np)
 
         # generate spp and pvers
-        spp = Array{Int}(np)
+        spp = Vector{Int}(np)
 
         pvers = [VersionNumber[] for i = 1:np]
 
@@ -82,11 +82,11 @@ mutable struct Interface
         end
 
         ## generate wveights:
-        vweight = Array{Vector{VersionWeight}}(np)
+        vweight = Vector{Vector{VersionWeight}}(np)
         for p0 = 1:np
             pvers0 = pvers[p0]
             spp0 = spp[p0]
-            vweight0 = vweight[p0] = Array{VersionWeight}(spp0)
+            vweight0 = vweight[p0] = Vector{VersionWeight}(spp0)
             for v0 = 1:spp0-1
                 vweight0[v0] = VersionWeight(pvers0[v0])
             end

base/pkg/resolve/maxsum.jl

@@ -240,7 +240,7 @@ function getsolution(msgs::Messages)
 
     fld = msgs.fld
     np = length(fld)
-    sol = Array{Int}(np)
+    sol = Vector{Int}(np)
     for p0 = 1:np
         fld0 = fld[p0]
         s0 = indmax(fld0)

base/random.jl

@@ -1506,7 +1506,7 @@ To randomly permute a arbitrary vector, see [`shuffle`](@ref)
 or [`shuffle!`](@ref).
 """
 function randperm(r::AbstractRNG, n::Integer)
-    a = Array{typeof(n)}(n)
+    a = Vector{typeof(n)}(n)
     @assert n <= Int64(2)^52
     if n == 0
        return a
@@ -1532,7 +1532,7 @@ Construct a random cyclic permutation of length `n`. The optional `rng`
 argument specifies a random number generator, see [Random Numbers](@ref).
 """
 function randcycle(r::AbstractRNG, n::Integer)
-    a = Array{typeof(n)}(n)
+    a = Vector{typeof(n)}(n)
     n == 0 && return a
     @assert n <= Int64(2)^52
     a[1] = 1

base/sparse/sparsevector.jl

@@ -951,7 +951,7 @@ end
 function hvcat(rows::Tuple{Vararg{Int}}, X::_SparseConcatGroup...)
     nbr = length(rows)  # number of block rows
 
-    tmp_rows = Array{SparseMatrixCSC}(nbr)
+    tmp_rows = Vector{SparseMatrixCSC}(nbr)
     k = 0
     @inbounds for i = 1 : nbr
         tmp_rows[i] = hcat(X[(1 : rows[i]) + k]...)