Julia v1.8 Support (#82)

* Branch with segfault on 1.8

* Tests pass on 1.8

Author: dlfivefifty

.github/workflows/ci.yml

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

Project.toml

@@ -1,7 +1,7 @@
 name = "QuasiArrays"
 uuid = "c4ea9172-b204-11e9-377d-29865faadc5c"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.9"
+version = "0.9.1"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -12,9 +12,9 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
-ArrayLayouts = "0.7.6"
+ArrayLayouts = "0.7.6, 0.8"
 DomainSets = "0.5"
-FillArrays = "0.12"
+FillArrays = "0.12, 0.13"
 LazyArrays = "0.22.2"
 StaticArrays = "1"
 julia = "1.6"

src/QuasiArrays.jl

@@ -36,7 +36,7 @@ import Base.Broadcast: materialize, materialize!, BroadcastStyle, AbstractArrayS
                         newindex, broadcastable, preprocess, _eachindex, _broadcast_getindex, broadcast_shape,
                         DefaultArrayStyle, axistype, throwdm, instantiate, combine_eltypes, eltypes, combine_styles
 
-import LinearAlgebra: transpose, adjoint, checkeltype_adjoint, checkeltype_transpose, Diagonal,
+import LinearAlgebra: transpose, adjoint, Diagonal,
                         AbstractTriangular, pinv, inv, promote_leaf_eltypes, power_by_squaring,
                         integerpow, schurpow, tr, factorize, copy_oftype, rank, dot
 

src/abstractquasiarray.jl

@@ -295,12 +295,9 @@ similar(a::AbstractQuasiArray, ::Type{T}) where {T}                     = simila
 similar(a::AbstractQuasiArray{T}, dims::Tuple) where {T}                = similar(a, T, dims)
 similar(a::AbstractQuasiArray{T}, dims::QuasiDimOrInd...) where {T}          = similar(a, T, dims)
 similar(a::AbstractQuasiArray, ::Type{T}, dims::QuasiDimOrInd...) where {T}  = similar(a, T, dims)
-similar(::Type{<:AbstractQuasiArray{T}}, shape::NTuple{N,AbstractQuasiOrVector}) where {N,T} =
-    QuasiArray{T,N}(undef, convert.(AbstractVector, shape))
-similar(a::AbstractQuasiArray, ::Type{T}, dims::NTuple{N,AbstractQuasiOrVector}) where {T,N} =
-    QuasiArray{T,N}(undef, convert.(AbstractVector, dims))
-similar(a::AbstractQuasiArray, ::Type{T}, dims::Vararg{AbstractQuasiOrVector,N}) where {T,N} =
-    QuasiArray{T,N}(undef, convert.(AbstractVector, dims))
+similar(::Type{<:AbstractQuasiArray{T}}, shape::NTuple{N,AbstractQuasiOrVector}) where {N,T} = QuasiArray{T,N}(undef, shape)
+similar(a::AbstractQuasiArray, ::Type{T}, dims::NTuple{N,AbstractQuasiOrVector}) where {T,N} = QuasiArray{T,N}(undef, dims)
+similar(a::AbstractQuasiArray, ::Type{T}, dims::Vararg{AbstractQuasiOrVector,N}) where {T,N} = QuasiArray{T,N}(undef, dims)
 
 similar(a::AbstractQuasiArray{T}, m::Int) where {T}              = Vector{T}(undef, m)
 similar(a::AbstractQuasiArray, T::Type, dims::Dims{N}) where {N} = Array{T,N}(undef, dims)

src/indices.jl

@@ -169,6 +169,7 @@ copy(d::Inclusion) = d
 ==(A::Inclusion, B::Inclusion) = A.domain == B.domain
 domain(A::Inclusion) = A.domain
 domain(A::AbstractUnitRange) = A
+domain(A::IdentityUnitRange) = A.indices
 axes(S::Inclusion) = (S,)
 axes1(S::Inclusion) = S
 axes(S::Inclusion{<:Any,<:OneTo}) = (S.domain,)

src/quasiarray.jl

@@ -66,6 +66,13 @@ QuasiArray(par::AbstractArray) = QuasiArray(par, axes(par))
 QuasiMatrix(par::AbstractArray) = QuasiMatrix(par, axes(par))
 QuasiVector(par::AbstractArray) = QuasiVector(par, axes(par))
 
+QuasiArray{T,N,AXES}(::UndefInitializer, axes::NTuple{N,AbstractQuasiOrVector}) where {T,N,AXES} =
+    QuasiArray{T,N,AXES}(undef, map(domain,axes))
+QuasiArray{T,N}(::UndefInitializer, axes::NTuple{N,AbstractQuasiOrVector}) where {T,N} =
+    QuasiArray{T,N}(undef, map(domain,axes))    
+QuasiArray{T}(::UndefInitializer, axes::NTuple{N,AbstractQuasiOrVector}) where {T,N} =
+    QuasiArray{T}(undef, map(domain,axes))    
+
 QuasiArray{T,N,AXES}(par::AbstractArray{T,N}, axes::NTuple{N,AbstractQuasiOrVector}) where {T,N,AXES} =
     QuasiArray{T,N,AXES}(par, map(domain,axes))
 QuasiArray{T,N}(par::AbstractArray{T,N}, axes::NTuple{N,AbstractQuasiOrVector}) where {T,N} =
@@ -83,10 +90,10 @@ QuasiVector(par::AbstractVector{T}, axes::AbstractArray) where {T} =
     QuasiVector(par, (axes,))
 
 
-QuasiArray(a::AbstractQuasiArray{T}) where T = QuasiArray{T}(a[map(collect,axes(a))...], axes(a))
-QuasiArray{T}(a::AbstractQuasiArray) where T = QuasiArray(convert(AbstractArray{T},a[map(collect,axes(a))...]), axes(a))
-QuasiArray{T,N}(a::AbstractQuasiArray{<:Any,N}) where {T,N} = QuasiArray(convert(AbstractArray{T,N},a[map(collect,axes(a))...]), axes(a))
-QuasiArray{T,N,AXES}(a::AbstractQuasiArray{<:Any,N}) where {T,N,AXES} = QuasiArray{T,N,AXES}(Array{T}(a), axes(a))
+QuasiArray(a::AbstractQuasiArray{T}) where T = QuasiArray{T}(a[map(collect,axes(a))...], map(domain,axes(a)))
+QuasiArray{T}(a::AbstractQuasiArray) where T = QuasiArray(convert(AbstractArray{T},a[map(collect,axes(a))...]), map(domain,axes(a)))
+QuasiArray{T,N}(a::AbstractQuasiArray{<:Any,N}) where {T,N} = QuasiArray(convert(AbstractArray{T,N},a[map(collect,axes(a))...]), map(domain,axes(a)))
+QuasiArray{T,N,AXES}(a::AbstractQuasiArray{<:Any,N}) where {T,N,AXES} = QuasiArray{T,N,AXES}(Array{T}(a), map(domain,axes(a)))
 QuasiMatrix(a::AbstractQuasiMatrix) = QuasiArray(a)
 QuasiVector(a::AbstractQuasiVector) = QuasiArray(a)