Update for Julia v1.7 (#77)

* Update for Julia v1.7

* Update indices.jl

Author: dlfivefifty

.github/workflows/ci.yml

@@ -11,6 +11,7 @@ jobs:
       matrix:
         version:
           - '1.6'
+          - '^1.7.0-0'
         os:
           - ubuntu-latest
           - macOS-latest

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <solver@mac.com>"]
-version = "0.7.1"
+version = "0.8.0"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"

src/QuasiArrays.jl

@@ -7,11 +7,11 @@ import Base: getindex, size, axes, axes1, length, ==, isequal, iterate, Cartesia
 import Base: @_inline_meta, DimOrInd, OneTo, @_propagate_inbounds_meta, @_noinline_meta,
                 DimsInteger, error_if_canonical_getindex, @propagate_inbounds, _return_type,
                 _maybetail, tail, _getindex, _maybe_reshape, index_ndims, _unsafe_getindex,
-                index_shape, to_shape, unsafe_length, @nloops, @ncall, unalias, _unaliascopy,
+                index_shape, to_shape, @nloops, @ncall, unalias, _unaliascopy,
                 to_index, to_indices, _to_subscript_indices, _splatmap, dataids,
                 compute_stride1, compute_offset1, fill_to_length
 import Base: Slice, IdentityUnitRange, ScalarIndex, RangeIndex, view, viewindexing, mightalias, ensure_indexable, index_dimsum,
-                check_parent_index_match, reindex, _isdisjoint, unsafe_indices, _unsafe_ind2sub,
+                check_parent_index_match, reindex, _isdisjoint, _unsafe_ind2sub,
                 _ind2sub, _sub2ind, _ind2sub_recurse, _lookup, SubArray,
                 parentindices, reverse, ndims, checkbounds, uncolon,
                 maybeview, unsafe_view, checkindex, checkbounds_indices,

src/indices.jl

@@ -166,17 +166,17 @@ copy(d::Inclusion) = d
 domain(A::Inclusion) = A.domain
 domain(A::AbstractUnitRange) = A
 axes(S::Inclusion) = (S,)
-unsafe_indices(S::Inclusion) = (S,)
 axes1(S::Inclusion) = S
 axes(S::Inclusion{<:Any,<:OneTo}) = (S.domain,)
-unsafe_indices(S::Inclusion{<:Any,<:OneTo}) = (S.domain,)
 axes1(S::Inclusion{<:Any,<:OneTo}) = S.domain
 
 first(S::Inclusion) = first(S.domain)
 last(S::Inclusion) = last(S.domain)
 size(S::Inclusion) = (cardinality(S.domain),)
 length(S::Inclusion) = cardinality(S.domain)
-unsafe_length(S::Inclusion) = cardinality(S.domain)
+if VERSION < v"1.7-"
+    Base.unsafe_length(S::Inclusion) = length(S)
+end
 cardinality(S::Inclusion) = cardinality(S.domain)
 measure(x) = cardinality(x) # TODO: Inclusion(0:0.5:1) should have 
 getindex(S::Inclusion{T}, i::T) where T = (@_inline_meta; @boundscheck checkbounds(S, i); convert(T,i))

src/quasiadjtrans.jl

@@ -9,17 +9,9 @@
 # user-defined such objects. so do not restrict the wrapped type.
 struct QuasiAdjoint{T,S} <: AbstractQuasiMatrix{T}
     parent::S
-    function QuasiAdjoint{T,S}(A::S) where {T,S}
-        checkeltype_adjoint(T, eltype(A))
-        new(A)
-    end
 end
 struct QuasiTranspose{T,S} <: AbstractQuasiMatrix{T}
     parent::S
-    function QuasiTranspose{T,S}(A::S) where {T,S}
-        checkeltype_transpose(T, eltype(A))
-        new(A)
-    end
 end
 
 # basic outer constructors

src/quasibroadcast.jl

@@ -100,7 +100,7 @@ instantiate(bc::Broadcasted{<:AbstractQuasiArrayStyle{0}}) = bc
 result_join(::AbstractQuasiArrayStyle, ::AbstractQuasiArrayStyle, ::Unknown, ::Unknown) =
     QuasiArrayConflict()
 
-Base.@propagate_inbounds _newindex(ax::Tuple, I::Tuple) = (Base.unsafe_length(ax[1])==1 ? first(ax[1]) : I[1], _newindex(tail(ax), tail(I))...)
+Base.@propagate_inbounds _newindex(ax::Tuple, I::Tuple) = (length(ax[1])==1 ? first(ax[1]) : I[1], _newindex(tail(ax), tail(I))...)
 Base.@propagate_inbounds _newindex(ax::Tuple{}, I::Tuple) = ()
 Base.@propagate_inbounds _newindex(ax::Tuple, I::Tuple{}) = (first(ax[1]), _newindex(tail(ax), ())...)
 Base.@propagate_inbounds _newindex(ax::Tuple{}, I::Tuple{}) = ()

src/subquasiarray.jl

@@ -194,11 +194,11 @@ _quasi_indices_sub(axs::Tuple{AbstractVector{IND},Vararg{Any}}, inds::Tuple{IND,
 _quasi_indices_sub(::Tuple{}, ::Tuple{}) = ()
 function _quasi_indices_sub(axs::Tuple{AbstractQuasiVector{IND},Vararg{Any}}, inds::Tuple{AbstractArray{IND},Vararg{Any}}) where IND
     @_inline_meta
-    (unsafe_indices(inds[1])..., _quasi_indices_sub(tail(axs), tail(inds))...)
+    (axes(inds[1])..., _quasi_indices_sub(tail(axs), tail(inds))...)
 end
 function _quasi_indices_sub(axs::Tuple{AbstractVector{IND},Vararg{Any}}, inds::Tuple{AbstractArray{IND},Vararg{Any}}) where IND
     @_inline_meta
-    (unsafe_indices(inds[1])..., _quasi_indices_sub(tail(axs), tail(inds))...)
+    (axes(inds[1])..., _quasi_indices_sub(tail(axs), tail(inds))...)
 end
 
 quasi_reindex(axs::Tuple{AbstractQuasiOrVector{IND}, Vararg{Any}}, idxs::Tuple{IND, Vararg{Any}}, subidxs::Tuple{Vararg{Any}}) where IND =
@@ -275,12 +275,12 @@ end
 function compute_linindex(f, s, IP::Tuple, I::Tuple{ScalarIndex, Vararg{Any}})
     @_inline_meta
     Δi = I[1]-first(IP[1])
-    compute_linindex(f + Δi*s, s*unsafe_length(IP[1]), tail(IP), tail(I))
+    compute_linindex(f + Δi*s, s*length(IP[1]), tail(IP), tail(I))
 end
 function compute_linindex(f, s, IP::Tuple, I::Tuple{Any, Vararg{Any}})
     @_inline_meta
     Δi = first(I[1])-first(IP[1])
-    compute_linindex(f + Δi*s, s*unsafe_length(IP[1]), tail(IP), tail(I))
+    compute_linindex(f + Δi*s, s*length(IP[1]), tail(IP), tail(I))
 end
 compute_linindex(f, s, IP::Tuple, I::Tuple{}) = f
 
@@ -307,7 +307,7 @@ _indices_sub(S::SubQuasiArray) = ()
 _indices_sub(S::SubQuasiArray, ::Number, I...) = (@_inline_meta; _indices_sub(S, I...))
 function _indices_sub(S::SubQuasiArray, i1::Union{AbstractQuasiArray,AbstractArray}, I...)
     @_inline_meta
-    (unsafe_indices(i1)..., _indices_sub(S, I...)...)
+    (axes(i1)..., _indices_sub(S, I...)...)
 end
 
 @propagate_inbounds maybeview(A::AbstractQuasiArray, args...) = view(A, args...)

test/test_quasiadjtrans.jl

@@ -8,16 +8,6 @@ import QuasiArrays: MemoryLayout
 @testset "QuasiAdjoint/Transpose" begin
     @testset "Adjoint and Transpose inner constructor basics" begin
         intvec, intmat = QuasiVector([1, 2],0:0.5:0.5), QuasiArray([1 2; 3 4],(0:0.5:0.5,0:0.5:0.5))
-        # Adjoint/Transpose eltype must match the type of the Adjoint/Transpose of the input eltype
-        @test_throws ErrorException QuasiAdjoint{Float64,typeof(intvec)}(intvec)
-        @test_throws ErrorException QuasiAdjoint{Float64,typeof(intmat)}(intmat)
-        @test_throws ErrorException QuasiTranspose{Float64,typeof(intvec)}(intvec)
-        @test_throws ErrorException QuasiTranspose{Float64,typeof(intmat)}(intmat)
-        # Adjoint/Transpose wrapped array type must match the input array type
-        @test_throws MethodError QuasiAdjoint{Int,Vector{Float64}}(intvec)
-        @test_throws MethodError QuasiAdjoint{Int,Matrix{Float64}}(intmat)
-        @test_throws MethodError QuasiTranspose{Int,Vector{Float64}}(intvec)
-        @test_throws MethodError QuasiTranspose{Int,Matrix{Float64}}(intmat)
         # Adjoint/Transpose inner constructor basic functionality, concrete scalar eltype
         @test (QuasiAdjoint{Int,typeof(intvec)}(intvec)::QuasiAdjoint{Int,typeof(intvec)}).parent === intvec
         @test (QuasiAdjoint{Int,typeof(intmat)}(intmat)::QuasiAdjoint{Int,typeof(intmat)}).parent === intmat

test/test_quasisubarray.jl

@@ -300,7 +300,11 @@ using QuasiArrays, Base64, Test
     @testset "Show" begin
         a = QuasiVector(randn(3), 0:0.5:1)
         v = view(a, :)
-        @test stringmime("text/plain", v) == "view(QuasiVector{Float64, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Inclusion(0.0:0.5:1.0)) with eltype Float64"
+        if VERSION < v"1.7-"
+            @test stringmime("text/plain", v) == "view(QuasiVector{Float64, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}}, Inclusion(0.0:0.5:1.0)) with eltype Float64"
+        else
+            @test stringmime("text/plain", v) == "view(QuasiVector{Float64, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, $Int}}}, Inclusion(0.0:0.5:1.0)) with eltype Float64"
+        end
     end
 
     @testset "==" begin