Convert to 1-based indexing rather than generalize to arbitrary indexing

Author: Lilith Hafner

base/sort.jl

@@ -5,7 +5,7 @@ module Sort
 import ..@__MODULE__, ..parentmodule
 const Base = parentmodule(@__MODULE__)
 using .Base.Order
-using .Base: copymutable, LinearIndices, length, (:), iterate, elsize, checkbounds,
+using .Base: copymutable, LinearIndices, length, (:), iterate, elsize,
     eachindex, axes, first, last, similar, zip, OrdinalRange, firstindex, lastindex,
     AbstractVector, @inbounds, AbstractRange, @eval, @inline, Vector, @noinline,
     AbstractMatrix, AbstractUnitRange, isless, identity, eltype, >, <, <=, >=, |, +, -, *, !,
@@ -605,7 +605,7 @@ function sort!(v::AbstractVector{T}, lo::Integer, hi::Integer, a::MergeSortAlg,
         hi-lo <= SMALL_THRESHOLD && return sort!(v, lo, hi, SMALL_ALGORITHM, o)
 
         m = midpoint(lo, hi)
-        t = workspace(v, t0, Base.OneTo(m-lo+1))
+        t = workspace(v, t0, m-lo+1)
 
         sort!(v, lo,  m,  a, o, t)
         sort!(v, m+1, hi, a, o, t)
@@ -682,8 +682,9 @@ end
 function radix_sort!(v::AbstractVector{U}, lo::Integer, hi::Integer, bits::Unsigned,
                      t::AbstractVector{U}, chunk_size=radix_chunk_size_heuristic(lo, hi, bits)) where U <: Unsigned
     # bits is unsigned for performance reasons.
+    Base.require_one_based_indexing(v, t)
     mask = UInt(1) << chunk_size - 1
-    counts = Vector{Int}(undef, mask+2)
+    counts = Vector{UInt}(undef, mask+2)
 
     @inbounds for shift in 0:chunk_size:bits-1
 
@@ -746,9 +747,9 @@ function sort!(v::AbstractVector{B}, lo::Integer, hi::Integer, a::AdaptiveSort,
     v
 end
 
-workspace(v::AbstractVector, ::Nothing, indices::AbstractUnitRange=eachindex(v)) = similar(v, indices)
-function workspace(v::AbstractVector{T}, t::AbstractVector{T}, indices::AbstractUnitRange=eachindex(v)) where T
-    checkbounds(Bool, t, indices) ? t : similar(t, indices)
+workspace(v::AbstractVector, ::Nothing, len::Integer) = similar(v, len)
+function workspace(v::AbstractVector{T}, t::AbstractVector{T}, len::Integer) where T
+    length(t) < len ? resize!(t, len) : t
 end
 maybe_unsigned(x::Integer) = x # this is necessary to avoid calling unsigned on BigInt
 maybe_unsigned(x::BitSigned) = unsigned(x)
@@ -856,7 +857,7 @@ function sort!(v::AbstractVector{T}, lo::Integer, hi::Integer, a::AdaptiveSort,
         u[i] -= u_min
     end
 
-    u2 = radix_sort!(u, lo, hi, bits, reinterpret(U, workspace(v, t)))
+    u2 = radix_sort!(view(u, lo:hi), 1, hi-lo+1, bits, reinterpret(U, workspace(v, t, hi-lo+1)))
     uint_unmap!(v, u2, lo, hi, o, u_min)
 end
 
@@ -1393,8 +1394,8 @@ end
 
 function uint_unmap!(v::AbstractVector, u::AbstractVector{U}, lo::Integer, hi::Integer,
                      order::Ordering, offset::U=zero(U)) where U <: Unsigned
-    @inbounds for i in lo:hi
-        v[i] = uint_unmap(eltype(v), u[i]+offset, order)
+    @inbounds for (i, j) in zip(lo:hi, eachindex(u))
+        v[i] = uint_unmap(eltype(v), u[j]+offset, order)
     end
     v
 end

test/sorting.jl

@@ -666,10 +666,11 @@ end
 
 @testset "workspace()" begin
     for v in [[1, 2, 3], [0.0]]
-        for t0 in vcat([nothing], [similar(v,i) for i in 1:5]), axes in [0:5, 1:3, Base.OneTo(7), 3:2, -1:0]
-            t = Base.Sort.workspace(v, t0, axes)
+        for t0 in vcat([nothing], [similar(v,i) for i in 1:5]), len in 0:5
+            t = Base.Sort.workspace(v, t0, len)
             @test eltype(t) == eltype(v)
-            @test checkbounds(Bool, t, axes)
+            @test length(t) >= len
+            @test firstindex(t) == 1
         end
     end
 end