Support size, length, atsign-inbounds

timholy · timholy · commit f245c6a516fd · 2018-07-12T07:23:41.000-05:00
This is now permitted due to JuliaLang/julia#24899
diff --git a/REQUIRE b/REQUIRE
@@ -1 +1 @@
-julia 0.7.0-beta.73
+julia 0.7.0-beta.270
diff --git a/src/OffsetArrays.jl b/src/OffsetArrays.jl
@@ -2,9 +2,9 @@ __precompile__()
 
 module OffsetArrays
 
-using Base: Indices, tail
+using Base: Indices, tail, @propagate_inbounds
 
-export OffsetArray, OffsetVector, @unsafe
+export OffsetArray, OffsetVector
 
 struct OffsetArray{T,N,AA<:AbstractArray} <: AbstractArray{T,N}
     parent::AA
@@ -58,12 +58,12 @@ parenttype(A::OffsetArray) = parenttype(typeof(A))
 
 Base.parent(A::OffsetArray) = A.parent
 
-errmsg(A) = error("size not supported for arrays with axes $(axes(A)); see http://docs.julialang.org/en/latest/devdocs/offset-arrays/")
-Base.size(A::OffsetArray) = errmsg(A)
-Base.size(A::OffsetArray, d) = errmsg(A)
 Base.eachindex(::IndexCartesian, A::OffsetArray) = CartesianIndices(axes(A))
 Base.eachindex(::IndexLinear, A::OffsetVector)   = axes(A, 1)
 
+Base.size(A::OffsetArray) = size(parent(A))
+Base.size(A::OffsetArray, d) = size(parent(A), d)
+
 # Implementations of axes and indices1. Since bounds-checking is
 # performance-critical and relies on axes, these are usually worth
 # optimizing thoroughly.
@@ -74,8 +74,7 @@ Base.eachindex(::IndexLinear, A::OffsetVector)   = axes(A, 1)
 @inline _axes(inds, offsets) =
     (Base.Slice(inds[1] .+ offsets[1]), _axes(tail(inds), tail(offsets))...)
 _axes(::Tuple{}, ::Tuple{}) = ()
-Base.indices1(A::OffsetArray{T,0}) where {T} = 1:1  # we only need to specialize this one
-
+Base.axes1(A::OffsetArray{T,0}) where {T} = 1:1  # we only need to specialize this one
 
 const OffsetAxis = Union{Integer, UnitRange, Base.Slice{<:UnitRange}, Base.OneTo}
 function Base.similar(A::OffsetArray, ::Type{T}, dims::Dims) where T
@@ -111,34 +110,33 @@ Base.trues(inds::NTuple{N, Union{Integer, AbstractUnitRange}}) where {N} =
 Base.falses(inds::NTuple{N, Union{Integer, AbstractUnitRange}}) where {N} =
     fill!(OffsetArray(BitArray{N}(undef, map(indexlength, inds)), map(indexoffset, inds)), false)
 
-# Don't allow bounds-checks to be removed during Julia 0.5
-@inline function Base.getindex(A::OffsetArray{T,N}, I::Vararg{Int,N}) where {T,N}
-    checkbounds(A, I...)
+@inline @propagate_inbounds function Base.getindex(A::OffsetArray{T,N}, I::Vararg{Int,N}) where {T,N}
+    @boundscheck checkbounds(A, I...)
     @inbounds ret = parent(A)[offset(A.offsets, I)...]
     ret
 end
-@inline function Base.getindex(A::OffsetVector, i::Int)
-    checkbounds(A, i)
+@inline @propagate_inbounds function Base.getindex(A::OffsetVector, i::Int)
+    @boundscheck checkbounds(A, i)
     @inbounds ret = parent(A)[offset(A.offsets, (i,))[1]]
     ret
 end
-@inline function Base.getindex(A::OffsetArray, i::Int)
-    checkbounds(A, i)
+@inline @propagate_inbounds function Base.getindex(A::OffsetArray, i::Int)
+    @boundscheck checkbounds(A, i)
     @inbounds ret = parent(A)[i]
     ret
 end
-@inline function Base.setindex!(A::OffsetArray{T,N}, val, I::Vararg{Int,N}) where {T,N}
-    checkbounds(A, I...)
+@inline @propagate_inbounds function Base.setindex!(A::OffsetArray{T,N}, val, I::Vararg{Int,N}) where {T,N}
+    @boundscheck checkbounds(A, I...)
     @inbounds parent(A)[offset(A.offsets, I)...] = val
     val
 end
-@inline function Base.setindex!(A::OffsetVector, val, i::Int)
-    checkbounds(A, i)
+@inline @propagate_inbounds function Base.setindex!(A::OffsetVector, val, i::Int)
+    @boundscheck checkbounds(A, i)
     @inbounds parent(A)[offset(A.offsets, (i,))[1]] = val
     val
 end
-@inline function Base.setindex!(A::OffsetArray, val, i::Int)
-    checkbounds(A, i)
+@inline @propagate_inbounds function Base.setindex!(A::OffsetArray, val, i::Int)
+    @boundscheck checkbounds(A, i)
     @inbounds parent(A)[i] = val
     val
 end
@@ -163,82 +161,10 @@ offset(offsets::Tuple{Vararg{Int}}, inds::Tuple{}) = error("inds cannot be short
 
 indexoffset(r::AbstractRange) = first(r) - 1
 indexoffset(i::Integer) = 0
-indexlength(r::AbstractRange) = Base._length(r)
+indexlength(r::AbstractRange) = length(r)
 indexlength(i::Integer) = i
 
-macro unsafe(ex)
-    esc(unsafe(ex))
-end
-unsafe(ex) = ex
-function unsafe(ex::Expr)
-    if ex.head ∈ (:+=, :-=, :*=, :/=)
-        ex = Expr(:(=), ex.args[1], Expr(:call, Symbol(string(ex.head)[1]), ex.args...))
-    end
-    if ex.head == :(=)
-        a = ex.args[1]
-        if isa(a, Expr) && (a::Expr).head == :ref
-            # setindex!
-            newargs = map(unsafe, ex.args[2:end])
-            @assert length(newargs) == 1
-            return Expr(:call, :(OffsetArrays.unsafe_setindex!), (a::Expr).args[1], newargs[1], (a::Expr).args[2:end]...)
-        end
-    end
-    newargs = map(unsafe, ex.args)
-    if ex.head == :ref
-        # getindex
-        return Expr(:call, :(OffsetArrays.unsafe_getindex), newargs...)
-    end
-    Expr(ex.head, newargs...)
-end
-
-@inline unsafe_getindex(a::AbstractArray, I...) = (@inbounds ret = a[I...]; ret)
-@inline unsafe_setindex!(a::AbstractArray, val, I...) = (@inbounds a[I...] = val; val)
-
-# Linear indexing
-@inline unsafe_getindex(a::OffsetArray, i::Int) = _unsafe_getindex(IndexStyle(a), a, i)
-@inline unsafe_setindex!(a::OffsetArray, val, i::Int) = _unsafe_setindex!(IndexStyle(a), a, val, i)
-for T in (IndexLinear, IndexCartesian)  # ambiguity-resolution requires specificity for both
-    @eval begin
-        @inline function _unsafe_getindex(::$T, a::OffsetVector, i::Int)
-            @inbounds ret = parent(a)[offset(a.offsets, (i,))[1]]
-            ret
-        end
-        @inline function _unsafe_setindex!(::$T, a::OffsetVector, val, i::Int)
-            @inbounds parent(a)[offset(a.offsets, (i,))[1]] = val
-            val
-        end
-    end
-end
-@inline function _unsafe_getindex(::IndexLinear, a::OffsetArray, i::Int)
-    @inbounds ret = parent(a)[i]
-    ret
-end
-@inline _unsafe_getindex(::IndexCartesian, a::OffsetArray, i::Int) =
-    unsafe_getindex(a, CartesianIndices(axes(a))[i])
-@inline function _unsafe_setindex!(::IndexLinear, a::OffsetArray, val, i::Int)
-    @inbounds parent(a)[i] = val
-    val
-end
-@inline _unsafe_setindex!(::IndexCartesian, a::OffsetArray, val, i::Int) =
-    unsafe_setindex!(a, val, CartesianIndices(axes(a))[i]...)
-
-@inline unsafe_getindex(a::OffsetArray, I::Int...) = unsafe_getindex(parent(a), offset(a.offsets, I)...)
-@inline unsafe_setindex!(a::OffsetArray, val, I::Int...) = unsafe_setindex!(parent(a), val, offset(a.offsets, I)...)
-@inline unsafe_getindex(a::OffsetArray, I...) = unsafe_getindex(a, Base.IteratorsMD.flatten(I)...)
-@inline unsafe_setindex!(a::OffsetArray, val, I...) = unsafe_setindex!(a, val, Base.IteratorsMD.flatten(I)...)
-
-# Indexing a SubArray which has OffsetArray axes
-OffsetSubArray{T,N,P,I<:Tuple{OffsetArray,Vararg{OffsetArray}}} = SubArray{T,N,P,I,false}
-@inline function unsafe_getindex(a::OffsetSubArray{T,N}, I::Vararg{Int,N}) where {T,N}
-    J = map(unsafe_getindex, a.indexes, I)
-    unsafe_getindex(parent(a), J...)
-end
-@inline function unsafe_setindex!(a::OffsetSubArray{T,N}, val, I::Vararg{Int,N}) where {T,N}
-    J = map(unsafe_getindex, a.indexes, I)
-    unsafe_setindex!(parent(a), val, J...)
-end
-@inline unsafe_getindex(a::OffsetSubArray, I::Union{Integer,CartesianIndex}...) = unsafe_getindex(a, Base.IteratorsMD.flatten(I)...)
-@inline unsafe_setindex!(a::OffsetSubArray, val, I::Union{Integer,CartesianIndex}...) = unsafe_setindex!(a, val, Base.IteratorsMD.flatten(I)...)
+@eval @deprecate $(Symbol("@unsafe")) $(Symbol("@inbounds"))
 
 function Base.showarg(io::IO, a::OffsetArray, toplevel)
     print(io, "OffsetArray(")
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -6,14 +6,14 @@ using DelimitedFiles
 
 # Basics
 for n = 0:5
-    for a in (OffsetArray(ones(Int,ntuple(d->1,n)), ntuple(x->x-1,n)),
+    for z in (OffsetArray(ones(Int,ntuple(d->1,n)), ntuple(x->x-1,n)),
               fill!(OffsetArray{Float64}(undef, ntuple(x->x:x, n)), 1),
               fill!(OffsetArray{Float64}(undef, ntuple(x->x:x, n)...), 1),
               fill!(OffsetArray{Float64,n}(undef, ntuple(x->x:x, n)), 1),
               fill!(OffsetArray{Float64,n}(undef, ntuple(x->x:x, n)...), 1))
-        @test length(LinearIndices(a)) == 1
-        @test axes(a) == ntuple(x->x:x, n)
-        @test a[1] == 1
+        @test length(LinearIndices(z)) == 1
+        @test axes(z) == ntuple(x->x:x, n)
+        @test z[1] == 1
     end
 end
 a0 = reshape([3])
@@ -41,8 +41,9 @@ A0 = [1 3; 2 4]
 A = OffsetArray(A0, (-1,2))                   # IndexLinear
 S = OffsetArray(view(A0, 1:2, 1:2), (-1,2))   # IndexCartesian
 @test axes(A) == axes(S) == (0:1, 3:4)
-@test_throws ErrorException size(A)
-@test_throws ErrorException size(A, 1)
+@test size(A) == size(A0)
+@test size(A, 1) == size(A0, 1)
+@test length(A) == length(A0)
 @test A == OffsetArray(A0, 0:1, 3:4)
 @test_throws DimensionMismatch OffsetArray(A0, 0:2, 3:4)
 @test_throws DimensionMismatch OffsetArray(A0, 0:1, 2:4)
@@ -52,10 +53,10 @@ S = OffsetArray(view(A0, 1:2, 1:2), (-1,2))   # IndexCartesian
 @test A[1,3] == A[1,3,1] == A[2] == S[1,3] == S[1,3,1] == S[2] == 2
 @test A[0,4] == A[0,4,1] == A[3] == S[0,4] == S[0,4,1] == S[3] == 3
 @test A[1,4] == A[1,4,1] == A[4] == S[1,4] == S[1,4,1] == S[4] == 4
-@test @unsafe(A[0,3]) == @unsafe(A[0,3,1]) == @unsafe(A[1]) == @unsafe(S[0,3]) == @unsafe(S[0,3,1]) == @unsafe(S[1]) == 1
-@test @unsafe(A[1,3]) == @unsafe(A[1,3,1]) == @unsafe(A[2]) == @unsafe(S[1,3]) == @unsafe(S[1,3,1]) == @unsafe(S[2]) == 2
-@test @unsafe(A[0,4]) == @unsafe(A[0,4,1]) == @unsafe(A[3]) == @unsafe(S[0,4]) == @unsafe(S[0,4,1]) == @unsafe(S[3]) == 3
-@test @unsafe(A[1,4]) == @unsafe(A[1,4,1]) == @unsafe(A[4]) == @unsafe(S[1,4]) == @unsafe(S[1,4,1]) == @unsafe(S[4]) == 4
+@test @inbounds(A[0,3]) == @inbounds(A[0,3,1]) == @inbounds(A[1]) == @inbounds(S[0,3]) == @inbounds(S[0,3,1]) == @inbounds(S[1]) == 1
+@test @inbounds(A[1,3]) == @inbounds(A[1,3,1]) == @inbounds(A[2]) == @inbounds(S[1,3]) == @inbounds(S[1,3,1]) == @inbounds(S[2]) == 2
+@test @inbounds(A[0,4]) == @inbounds(A[0,4,1]) == @inbounds(A[3]) == @inbounds(S[0,4]) == @inbounds(S[0,4,1]) == @inbounds(S[3]) == 3
+@test @inbounds(A[1,4]) == @inbounds(A[1,4,1]) == @inbounds(A[4]) == @inbounds(S[1,4]) == @inbounds(S[1,4,1]) == @inbounds(S[4]) == 4
 @test_throws BoundsError A[1,1]
 @test_throws BoundsError S[1,1]
 @test_throws BoundsError A[0,3,2]
@@ -65,7 +66,7 @@ Ac[0,3] = 10
 @test Ac[0,3] == 10
 Ac[0,3,1] = 11
 @test Ac[0,3] == 11
-@unsafe Ac[0,3,1] = 12
+@inbounds Ac[0,3,1] = 12
 @test Ac[0,3] == 12
 
 # Vector indexing
@@ -86,8 +87,8 @@ Ac[0,3,1] = 11
 # CartesianIndexing
 @test A[CartesianIndex((0,3))] == S[CartesianIndex((0,3))] == 1
 @test A[CartesianIndex((0,3)),1] == S[CartesianIndex((0,3)),1] == 1
-@test @unsafe(A[CartesianIndex((0,3))]) == @unsafe(S[CartesianIndex((0,3))]) == 1
-@test @unsafe(A[CartesianIndex((0,3)),1]) == @unsafe(S[CartesianIndex((0,3)),1]) == 1
+@test @inbounds(A[CartesianIndex((0,3))]) == @inbounds(S[CartesianIndex((0,3))]) == 1
+@test @inbounds(A[CartesianIndex((0,3)),1]) == @inbounds(S[CartesianIndex((0,3)),1]) == 1
 @test_throws BoundsError A[CartesianIndex(1,1)]
 @test_throws BoundsError A[CartesianIndex(1,1),0]
 @test_throws BoundsError A[CartesianIndex(1,1),2]
@@ -353,12 +354,12 @@ B = fill(5, 1:3, -1:1)
 @test axes(B) == (1:3,-1:1)
 @test all(B.==5)
 
-# @unsafe
+# @inbounds
 a = OffsetArray(zeros(7), -3:3)
-unsafe_fill!(x) = @unsafe(for i in axes(x,1); x[i] = i; end)
+unsafe_fill!(x) = @inbounds(for i in axes(x,1); x[i] = i; end)
 function unsafe_sum(x)
     s = zero(eltype(x))
-    @unsafe for i in axes(x,1)
+    @inbounds for i in axes(x,1)
         s += x[i]
     end
     s

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-julia 0.7.0-beta.73`
	`1`	`+julia 0.7.0-beta.270`