permit AbstractUnitRange for BitArray indexing (#41810)

JuliaLang · Aug 20, 2021 · 1976045 · 1976045
1 parent 0224c42
commit 1976045
Show file tree

Hide file tree

Showing 2 changed files with 11 additions and 11 deletions.
diff --git a/base/bitarray.jl b/base/bitarray.jl
@@ -703,7 +703,7 @@ end
 indexoffset(i) = first(i)-1
 indexoffset(::Colon) = 0
 
-@propagate_inbounds function setindex!(B::BitArray, X::AbstractArray, J0::Union{Colon,UnitRange{Int}})
+@propagate_inbounds function setindex!(B::BitArray, X::AbstractArray, J0::Union{Colon,AbstractUnitRange{Int}})
  _setindex!(IndexStyle(B), B, X, to_indices(B, (J0,))[1])
 end
 
@@ -954,7 +954,7 @@ function deleteat!(B::BitVector, i::Integer)
  return _deleteat!(B, i)
 end
 
-function deleteat!(B::BitVector, r::UnitRange{Int})
+function deleteat!(B::BitVector, r::AbstractUnitRange{Int})
  n = length(B)
  i_f = first(r)
  i_l = last(r)
@@ -1031,8 +1031,8 @@ end
 
 const _default_bit_splice = BitVector()
 
-function splice!(B::BitVector, r::Union{UnitRange{Int}, Integer}, ins::AbstractArray = _default_bit_splice)
- _splice_int!(B, isa(r, UnitRange{Int}) ? r : Int(r), ins)
+function splice!(B::BitVector, r::Union{AbstractUnitRange{Int}, Integer}, ins::AbstractArray = _default_bit_splice)
+ _splice_int!(B, isa(r, AbstractUnitRange{Int}) ? r : Int(r), ins)
 end
 function _splice_int!(B::BitVector, r, ins)
  n = length(B)
@@ -1073,7 +1073,7 @@ function _splice_int!(B::BitVector, r, ins)
  return v
 end
 
-function splice!(B::BitVector, r::Union{UnitRange{Int}, Integer}, ins)
+function splice!(B::BitVector, r::Union{AbstractUnitRange{Int}, Integer}, ins)
  Bins = BitVector(undef, length(ins))
  i = 1
  for x in ins

diff --git a/base/multidimensional.jl b/base/multidimensional.jl
@@ -1251,14 +1251,14 @@ end
 
 # contiguous multidimensional indexing: if the first dimension is a range,
 # we can get some performance from using copy_chunks!
-@inline function _unsafe_getindex!(X::BitArray, B::BitArray, I0::Union{UnitRange{Int},Slice})
+@inline function _unsafe_getindex!(X::BitArray, B::BitArray, I0::Union{AbstractUnitRange{Int},Slice})
  copy_chunks!(X.chunks, 1, B.chunks, indexoffset(I0)+1, length(I0))
  return X
 end
 
 # Optimization where the inner dimension is contiguous improves perf dramatically
 @generated function _unsafe_getindex!(X::BitArray, B::BitArray,
- I0::Union{Slice,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Slice}...)
+ I0::Union{Slice,UnitRange{Int}}, I::Union{Int,AbstractUnitRange{Int},Slice}...)
  N = length(I)
  quote
  $(Expr(:meta, :inline))
@@ -1393,7 +1393,7 @@ end
 # contiguous multidimensional indexing: if the first dimension is a range,
 # we can get some performance from using copy_chunks!
 
-@inline function setindex!(B::BitArray, X::Union{StridedArray,BitArray}, J0::Union{Colon,UnitRange{Int}})
+@inline function setindex!(B::BitArray, X::Union{StridedArray,BitArray}, J0::Union{Colon,AbstractUnitRange{Int}})
  I0 = to_indices(B, (J0,))[1]
  @boundscheck checkbounds(B, I0)
  l0 = length(I0)
@@ -1405,13 +1405,13 @@ end
 end
 
 @inline function setindex!(B::BitArray, X::Union{StridedArray,BitArray},
- I0::Union{Colon,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Colon}...)
+ I0::Union{Colon,AbstractUnitRange{Int}}, I::Union{Int,AbstractUnitRange{Int},Colon}...)
  J = to_indices(B, (I0, I...))
  @boundscheck checkbounds(B, J...)
  _unsafe_setindex!(B, X, J...)
 end
 @generated function _unsafe_setindex!(B::BitArray, X::Union{StridedArray,BitArray},
- I0::Union{Slice,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Slice}...)
+ I0::Union{Slice,AbstractUnitRange{Int}}, I::Union{Int,AbstractUnitRange{Int},Slice}...)
  N = length(I)
  quote
  idxlens = @ncall $N index_lengths I0 d->I[d]
@@ -1446,7 +1446,7 @@ end
 end
 
 @propagate_inbounds function setindex!(B::BitArray, X::AbstractArray,
- I0::Union{Colon,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Colon}...)
+ I0::Union{Colon,AbstractUnitRange{Int}}, I::Union{Int,AbstractUnitRange{Int},Colon}...)
  _setindex!(IndexStyle(B), B, X, to_indices(B, (I0, I...))...)
 end