Use checkbounds in more places

Author: giordano

base/abstractarray.jl

@@ -387,6 +387,7 @@ function eachindex(A::AbstractArray, B::AbstractArray...)
     @inline
     eachindex(IndexStyle(A,B...), A, B...)
 end
+eachindex(::IndexLinear, A::Union{Array, Memory}) = unchecked_oneto(length(A))
 eachindex(::IndexLinear, A::AbstractArray) = (@inline; oneto(length(A)))
 eachindex(::IndexLinear, A::AbstractVector) = (@inline; axes1(A))
 function eachindex(::IndexLinear, A::AbstractArray, B::AbstractArray...)
@@ -749,7 +750,7 @@ false
 checkindex(::Type{Bool}, inds, i) = throw(ArgumentError(LazyString("unable to check bounds for indices of type ", typeof(i))))
 checkindex(::Type{Bool}, inds::AbstractUnitRange, i::Real) = (first(inds) <= i) & (i <= last(inds))
 checkindex(::Type{Bool}, inds::IdentityUnitRange, i::Real) = checkindex(Bool, inds.indices, i)
-checkindex(::Type{Bool}, inds::OneTo{T}, i::T) where {T<:BitInteger} = unsigned(i - one(i)) < unsigned(last(inds))
+checkindex(::Type{Bool}, inds::OneTo{T}, i::T) where {T<:BitInteger} = _checkbounds_array_onebased(Bool, last(inds), i)
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Colon) = true
 checkindex(::Type{Bool}, inds::AbstractUnitRange, ::Slice) = true
 checkindex(::Type{Bool}, inds::AbstractUnitRange, i::AbstractRange) =
@@ -1237,15 +1238,15 @@ oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
 iterate_starting_state(A) = iterate_starting_state(A, IndexStyle(A))
 iterate_starting_state(A, ::IndexLinear) = firstindex(A)
 iterate_starting_state(A, ::IndexStyle) = (eachindex(A),)
-iterate(A::AbstractArray, state = iterate_starting_state(A)) = _iterate(A, state)
+@inline iterate(A::AbstractArray, state = iterate_starting_state(A)) = _iterate(A, state)
 function _iterate(A::AbstractArray, state::Tuple)
     y = iterate(state...)
     y === nothing && return nothing
     A[y[1]], (state[1], tail(y)...)
 end
 function _iterate(A::AbstractArray, state::Integer)
     checkbounds(Bool, A, state) || return nothing
-    @inbounds(A[state]), state + one(state)
+    A[state], state + one(state)
 end
 
 isempty(a::AbstractArray) = (length(a) == 0)

base/array.jl

@@ -902,10 +902,6 @@ function grow_to!(dest, itr, st)
     return dest
 end
 
-## Iteration ##
-
-iterate(A::Array, i=1) = (@inline; _iterate_array(A, i))
-
 ## Indexing: getindex ##
 
 """
@@ -993,7 +989,7 @@ function setindex!(A::Array{T}, x, i::Int) where {T}
 end
 function _setindex!(A::Array{T}, x::T, i::Int) where {T}
     @_noub_if_noinbounds_meta
-    @boundscheck _checkbounds_array(Bool, A, i) || throw_boundserror(A, (i,))
+    @boundscheck checkbounds(Bool, A, i) || throw_boundserror(A, (i,))
     memoryrefset!(memoryrefnew(A.ref, i, false), x, :not_atomic, false)
     return A
 end

base/essentials.jl

@@ -377,13 +377,20 @@ macro _nospecializeinfer_meta()
     return Expr(:meta, :nospecializeinfer)
 end
 
-function _checkbounds_array(::Type{Bool}, A::Union{Array, GenericMemory}, i::Int)
+# NOTE: this function expects one-based indexing.  We can't use `require_one_based_indexing`
+# here because it's defined later in the bootstrap process.  Use only where you are really
+# sure about indexing.
+function _checkbounds_array_onebased(::Type{Bool}, len::Integer, i::Int)
     @inline
-    ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, length(A)))
+    ult_int(bitcast(UInt, sub_int(i, 1)), bitcast(UInt, len))
 end
-function _checkbounds_array(A::Union{Array, GenericMemory}, i::Int)
+function _checkbounds_array_onebased(::Type{Bool}, A::AbstractArray, i::Int)
     @inline
-    _checkbounds_array(Bool, A, i) || throw_boundserror(A, (i,))
+    _checkbounds_array_onebased(Bool, length(A), i)
+end
+function _checkbounds_array_onebased(A::Union{Array, GenericMemory}, i::Int)
+    @inline
+    _checkbounds_array_onebased(Bool, A, i) || throw_boundserror(A, (i,))
 end
 
 default_access_order(a::GenericMemory{:not_atomic}) = :not_atomic
@@ -393,7 +400,7 @@ default_access_order(a::GenericMemoryRef{:atomic}) = :monotonic
 
 function getindex(A::GenericMemory, i::Int)
     @_noub_if_noinbounds_meta
-    (@_boundscheck) && _checkbounds_array(A, i)
+    (@_boundscheck) && _checkbounds_array_onebased(A, i)
     memoryrefget(memoryrefnew(memoryrefnew(A), i, false), default_access_order(A), false)
 end
 
@@ -962,13 +969,13 @@ end
 # linear indexing
 function getindex(A::Array, i::Int)
     @_noub_if_noinbounds_meta
-    @boundscheck _checkbounds_array(A, i)
+    @boundscheck _checkbounds_array_onebased(A, i)
     memoryrefget(memoryrefnew(getfield(A, :ref), i, false), :not_atomic, false)
 end
 # simple Array{Any} operations needed for bootstrap
 function setindex!(A::Array{Any}, @nospecialize(x), i::Int)
     @_noub_if_noinbounds_meta
-    @boundscheck _checkbounds_array(A, i)
+    @boundscheck _checkbounds_array_onebased(A, i)
     memoryrefset!(memoryrefnew(getfield(A, :ref), i, false), x, :not_atomic, false)
     return A
 end

base/genericmemory.jl

@@ -106,7 +106,7 @@ sizeof(a::GenericMemory) = Core.sizeof(a)
 # multi arg case will be overwritten later. This is needed for bootstrapping
 function isassigned(a::GenericMemory, i::Int)
     @inline
-    @boundscheck _checkbounds_array(Bool, a, i) || return false
+    @boundscheck checkbounds(Bool, a, i) || return false
     return @inbounds memoryref_isassigned(memoryref(a, i), default_access_order(a), false)
 end
 
@@ -223,15 +223,6 @@ Memory{T}(x::AbstractArray{S,1}) where {T,S} = copyto_axcheck!(Memory{T}(undef,
 
 ## copying iterators to containers
 
-## Iteration ##
-
-function _iterate_array(A::Union{Memory, Array}, i::Int)
-    @inline
-    _checkbounds_array(Bool, A, i) ? (A[i], i + 1) : nothing
-end
-
-iterate(A::Memory, i=1) = (@inline; _iterate_array(A, i))
-
 ## Indexing: getindex ##
 
 # Faster contiguous indexing using copyto! for AbstractUnitRange and Colon

base/strings/basic.jl

@@ -797,7 +797,7 @@ size(s::CodeUnits) = (length(s),)
 elsize(s::Type{<:CodeUnits{T}}) where {T} = sizeof(T)
 @propagate_inbounds getindex(s::CodeUnits, i::Int) = codeunit(s.s, i)
 IndexStyle(::Type{<:CodeUnits}) = IndexLinear()
-@inline iterate(s::CodeUnits, i=1) = _checkbounds_array(Bool, s, i) ? (@inbounds s[i], i + 1) : nothing
+@inline iterate(s::CodeUnits, i=1) = checkbounds(Bool, s, i) ? (@inbounds s[i], i + 1) : nothing
 
 
 write(io::IO, s::CodeUnits) = write(io, s.s)