Revert "zeros/ones/fill may accept arbitrary axes that are supp…

…orted by `similar` (#53965)"

This reverts commit 8d577ab.

base/array.jl

@@ -529,7 +529,6 @@ function fill end
 fill(v, dims::DimOrInd...) = fill(v, dims)
 fill(v, dims::NTuple{N, Union{Integer, OneTo}}) where {N} = fill(v, map(to_dim, dims))
 fill(v, dims::NTuple{N, Integer}) where {N} = (a=Array{typeof(v),N}(undef, dims); fill!(a, v); a)
-fill(v, dims::NTuple{N, DimOrInd}) where {N} = (a=similar(Array{typeof(v),N}, dims); fill!(a, v); a)
 fill(v, dims::Tuple{}) = (a=Array{typeof(v),0}(undef, dims); fill!(a, v); a)
 
 """
@@ -590,11 +589,6 @@ for (fname, felt) in ((:zeros, :zero), (:ones, :one))
             fill!(a, $felt(T))
             return a
         end
-        function $fname(::Type{T}, dims::NTuple{N, DimOrInd}) where {T,N}
-            a = similar(Array{T,N}, dims)
-            fill!(a, $felt(T))
-            return a
-        end
     end
 end
 

base/bitarray.jl

@@ -404,7 +404,6 @@ falses(dims::DimOrInd...) = falses(dims)
 falses(dims::NTuple{N, Union{Integer, OneTo}}) where {N} = falses(map(to_dim, dims))
 falses(dims::NTuple{N, Integer}) where {N} = fill!(BitArray(undef, dims), false)
 falses(dims::Tuple{}) = fill!(BitArray(undef, dims), false)
-falses(dims::NTuple{N, DimOrInd}) where {N} = fill!(similar(BitArray, dims), false)
 
 """
     trues(dims)
@@ -423,7 +422,6 @@ trues(dims::DimOrInd...) = trues(dims)
 trues(dims::NTuple{N, Union{Integer, OneTo}}) where {N} = trues(map(to_dim, dims))
 trues(dims::NTuple{N, Integer}) where {N} = fill!(BitArray(undef, dims), true)
 trues(dims::Tuple{}) = fill!(BitArray(undef, dims), true)
-trues(dims::NTuple{N, DimOrInd}) where {N} = fill!(similar(BitArray, dims), true)
 
 function one(x::BitMatrix)
     m, n = size(x)

test/abstractarray.jl

@@ -11,9 +11,6 @@ using .Main.StructArrays
 isdefined(Main, :FillArrays) || @eval Main include("testhelpers/FillArrays.jl")
 using .Main.FillArrays
 
-isdefined(Main, :SizedArrays) || @eval Main include("testhelpers/SizedArrays.jl")
-using .Main.SizedArrays
-
 A = rand(5,4,3)
 @testset "Bounds checking" begin
     @test checkbounds(Bool, A, 1, 1, 1) == true
@@ -2100,22 +2097,3 @@ end
         @test r2[i] == z[j]
     end
 end
-
-@testset "zero for arbitrary axes" begin
-    r = SizedArrays.SOneTo(2)
-    s = Base.OneTo(2)
-    _to_oneto(x::Integer) = Base.OneTo(2)
-    _to_oneto(x::Union{Base.OneTo, SizedArrays.SOneTo}) = x
-    for (f, v) in ((zeros, 0), (ones, 1), ((x...)->fill(3,x...),3))
-        for ax in ((r,r), (s, r), (2, r))
-            A = f(ax...)
-            @test axes(A) == map(_to_oneto, ax)
-            if all(x -> x isa SizedArrays.SOneTo, ax)
-                @test A isa SizedArrays.SizedArray && parent(A) isa Array
-            else
-                @test A isa Array
-            end
-            @test all(==(v), A)
-        end
-    end
-end

test/bitarray.jl

@@ -3,9 +3,6 @@
 using Base: findprevnot, findnextnot
 using Random, LinearAlgebra, Test
 
-isdefined(Main, :SizedArrays) || @eval Main include("testhelpers/SizedArrays.jl")
-using .Main.SizedArrays
-
 tc(r1::NTuple{N,Any}, r2::NTuple{N,Any}) where {N} = all(x->tc(x...), [zip(r1,r2)...])
 tc(r1::BitArray{N}, r2::Union{BitArray{N},Array{Bool,N}}) where {N} = true
 tc(r1::SubArray{Bool,N1,BitArray{N2}}, r2::SubArray{Bool,N1,<:Union{BitArray{N2},Array{Bool,N2}}}) where {N1,N2} = true
@@ -85,25 +82,6 @@ allsizes = [((), BitArray{0}), ((v1,), BitVector),
     @test !isassigned(b, length(b) + 1)
 end
 
-@testset "trues and falses with custom axes" begin
-    for ax in ((SizedArrays.SOneTo(2),), (SizedArrays.SOneTo(2), Base.OneTo(2)))
-        t = trues(ax)
-        if all(x -> x isa SizedArrays.SOneTo, ax)
-            @test t isa SizedArrays.SizedArray && parent(t) isa BitArray
-        else
-            @test t isa BitArray
-        end
-        @test all(t)
-
-        f = falses(ax)
-        if all(x -> x isa SizedArrays.SOneTo, ax)
-            @test t isa SizedArrays.SizedArray && parent(t) isa BitArray
-        else
-            @test t isa BitArray
-        end
-        @test !any(f)
-    end
-end
 
 @testset "Conversions for size $sz" for (sz, T) in allsizes
     b1 = rand!(falses(sz...))

test/testhelpers/SizedArrays.jl

@@ -43,25 +43,10 @@ Base.size(a::SizedArray) = size(typeof(a))
 Base.size(::Type{<:SizedArray{SZ}}) where {SZ} = SZ
 Base.axes(a::SizedArray) = map(SOneTo, size(a))
 Base.getindex(A::SizedArray, i...) = getindex(A.data, i...)
-Base.setindex!(A::SizedArray, v, i...) = setindex!(A.data, v, i...)
 Base.zero(::Type{T}) where T <: SizedArray = SizedArray{size(T)}(zeros(eltype(T), size(T)))
-Base.parent(S::SizedArray) = S.data
 +(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = SizedArray{SZ}(S1.data + S2.data)
 ==(S1::SizedArray{SZ}, S2::SizedArray{SZ}) where {SZ} = S1.data == S2.data
 
-homogenize_shape(t::Tuple) = (_homogenize_shape(first(t)), homogenize_shape(Base.tail(t))...)
-homogenize_shape(::Tuple{}) = ()
-_homogenize_shape(x::Integer) = x
-_homogenize_shape(x::AbstractUnitRange) = length(x)
-const Dims = Union{Integer, Base.OneTo, SOneTo}
-function Base.similar(::Type{A}, shape::Tuple{Dims, Vararg{Dims}}) where {A<:AbstractArray}
-    similar(A, homogenize_shape(shape))
-end
-function Base.similar(::Type{A}, shape::Tuple{SOneTo, Vararg{SOneTo}}) where {A<:AbstractArray}
-    R = similar(A, length.(shape))
-    SizedArray{length.(shape)}(R)
-end
-
 const SizedMatrixLike = Union{SizedMatrix, Transpose{<:Any, <:SizedMatrix}, Adjoint{<:Any, <:SizedMatrix}}
 
 _data(S::SizedArray) = S.data