Improve organization / reduce organizational change vs earlier.

Author: chriselrod

src/ArrayInterface.jl

@@ -744,10 +744,9 @@ end
 
 include("static.jl")
 include("ranges.jl")
-include("dimensions.jl")
 include("indexing.jl")
+include("dimensions.jl")
 include("stridelayout.jl")
-include("generated_funcs.jl")
 
 function __init__()
 

src/dimensions.jl

@@ -26,6 +26,19 @@ Returns the mapping from parent dimensions to child dimensions.
 from_parent_dims(::Type{T}) where {T} = nstatic(Val(ndims(T)))
 from_parent_dims(::Type{T}) where {T<:Union{Transpose,Adjoint}} = (StaticInt(2), One())
 from_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _from_sub_dims(A, I)
+@generated function _from_sub_dims(::Type{A}, ::Type{I}) where {A,N,I<:Tuple{Vararg{Any,N}}}
+    out = Expr(:tuple)
+    n = 1
+    for p in I.parameters
+        if argdims(A, p) > 0
+            push!(out.args, :(StaticInt($n)))
+            n += 1
+        else
+            push!(out.args, :(StaticInt(0)))
+        end
+    end
+    out
+end
 function from_parent_dims(::Type{<:PermutedDimsArray{T,N,<:Any,I}}) where {T,N,I}
     return _val_to_static(Val(I))
 end
@@ -40,6 +53,17 @@ to_parent_dims(::Type{T}) where {T} = nstatic(Val(ndims(T)))
 to_parent_dims(::Type{T}) where {T<:Union{Transpose,Adjoint}} = (StaticInt(2), One())
 to_parent_dims(::Type{<:PermutedDimsArray{T,N,I}}) where {T,N,I} = _val_to_static(Val(I))
 to_parent_dims(::Type{<:SubArray{T,N,A,I}}) where {T,N,A,I} = _to_sub_dims(A, I)
+@generated function _to_sub_dims(::Type{A}, ::Type{I}) where {A,N,I<:Tuple{Vararg{Any,N}}}
+    out = Expr(:tuple)
+    n = 1
+    for p in I.parameters
+        if argdims(A, p) > 0
+            push!(out.args, :(StaticInt($n)))
+        end
+        n += 1
+    end
+    out
+end
 
 """
     has_dimnames(::Type{T}) -> Bool
@@ -222,19 +246,72 @@ end
 @inline function axes_types(::Type{T}) where {P,I,T<:SubArray{<:Any,<:Any,P,I}}
     return _sub_axes_types(Val(ArrayStyle(T)), I, axes_types(P))
 end
-
 @inline function axes_types(::Type{T}) where {T<:Base.ReinterpretArray}
     return _reinterpret_axes_types(
         axes_types(parent_type(T)),
         eltype(T),
         eltype(parent_type(T)),
     )
 end
-
 function axes_types(::Type{T}) where {N,T<:Base.ReshapedArray{<:Any,N}}
     return Tuple{Vararg{OptionallyStaticUnitRange{One,Int},N}}
 end
 
+# These methods help handle identifying axes that don't directly propagate from the
+# parent array axes. They may be worth making a formal part of the API, as they provide
+# a low traffic spot to change what axes_types produces.
+@inline function sub_axis_type(::Type{A}, ::Type{I}) where {A,I}
+    if known_length(I) === nothing
+        return OptionallyStaticUnitRange{One,Int}
+    else
+        return OptionallyStaticUnitRange{One,StaticInt{known_length(I)}}
+    end
+end
+@generated function _sub_axes_types(
+    ::Val{S},
+    ::Type{I},
+    ::Type{PI},
+) where {S,I<:Tuple,PI<:Tuple}
+    out = Expr(:curly, :Tuple)
+    d = 1
+    for i in I.parameters
+        ad = argdims(S, i)
+        if ad > 0
+            push!(out.args, :(sub_axis_type($(PI.parameters[d]), $i)))
+            d += ad
+        else
+            d += 1
+        end
+    end
+    Expr(:block, Expr(:meta, :inline), out)
+end
+@inline function reinterpret_axis_type(::Type{A}, ::Type{T}, ::Type{S}) where {A,T,S}
+    if known_length(A) === nothing
+        return OptionallyStaticUnitRange{One,Int}
+    else
+        return OptionallyStaticUnitRange{
+            One,
+            StaticInt{Int(known_length(A) / (sizeof(T) / sizeof(S)))},
+        }
+    end
+end
+@generated function _reinterpret_axes_types(
+    ::Type{I},
+    ::Type{T},
+    ::Type{S},
+) where {I<:Tuple,T,S}
+    out = Expr(:curly, :Tuple)
+    for i = 1:length(I.parameters)
+        if i === 1
+            push!(out.args, reinterpret_axis_type(I.parameters[1], T, S))
+        else
+            push!(out.args, I.parameters[i])
+        end
+    end
+    Expr(:block, Expr(:meta, :inline), out)
+end
+
+
 
 """
   size(A)
@@ -266,6 +343,19 @@ end
 function strides(B::S) where {N,NP,T,A<:AbstractArray{T,NP},I,S<:SubArray{T,N,A,I}}
     return _strides(strides(parent(B)), B.indices)
 end
+@generated function _size(A::Tuple{Vararg{Any,N}}, inds::I, l::L) where {N,I<:Tuple,L}
+    t = Expr(:tuple)
+    for n = 1:N
+        if (I.parameters[n] <: Base.Slice)
+            push!(t.args, :(@inbounds(_try_static(A[$n], l[$n]))))
+        elseif I.parameters[n] <: Number
+            nothing
+        else
+            push!(t.args, Expr(:ref, :l, n))
+        end
+    end
+    Expr(:block, Expr(:meta, :inline), t)
+end
 @inline size(v::AbstractVector) = (static_length(v),)
 @inline size(B::MatAdjTrans) = permute(size(parent(B)), Val{(2, 1)}())
 @inline function size(B::PermutedDimsArray{T,N,I1,I2,A}) where {T,N,I1,I2,A}

src/generated_funcs.jl

@@ -313,27 +313,7 @@ end
 _known_length(::Nothing, _, __) = nothing
 @inline _known_length(L::Integer, ::Type{T}, ::Type{P}) where {T,P} = L * sizeof(P) ÷ sizeof(T)
 
-# These methods help handle identifying axes that dont' directly propagate from the
-# parent array axes. They may be worth making a formal part of the API, as they provide
-# a low traffic spot to change what axes_types produces.
-@inline function sub_axis_type(::Type{A}, ::Type{I}) where {A,I}
-    if known_length(I) === nothing
-        return OptionallyStaticUnitRange{One,Int}
-    else
-        return OptionallyStaticUnitRange{One,StaticInt{known_length(I)}}
-    end
-end
 
-@inline function reinterpret_axis_type(::Type{A}, ::Type{T}, ::Type{S}) where {A,T,S}
-    if known_length(A) === nothing
-        return OptionallyStaticUnitRange{One,Int}
-    else
-        return OptionallyStaticUnitRange{
-            One,
-            StaticInt{Int(known_length(A) / (sizeof(T) / sizeof(S)))},
-        }
-    end
-end
 
 """
     known_offsets(::Type{T}[, d]) -> Tuple
@@ -343,6 +323,13 @@ not known at compile time `nothing` is returned its position.
 """
 @inline known_offsets(x, d) = known_offsets(x)[to_dims(x, d)]
 known_offsets(x) = known_offsets(typeof(x))
+@generated function known_offsets(::Type{T}) where {T}
+    out = Expr(:tuple)
+    for p in axes_types(T).parameters
+        push!(out.args, known_first(p))
+    end
+    return out
+end
 
 """
     known_size(::Type{T}[, d]) -> Tuple