Use static indices for deletat and safer param access (#287)

Since we created our own ArrayInterface.length we were calling OneTo(static_length) indirectly. We might as well just use the known indices so that if the compiler ever gets smart enough it can unroll that. We also shouldn't be doing T.parameters[i] as much so this fixes some of that. I also threw in some very minor changes that reduced invalidations from over 100 to 27 when loading ArrayInterface.

All changes were locally tested to ensure we wouldn't get performance regressions.

Author: Tokazama

Project.toml

@@ -1,6 +1,6 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "6.0.6"
+version = "6.0.7"
 
 [deps]
 ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"

src/ArrayInterface.jl

@@ -51,7 +51,7 @@ function Base.axes(A::AbstractArray2)
     !(parent_type(A) <: typeof(A)) && return ArrayInterface.axes(parent(A))
     throw(ArgumentError("Subtypes of `AbstractArray2` must define an axes method"))
 end
-Base.axes(A::AbstractArray2, dim) = ArrayInterface.axes(A, dim)
+Base.axes(A::AbstractArray2, dim::Union{Symbol,StaticSymbol}) = Base.axes(A, to_dims(A, dim))
 
 function Base.strides(A::AbstractArray2)
     defines_strides(A) && return map(Int, ArrayInterface.strides(A))
@@ -256,7 +256,7 @@ end
 @inline function unsafe_deleteat(src::Tuple, inds::AbstractVector)
     dst = Vector{eltype(src)}(undef, length(src) - length(inds))
     dst_index = firstindex(dst)
-    @inbounds for src_index in OneTo(length(src))
+    @inbounds for src_index in static(1):length(src)
         if !in(src_index, inds)
             dst[dst_index] = src[src_index]
             dst_index += one(dst_index)

src/axes.jl

@@ -17,7 +17,7 @@ end
     if dim > ndims(x)
         return SOneTo{1}
     else
-        return axes_types(x).parameters[dim]
+        return fieldtype(axes_types(x), dim)
     end
 end
 axes_types(x) = axes_types(typeof(x))
@@ -230,7 +230,6 @@ end
 end
 ArrayInterfaceCore.known_last(::Type{LazyAxis{N,P}}) where {N,P} = known_last(axes_types(P, static(N)))
 ArrayInterfaceCore.known_last(::Type{LazyAxis{:,P}}) where {P} = known_length(P)
-Base.lastindex(x::LazyAxis) = last(x)
 Base.last(x::LazyAxis) = _last(known_last(x), x)
 _last(::Nothing, x) = last(parent(x))
 _last(N::Int, x) = N

src/dimensions.jl

@@ -50,8 +50,8 @@ from_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _from_sub_dims(I
 @generated function _from_sub_dims(::Type{I}) where {I<:Tuple}
     out = Expr(:tuple)
     dim_i = 1
-    for i in 1:length(I.parameters)
-        p = I.parameters[i]
+    for i in 1:fieldcount(I)
+        p = fieldtype(I, i)
         if p <: CanonicalInt
             push!(out.args, :(StaticInt(0)))
         else
@@ -106,7 +106,8 @@ to_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _to_sub_dims(I)
 @generated function _to_sub_dims(::Type{I}) where {I<:Tuple}
     out = Expr(:tuple)
     n = 1
-    for p in I.parameters
+    for i in 1:fieldcount(I)
+        p = fieldtype(I, i)
         if !(p <: CanonicalInt)
             push!(out.args, :(StaticInt($n)))
         end

src/ranges.jl

@@ -239,7 +239,6 @@ end
 end
 
 ## length
-Base.lastindex(x::OptionallyStaticRange) = length(x)
 @inline function Base.length(r::OptionallyStaticUnitRange)
     if isempty(r)
         return 0
@@ -274,7 +273,6 @@ function Base.AbstractUnitRange{T}(r::OptionallyStaticUnitRange) where {T}
     end
 end
 
-Base.eachindex(r::OptionallyStaticRange) = One():length(r)
 @inline function Base.iterate(r::OptionallyStaticRange)
     isempty(r) && return nothing
     fi = Int(first(r));
@@ -302,7 +300,7 @@ Base.axes(S::Slice{<:OptionallyStaticUnitRange{One}}) = (S.indices,)
 Base.axes(S::Slice{<:OptionallyStaticRange}) = (Base.IdentityUnitRange(S.indices),)
 
 Base.axes(x::OptionallyStaticRange) = (Base.axes1(x),)
-Base.axes1(x::OptionallyStaticRange) = eachindex(x)
+Base.axes1(x::OptionallyStaticRange) = static(1):length(x)
 Base.axes1(x::Slice{<:OptionallyStaticUnitRange{One}}) = x.indices
 Base.axes1(x::Slice{<:OptionallyStaticRange}) = Base.IdentityUnitRange(x.indices)