Revert "Clean up code and version bump"

This reverts commit fcb6341.

Author: Tokazama

Project.toml

@@ -1,6 +1,6 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "3.1"
+version = "3.0.2"
 
 [deps]
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"

src/ArrayInterface.jl

@@ -6,7 +6,7 @@ using LinearAlgebra
 using SparseArrays
 using Base.Cartesian
 
-using Base: @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray
+using Base: @pure, @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray
 
 Base.@pure __parameterless_type(T) = Base.typename(T).wrapper
 parameterless_type(x) = parameterless_type(typeof(x))

src/dimensions.jl

@@ -172,8 +172,26 @@ end
     i === nothing && no_dimname_error(T, dim)
     return i
 end
-to_dims(::Type{T}, dims::Tuple) where {T} = map(i -> to_dims(T, i), dims)
+#=
+    return i
+    i = 1
+    out = 0
+    for s in dimnames(T)
+        if Symbol(s) === dim
+            out = i
+            break
+        else
+            i += i
+        end
+    end
+    if out === 0
+        no_dimname_error(T, dim)
+    end
+    return out
+end
+=#
 
+to_dims(::Type{T}, dims::Tuple) where {T} = map(i -> to_dims(T, i), dims)
 #=
     order_named_inds(names, namedtuple)
     order_named_inds(names, subnames, inds)
@@ -217,6 +235,49 @@ function _order_named_inds_check(inds::Tuple{Vararg{Any,N}}, nkwargs::Int) where
     return nothing
 end
 
+
+#=
+name_to_idx(name::StaticSymbol, kwargs::Tuple, inds::Tuple, )
+name_to_idx(name::StaticSymbol, kwargs::Tuple, inds::Tuple) = _name_to_index(find_first_eq(), inds)
+_name_to_index(::Zero, ::Tuple) = Colon()
+_name_to_index(::StaticInt{N}, inds::Tuple) where {N} = getfield(inds, N)
+
+#    return permute(inds, static_find_all_in(nd, x))
+_colon_or_inds(inds::Tuple, ::Zero) = :
+_colon_or_inds(inds::Tuple, ::StaticInt{I}) where {I} = getfield(inds, I)
+
+n_i -> _colon_or_inds(inds, find_first_eq(n_i, x))
+# FIXME this needs to insert a colon on missing names
+
+@inline function order_named_inds(val::Val{L}; kwargs...) where {L}
+    if isempty(kwargs)
+        return ()
+    else
+        return order_named_inds(val, kwargs.data)
+    end
+end
+@generated function order_named_inds(val::Val{L}, ni::NamedTuple{K}) where {L,K}
+    tuple_issubset(K, L) || throw(DimensionMismatch("Expected subset of $L, got $K"))
+    exs = map(L) do n
+        if Base.sym_in(n, K)
+            qn = QuoteNode(n)
+            :(getfield(ni, $qn))
+        else
+            :(Colon())
+        end
+    end
+    return Expr(:tuple, exs...)
+end
+=#
+
+@generated function _perm_tuple(::Type{T}, ::Val{P}) where {T,P}
+    out = Expr(:curly, :Tuple)
+    for p in P
+        push!(out.args, T.parameters[p])
+    end
+    Expr(:block, Expr(:meta, :inline), out)
+end
+
 """
     axes_types(::Type{T}[, d]) -> Type
 
@@ -232,11 +293,14 @@ function axes_types(::Type{T}) where {T}
         return axes_types(parent_type(T))
     end
 end
-function axes_types(::Type{T}) where {T<:MatAdjTrans}
-    return eachop_tuple(_get_tuple, axes_types(parent_type(T)), to_parent_dims(T))
+function axes_types(::Type{T}) where {T<:Adjoint}
+    return _perm_tuple(axes_types(parent_type(T)), Val((2, 1)))
+end
+function axes_types(::Type{T}) where {T<:Transpose}
+    return _perm_tuple(axes_types(parent_type(T)), Val((2, 1)))
 end
-function axes_types(::Type{T}) where {T<:PermutedDimsArray}
-    return eachop_tuple(_get_tuple, axes_types(parent_type(T)), to_parent_dims(T))
+function axes_types(::Type{T}) where {I1,T<:PermutedDimsArray{<:Any,<:Any,I1}}
+    return _perm_tuple(axes_types(parent_type(T)), Val(I1))
 end
 function axes_types(::Type{T}) where {T<:AbstractRange}
     if known_length(T) === nothing

src/indexing.jl

@@ -662,4 +662,3 @@ end
 ) where {N}
     return _generate_unsafe_setindex!_body(N)
 end
-

src/static.jl

@@ -272,6 +272,7 @@ function invariant_permutation(x::T, y::T) where {N,T<:Tuple{Vararg{StaticInt,N}
 end
 
 permute(x::Tuple, perm::Val) = permute(x, static(perm))
+# TODO delete this? permute(x::Tuple, perm::Tuple) = eachop(getindex, x, perm)
 function permute(x::Tuple{Vararg{Any}}, perm::Tuple{Vararg{StaticInt}})
     if invariant_permutation(perm, perm) isa False
         return eachop(getindex, x, perm)
@@ -296,14 +297,6 @@ end
     Expr(:block, Expr(:meta, :inline), t)
 end
 
-@generated function eachop_tuple(op, x, ::I) where {I}
-    t = Expr(:curly, :Tuple)
-    for p in I.parameters
-        push!(t.args, :(op(x, StaticInt{$(p.parameters[1])}())))
-    end
-    Expr(:block, Expr(:meta, :inline), t)
-end
-
 """
     eq(x::StaticInt, y::StaticInt) -> StaticBool