Merge pull request #7 from mateuszbaran/mbaran/static-arrays-0-12-1

StaticArrays 0.12.1 compatibility

Author: mateuszbaran

Project.toml

@@ -1,14 +1,14 @@
 name = "HybridArrays"
 uuid = "1baab800-613f-4b0a-84e4-9cd3431bfbb9"
 authors = ["Mateusz Baran <[email protected]>"]
-version = "0.3.0"
+version = "0.3.1"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-StaticArrays = "=0.12.0"
+StaticArrays = "=0.12.1"
 julia = "1"
 
 [extras]

src/ssubarray.jl

@@ -91,50 +91,46 @@ Base._maybe_reindex(V::SSubArray, I, A::Tuple{AbstractArray{<:Base.AbstractCarte
 Base._maybe_reindex(V::SSubArray, I, A::Tuple{Any, Vararg{Any}}) = (Base.@_inline_meta; Base._maybe_reindex(V, I, Base.tail(A)))
 function Base._maybe_reindex(V::SSubArray, I, ::Tuple{})
     Base.@_inline_meta
-    @inbounds idxs = to_indices(V.parent, reindex(V.indices, I))
+    @inbounds idxs = to_indices(V.parent, _reindex(V.indices, I))
     return Base.unsafe_view(V.parent, idxs...)
 end
 
-if VERSION < v"1.2"
-    # reindex copied from Base because in pre-1.2 it has an incompatible implementation
-    reindex(::Tuple{}, ::Tuple{}) = ()
-
-    # Skip dropped scalars, so simply peel them off the parent indices and continue
-    reindex(idxs::Tuple{Base.ScalarIndex, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) =
-        (Base.@_propagate_inbounds_meta; (idxs[1], reindex(Base.tail(idxs), subidxs)...))
-
-    # Slices simply pass their subindices straight through
-    reindex(idxs::Tuple{Base.Slice, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
-        (Base.@_propagate_inbounds_meta; (subidxs[1], reindex(Base.tail(idxs), Base.tail(subidxs))...))
-
-    # Re-index into parent vectors with one subindex
-    reindex(idxs::Tuple{AbstractVector, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
-        (Base.@_propagate_inbounds_meta; (idxs[1][subidxs[1]], reindex(Base.tail(idxs), Base.tail(subidxs))...))
-
-    # Parent matrices are re-indexed with two sub-indices
-    reindex(idxs::Tuple{AbstractMatrix, Vararg{Any}}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
-        (Base.@_propagate_inbounds_meta; (idxs[1][subidxs[1], subidxs[2]], reindex(Base.tail(idxs), Base.tail(Base.tail(subidxs)))...))
-
-    # In general, we index N-dimensional parent arrays with N indices
-    @generated function reindex(idxs::Tuple{AbstractArray{T,N}, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) where {T,N}
-        if length(subidxs.parameters) >= N
-            subs = [:(subidxs[$d]) for d in 1:N]
-            tail = [:(subidxs[$d]) for d in N+1:length(subidxs.parameters)]
-            :(Base.@_propagate_inbounds_meta; (idxs[1][$(subs...)], reindex(Base.tail(idxs), ($(tail...),))...))
-        else
-            :(throw(ArgumentError("cannot re-index SubArray with fewer indices than dimensions\nThis should not occur; please submit a bug report.")))
-        end
+# reindex was copied from Base because in pre-1.2 it has an incompatible implementation
+_reindex(::Tuple{}, ::Tuple{}) = ()
+
+# Skip dropped scalars, so simply peel them off the parent indices and continue
+_reindex(idxs::Tuple{Base.ScalarIndex, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) =
+    (Base.@_propagate_inbounds_meta; (idxs[1], _reindex(Base.tail(idxs), subidxs)...))
+
+# Slices simply pass their subindices straight through
+_reindex(idxs::Tuple{Base.Slice, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
+    (Base.@_propagate_inbounds_meta; (subidxs[1], _reindex(Base.tail(idxs), Base.tail(subidxs))...))
+
+# Re-index into parent vectors with one subindex
+_reindex(idxs::Tuple{AbstractVector, Vararg{Any}}, subidxs::Tuple{Any, Vararg{Any}}) =
+    (Base.@_propagate_inbounds_meta; (idxs[1][subidxs[1]], _reindex(Base.tail(idxs), Base.tail(subidxs))...))
+
+# Parent matrices are re-indexed with two sub-indices
+_reindex(idxs::Tuple{AbstractMatrix, Vararg{Any}}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
+    (Base.@_propagate_inbounds_meta; (idxs[1][subidxs[1], subidxs[2]], _reindex(Base.tail(idxs), Base.tail(Base.tail(subidxs)))...))
+
+# In general, we index N-dimensional parent arrays with N indices
+@generated function _reindex(idxs::Tuple{AbstractArray{T,N}, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) where {T,N}
+    if length(subidxs.parameters) >= N
+        subs = [:(subidxs[$d]) for d in 1:N]
+        tail = [:(subidxs[$d]) for d in N+1:length(subidxs.parameters)]
+        :(Base.@_propagate_inbounds_meta; (idxs[1][$(subs...)], _reindex(Base.tail(idxs), ($(tail...),))...))
+    else
+        :(throw(ArgumentError("cannot re-index SubArray with fewer indices than dimensions\nThis should not occur; please submit a bug report.")))
     end
-else
-    using Base: reindex
 end
 
 # In general, we simply re-index the parent indices by the provided ones
 SlowSSubArray{S,T,N,P,I} = SSubArray{S,T,N,P,I,false}
 function getindex(V::SSubArray{S,T,N}, I::Vararg{Int,N}) where {S,T,N}
     Base.@_inline_meta
     @boundscheck checkbounds(V, I...)
-    @inbounds r = V.parent[reindex(V.indices, I)...]
+    @inbounds r = V.parent[_reindex(V.indices, I)...]
     r
 end
 
@@ -143,7 +139,7 @@ function getindex(V::SSubArray, i::Int)
     Base.@_inline_meta
     @boundscheck checkbounds(V, i)
     subind = Base._to_subscript_indices(V, i)
-    @inbounds r = V.parent[reindex(V.indices, subind)...]
+    @inbounds r = V.parent[_reindex(V.indices, subind)...]
     return r
 end
 
@@ -193,14 +189,14 @@ end
 function setindex!(V::SSubArray{T,N}, x, I::Vararg{Int,N}) where {T,N}
     Base.@_inline_meta
     @boundscheck checkbounds(V, I...)
-    @inbounds V.parent[reindex(V.indices, I)...] = x
+    @inbounds V.parent[_reindex(V.indices, I)...] = x
     V
 end
 # overrides the default setindex! from `StaticArrays`
 function setindex!(V::SSubArray, x, i::Int)
     Base.@_inline_meta
     subind = Base._to_subscript_indices(V, i)
-    @inbounds V.parent[reindex(V.indices, subind)...] = x
+    @inbounds V.parent[_reindex(V.indices, subind)...] = x
     V
 end
 function setindex!(V::FastSSubArray, x, i::Int)