Add tests for ReinterpretArray and ranges

Author: Tokazama

src/stridelayout.jl

@@ -304,11 +304,11 @@ axes_types(::Type{T}) where {T<:Transpose} = _perm_tuple(axes_types(parent_type(
 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<:OptionallyStaticRange}
+function axes_types(::Type{T}) where {T<:AbstractRange}
     if known_length(T) === nothing
         return Tuple{OptionallyStaticUnitRange{One,Int}}
     else
-        return Tuple{OptionallyStaticUnitRange{One,StaticInt{known_length(T) - 1}}}
+        return Tuple{OptionallyStaticUnitRange{One,StaticInt{known_length(T)}}}
     end
 end
 
@@ -331,16 +331,15 @@ end
 end
 
 @inline function axes_types(::Type{T}) where {T<:Base.ReinterpretArray}
-    return _reinterpret_axes_types(axes_type(parent_type(T)), eltype(T), eltype(parent_type(T)))
+    return _reinterpret_axes_types(axes_types(parent_type(T)), eltype(T), eltype(parent_type(T)))
 end
 @generated function _reinterpret_axes_types(::Type{I}, ::Type{T}, ::Type{S}) where {I<:Tuple,T,S}
     out = Expr(:curly, :Tuple)
-    for i in 1:length(T.parameters)
+    for i in 1:length(I.parameters)
         if i === 1
-            push!(out.args, :(reinterpret_axis_type($(I.parameters[1]), $T, $S)))
+            push!(out.args, reinterpret_axis_type(I.parameters[1], T, S))
         else
-            # FIXME double check this once I've slept
-            push!(out.args, :($(I.parameters[i])))
+            push!(out.args, I.parameters[i])
         end
     end
     Expr(:block, Expr(:meta, :inline), out)
@@ -362,7 +361,7 @@ end
     if known_length(A) === nothing
         return OptionallyStaticUnitRange{One,Int}
     else
-        return OptionallyStaticUnitRange{One,StaticInt{Int(known_length(A) / (sizeof(T) / sizeof(S))) - 1}}
+        return OptionallyStaticUnitRange{One,StaticInt{Int(known_length(A) / (sizeof(T) / sizeof(S)))}}
     end
 end
 
@@ -531,6 +530,7 @@ end
     Expr(:block, Expr(:meta, :inline), t)
 end
 
+@inline size(v::AbstractVector) = (static_length(axes_types(v, 1)),)
 @inline size(B::Union{Transpose{T,A},Adjoint{T,A}}) where {T,A<:AbstractMatrix{T}} = permute(size(parent(B)), Val{(2,1)}())
 @inline size(B::PermutedDimsArray{T,N,I1,I2,A}) where {T,N,I1,I2,A<:AbstractArray{T,N}} = permute(size(parent(B)), Val{I1}())
 @inline size(A::AbstractArray, ::StaticInt{N}) where {N} = size(A)[N]

test/runtests.jl

@@ -355,7 +355,6 @@ using OffsetArrays
     @test @inferred(dense_dims(@view(PermutedDimsArray(A,(3,1,2))[2:3,:,[1,2]]))) === ArrayInterface.DenseDims((false,true,false))
     @test @inferred(dense_dims(@view(PermutedDimsArray(A,(3,1,2))[2:3,[1,2,3],:]))) === ArrayInterface.DenseDims((false,false,false))
 
-
     B = Array{Int8}(undef, 2,2,2,2);
     doubleperm = PermutedDimsArray(PermutedDimsArray(B,(4,2,3,1)), (4,2,1,3));
     @test collect(strides(B))[collect(stride_rank(doubleperm))] == collect(strides(doubleperm))
@@ -368,11 +367,18 @@ end
     Sp2 = @view(PermutedDimsArray(S,(3,2,1))[2:3,:,:]);
     Mp2 = @view(PermutedDimsArray(M,(3,1,2))[2:3,:,2])';
     D = @view(A[:,2:2:4,:])
+    R = StaticInt(1):StaticInt(2)
+    Rr = reinterpret(Int32, R)
+    Ar = reinterpret(Float32, A)
 
+ 
     @test @inferred(ArrayInterface.size(A)) === (3,4,5)
     @test @inferred(ArrayInterface.size(Ap)) === (2,5)
     @test @inferred(ArrayInterface.size(A)) === size(A)
     @test @inferred(ArrayInterface.size(Ap)) === size(Ap)
+    @test @inferred(ArrayInterface.size(R)) === (StaticInt(2),)
+    @test @inferred(ArrayInterface.size(Rr)) === (StaticInt(4),)
+
 
     @test @inferred(ArrayInterface.size(S)) === (StaticInt(2), StaticInt(3), StaticInt(4))
     @test @inferred(ArrayInterface.size(Sp)) === (2, 2, StaticInt(3))
@@ -394,6 +400,9 @@ end
 
     @test @inferred(ArrayInterface.known_size(A)) === (nothing, nothing, nothing)
     @test @inferred(ArrayInterface.known_size(Ap)) === (nothing,nothing)
+    @test @inferred(ArrayInterface.known_size(R)) === (2,)
+    @test @inferred(ArrayInterface.known_size(Rr)) === (4,)
+    @test @inferred(ArrayInterface.known_size(Ar)) === (nothing,nothing, nothing,)
 
     @test @inferred(ArrayInterface.known_size(S)) === (2, 3, 4)
     @test @inferred(ArrayInterface.known_size(Sp)) === (nothing, nothing, 3)
@@ -410,6 +419,8 @@ end
     @test @inferred(ArrayInterface.strides(Ap)) === (StaticInt(1), 12)
     @test @inferred(ArrayInterface.strides(A)) == strides(A)
     @test @inferred(ArrayInterface.strides(Ap)) == strides(Ap)
+    @test @inferred(ArrayInterface.strides(Ar)) === (StaticInt{1}(), 6, 24)
+
 
     @test @inferred(ArrayInterface.strides(S)) === (StaticInt(1), StaticInt(2), StaticInt(6))
     @test @inferred(ArrayInterface.strides(Sp)) === (StaticInt(6), StaticInt(1), StaticInt(2))
@@ -427,7 +438,8 @@ end
 
     @test @inferred(ArrayInterface.known_strides(A)) === (1, nothing, nothing)
     @test @inferred(ArrayInterface.known_strides(Ap)) === (1, nothing)
-    
+    @test @inferred(ArrayInterface.known_strides(Ar)) === (1, nothing, nothing)
+
     @test @inferred(ArrayInterface.known_strides(S)) === (1, 2, 6)
     @test @inferred(ArrayInterface.known_strides(Sp)) === (6, 1, 2)
     @test @inferred(ArrayInterface.known_strides(Sp2)) === (6, 2, 1)
@@ -441,6 +453,7 @@ end
 
     @test @inferred(ArrayInterface.offsets(A)) === (StaticInt(1), StaticInt(1), StaticInt(1))
     @test @inferred(ArrayInterface.offsets(Ap)) === (StaticInt(1), StaticInt(1))
+    @test @inferred(ArrayInterface.offsets(Ar)) === (StaticInt(1), StaticInt(1), StaticInt(1))
 
     @test @inferred(ArrayInterface.offsets(S)) === (StaticInt(1), StaticInt(1), StaticInt(1))
     @test @inferred(ArrayInterface.offsets(Sp)) === (StaticInt(1), StaticInt(1), StaticInt(1))
@@ -452,6 +465,7 @@ end
 
     @test @inferred(ArrayInterface.known_offsets(A)) === (1, 1, 1)
     @test @inferred(ArrayInterface.known_offsets(Ap)) === (1, 1)
+    @test @inferred(ArrayInterface.known_offsets(Ar)) === (1, 1, 1)
 
     @test @inferred(ArrayInterface.known_offsets(S)) === (1, 1, 1)
     @test @inferred(ArrayInterface.known_offsets(Sp)) === (1, 1, 1)
@@ -461,6 +475,10 @@ end
     @test @inferred(ArrayInterface.known_offsets(Mp)) === (1, 1)
     @test @inferred(ArrayInterface.known_offsets(Mp2)) === (1, 1)
 
+    @test @inferred(ArrayInterface.known_offsets(R)) === (1,)
+    @test @inferred(ArrayInterface.known_offsets(Rr)) === (1,)
+    @test @inferred(ArrayInterface.known_offsets(1:10)) === (1,)
+
     O = OffsetArray(A, 3, 7, 10);
     Op = PermutedDimsArray(O,(3,1,2));
     @test @inferred(ArrayInterface.offsets(O)) === (4, 8, 11)