Test code quality, resolve ambiguities (#355)

Author: dkarrasch

Project.toml

@@ -7,13 +7,15 @@ Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
-SuiteSparse_jll = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
+
+[compat]
 
 [extras]
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Dates", "InteractiveUtils", "Printf", "Test"]
+test = ["Aqua", "Dates", "InteractiveUtils", "Printf", "Test"]

src/abstractsparse.jl

@@ -76,6 +76,7 @@ issparse(A::DenseArray) = false
 issparse(S::AbstractSparseArray) = true
 
 indtype(S::AbstractSparseArray{<:Any,Ti}) where {Ti} = Ti
+indtype(T::UpperOrLowerTriangular{<:Any,<:AbstractSparseArray}) = indtype(parent(T))
 
 # The following two methods should be overloaded by concrete types to avoid
 # allocating the I = findall(...)

src/linalg.jl

@@ -169,10 +169,9 @@ const SparseOrTri{Tv,Ti} = Union{SparseMatrixCSCUnion{Tv,Ti},SparseTriangular{Tv
 # done by a quicksort of the row indices or by a full scan of the dense result vector.
 # The last is faster, if more than ≈ 1/32 of the result column is nonzero.
 # TODO: extend to SparseMatrixCSCUnion to allow for SubArrays (view(X, :, r)).
-function spmatmul(A::SparseOrTri{TvA,TiA}, B::Union{SparseOrTri{TvB,TiB},SparseVectorUnion{TvB,TiB},SubArray{TvB,<:Any,<:AbstractSparseArray{TvB,TiB}}}) where {TvA,TiA,TvB,TiB}
-
-    Tv = promote_op(matprod, TvA, TvB)
-    Ti = promote_type(TiA, TiB)
+function spmatmul(A::SparseOrTri, B::Union{SparseOrTri,SparseVectorUnion,SubArray{<:Any,<:Any,<:AbstractSparseArray}})
+    Tv = promote_op(matprod, eltype(A), eltype(B))
+    Ti = promote_type(indtype(A), indtype(B))
     mA, nA = size(A)
     nB = size(B, 2)
     nA == size(B, 1) || throw(DimensionMismatch())
@@ -375,8 +374,8 @@ const WrapperMatrixTypes{T,MT} = Union{
     Hermitian{T,MT},
 }
 
-function dot(A::MA, B::AbstractSparseMatrixCSC{TB}) where {MA<:Union{DenseMatrixUnion,WrapperMatrixTypes{<:Any,Union{DenseMatrixUnion,AbstractSparseMatrix}}},TB}
-    T = promote_type(eltype(A), TB)
+function dot(A::Union{DenseMatrixUnion,WrapperMatrixTypes{<:Any,Union{DenseMatrixUnion,AbstractSparseMatrix}}}, B::AbstractSparseMatrixCSC)
+    T = promote_type(eltype(A), eltype(B))
     (m, n) = size(A)
     if (m, n) != size(B)
         throw(DimensionMismatch())
@@ -397,7 +396,7 @@ function dot(A::MA, B::AbstractSparseMatrixCSC{TB}) where {MA<:Union{DenseMatrix
     return s
 end
 
-function dot(A::AbstractSparseMatrixCSC{TA}, B::MB) where {TA,MB<:Union{DenseMatrixUnion,WrapperMatrixTypes{<:Any,Union{DenseMatrixUnion,AbstractSparseMatrix}}}}
+function dot(A::AbstractSparseMatrixCSC, B::Union{DenseMatrixUnion,WrapperMatrixTypes{<:Any,Union{DenseMatrixUnion,AbstractSparseMatrix}}})
     return conj(dot(B, A))
 end
 
@@ -1315,19 +1314,19 @@ function opnormestinv(A::AbstractSparseMatrixCSC{T}, t::Integer = min(2,maximum(
 end
 
 ## kron
-const _SparseArraysCSC{T} = Union{SparseVector{T}, AbstractSparseMatrixCSC{T}}
-const _SparseKronArrays = Union{_SparseArrays, AdjOrTrans{<:Any,<:_SparseArraysCSC}}
+const _SparseArraysCSC = Union{AbstractCompressedVector, AbstractSparseMatrixCSC}
+const _SparseKronArrays = Union{_SparseArraysCSC, AdjOrTrans{<:Any,<:_SparseArraysCSC}}
 
-const _Symmetric_SparseKronArrays{T,A<:_SparseKronArrays} = Symmetric{T,A}
-const _Hermitian_SparseKronArrays{T,A<:_SparseKronArrays} = Hermitian{T,A}
-const _Triangular_SparseKronArrays{T,A<:_SparseKronArrays} = UpperOrLowerTriangular{T,A}
+const _Symmetric_SparseKronArrays = Symmetric{<:Any,<:_SparseKronArrays}
+const _Hermitian_SparseKronArrays = Hermitian{<:Any,<:_SparseKronArrays}
+const _Triangular_SparseKronArrays = UpperOrLowerTriangular{<:Any,<:_SparseKronArrays}
 const _Annotated_SparseKronArrays = Union{_Triangular_SparseKronArrays, _Symmetric_SparseKronArrays, _Hermitian_SparseKronArrays}
 const _SparseKronGroup = Union{_SparseKronArrays, _Annotated_SparseKronArrays}
 
 @inline function kron!(C::SparseMatrixCSC, A::AbstractSparseMatrixCSC, B::AbstractSparseMatrixCSC)
     mA, nA = size(A); mB, nB = size(B)
     mC, nC = mA*mB, nA*nB
-    @boundscheck size(C) == (mC, nC) || throw(DimensionMismatch("target matrix needs to have size ($mC, $nC)," * 
+    @boundscheck size(C) == (mC, nC) || throw(DimensionMismatch("target matrix needs to have size ($mC, $nC)," *
         " but has size $(size(C))"))
     rowvalC = rowvals(C)
     nzvalC = nonzeros(C)
@@ -1393,6 +1392,8 @@ kron!(C::SparseMatrixCSC, A::_SparseKronGroup, B::Diagonal) =
     kron!(C, convert(SparseMatrixCSC, A), convert(SparseMatrixCSC, B))
 kron!(C::SparseMatrixCSC, A::Diagonal, B::_SparseKronGroup) =
     kron!(C, convert(SparseMatrixCSC, A), convert(SparseMatrixCSC, B))
+kron!(C::SparseMatrixCSC, A::AbstractCompressedVector, B::AdjOrTrans{<:Any,<:AbstractCompressedVector}) =
+    broadcast!(*, C, A, B)
 kron!(c::SparseMatrixCSC, a::Number, b::_SparseKronGroup) = mul!(c, a, b)
 kron!(c::SparseMatrixCSC, a::_SparseKronGroup, b::Number) = mul!(c, a, b)
 
@@ -1406,7 +1407,7 @@ function kron(A::AbstractSparseMatrixCSC, B::AbstractSparseMatrixCSC)
     sizehint!(C, nnz(A)*nnz(B))
     return @inbounds kron!(C, A, B)
 end
-function kron(x::SparseVector, y::SparseVector)
+function kron(x::AbstractCompressedVector, y::AbstractCompressedVector)
     nnzx, nnzy = nnz(x), nnz(y)
     nnzz = nnzx*nnzy # number of nonzeros in new vector
     nzind = Vector{promote_type(indtype(x), indtype(y))}(undef, nnzz) # the indices of nonzeros
@@ -1421,6 +1422,7 @@ kron(A::_SparseKronGroup, B::_DenseConcatGroup) = kron(A, sparse(B))
 kron(A::_DenseConcatGroup, B::_SparseKronGroup) = kron(sparse(A), B)
 kron(A::SparseVectorUnion, B::AdjOrTransSparseVectorUnion) = A .* B
 # disambiguation
+kron(A::AbstractCompressedVector, B::AdjOrTrans{<:Any,<:AbstractCompressedVector}) = A .* B
 kron(a::Number, b::_SparseKronGroup) = a * b
 kron(a::_SparseKronGroup, b::Number) = a * b
 

src/readonly.jl

@@ -35,5 +35,8 @@ Base.copy(x::ReadOnly) = ReadOnly(copy(parent(x)))
 (==)(x::ReadOnly, y::AbstractVector) = parent(x) == y
 (==)(x::AbstractVector, y::ReadOnly) = x == parent(y)
 (==)(x::ReadOnly, y::ReadOnly) = parent(x) == parent(y)
+# disambiguation
+(==)(x::ReadOnly{T,1,<:AbstractVector{T}}, y::ReadOnly{S,1,<:AbstractVector{S}}) where {T,S} =
+    parent(x) == parent(y)
 
 Base.dataids(::ReadOnly) = tuple()

src/solvers/spqr.jl

@@ -5,7 +5,7 @@ module SPQR
 import Base: \, *
 using Base: require_one_based_indexing
 using LinearAlgebra
-using LinearAlgebra: AbstractQ, AdjointQ, copy_similar
+using LinearAlgebra: AbstractQ, AdjointQ, AdjointAbsVec, copy_similar
 using ..LibSuiteSparse: SuiteSparseQR_C
 
 # ordering options */
@@ -322,6 +322,7 @@ function (*)(A::AbstractMatrix, adjQ::AdjointQ{<:Any,<:QRSparseQ})
         throw(DimensionMismatch("matrix A has dimensions $(size(A)) but Q-matrix has dimensions $(size(adjQ))"))
     end
 end
+(*)(u::AdjointAbsVec, Q::AdjointQ{<:Any,<:QRSparseQ}) = (Q'u')'
 
 (*)(Q::QRSparseQ, B::SparseMatrixCSC) = sparse(Q) * B
 (*)(A::SparseMatrixCSC, Q::QRSparseQ) = A * sparse(Q)

src/sparsevector.jl

@@ -85,15 +85,17 @@ _unsafe_unfix(s::FixedSparseVector) = SparseVector(length(s), parent(nonzeroinds
 
 # Define an alias for a view of a whole column of a SparseMatrixCSC. Many methods can be written for the
 # union of such a view and a SparseVector so we define an alias for such a union as well
-const SparseColumnView{Tv,Ti}  = SubArray{Tv,1,<:AbstractSparseMatrixCSC{Tv,Ti},Tuple{Base.Slice{Base.OneTo{Int}},Int},false}
-const SparseVectorView{Tv,Ti}  = SubArray{Tv,1,<:AbstractSparseVector{Tv,Ti},Tuple{Base.Slice{Base.OneTo{Int}}},false}
-const SparseVectorUnion{Tv,Ti} = Union{AbstractCompressedVector{Tv,Ti}, SparseColumnView{Tv,Ti}, SparseVectorView{Tv,Ti}}
-const AdjOrTransSparseVectorUnion{Tv,Ti} = LinearAlgebra.AdjOrTrans{Tv, <:SparseVectorUnion{Tv,Ti}}
-const SVorFSV{Tv,Ti} = Union{SparseVector{Tv,Ti},FixedSparseVector{Tv,Ti}}
+const SparseColumnView = SubArray{<:Any,1,<:AbstractSparseMatrixCSC,Tuple{Base.Slice{Base.OneTo{Int}},Int},false}
+const SparseVectorView = SubArray{<:Any,1,<:AbstractSparseVector,Tuple{Base.Slice{Base.OneTo{Int}}},false}
+const SparseVectorUnion = Union{AbstractCompressedVector, SparseColumnView, SparseVectorView}
+const AdjOrTransSparseVectorUnion = AdjOrTrans{<:Any,<:SparseVectorUnion}
+
 ### Basic properties
 
-length(x::SVorFSV)   = getfield(x, :n)
-size(x::SVorFSV)     = (getfield(x, :n),)
+length(x::SparseVector) = getfield(x, :n)
+length(x::FixedSparseVector) = getfield(x, :n)
+size(x::SparseVector) = (getfield(x, :n),)
+size(x::FixedSparseVector) = (getfield(x, :n),)
 
 function Base._simple_count(f, x::AbstractCompressedVector, init::T) where T
     init + T(count(f, nonzeros(x)) + f(zero(eltype(x)))*(length(x) - nnz(x)))
@@ -118,7 +120,8 @@ function nzrange(x::SparseVectorUnion, j::Integer)
     j == 1 ? (1:nnz(x)) : throw(BoundsError(x, (":", j)))
 end
 
-nonzeros(x::SVorFSV) = getfield(x, :nzval)
+nonzeros(x::SparseVector) = getfield(x, :nzval)
+nonzeros(x::FixedSparseVector) = getfield(x, :nzval)
 function nonzeros(x::SparseColumnView)
     rowidx, colidx = parentindices(x)
     A = parent(x)
@@ -127,7 +130,8 @@ function nonzeros(x::SparseColumnView)
 end
 nonzeros(x::SparseVectorView) = nonzeros(parent(x))
 
-nonzeroinds(x::SVorFSV) = getfield(x, :nzind)
+nonzeroinds(x::SparseVector) = getfield(x, :nzind)
+nonzeroinds(x::FixedSparseVector) = getfield(x, :nzind)
 function nonzeroinds(x::SparseColumnView)
     rowidx, colidx = parentindices(x)
     A = parent(x)
@@ -802,12 +806,12 @@ function findall(x::SparseVectorUnion)
     return findall(identity, x)
 end
 
-function findall(p::F, x::SparseVectorUnion{<:Any,Ti}) where {Ti,F<:Function}
+function findall(p::F, x::SparseVectorUnion) where {F<:Function}
     if p(zero(eltype(x)))
         return invoke(findall, Tuple{Function, Any}, p, x)
     end
     numnz = nnz(x)
-    I = Vector{Ti}(undef, numnz)
+    I = Vector{indtype(x)}(undef, numnz)
 
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
@@ -827,7 +831,7 @@ function findall(p::F, x::SparseVectorUnion{<:Any,Ti}) where {Ti,F<:Function}
 
     return I
 end
-findall(p::Base.Fix2{typeof(in)}, x::SparseVectorUnion{<:Any,Ti}) where {Ti} =
+findall(p::Base.Fix2{typeof(in)}, x::SparseVectorUnion) =
     invoke(findall, Tuple{Base.Fix2{typeof(in)}, AbstractArray}, p, x)
 
 """
@@ -849,11 +853,11 @@ julia> findnz(x)
 ([1, 4, 6, 8], [1, 2, 4, 3])
 ```
 """
-function findnz(x::SparseVectorUnion{Tv,Ti}) where {Tv,Ti}
+function findnz(x::SparseVectorUnion)
     numnz = nnz(x)
 
-    I = Vector{Ti}(undef, numnz)
-    V = Vector{Tv}(undef, numnz)
+    I = Vector{indtype(x)}(undef, numnz)
+    V = Vector{eltype(x)}(undef, numnz)
 
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
@@ -1095,13 +1099,13 @@ complex(x::AbstractSparseVector) =
 
 ### Concatenation
 
-# Without the first of these methods, horizontal concatenations of SparseVectors fall
-# back to the horizontal concatenation method that ensures that combinations of
-# sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs, instead
-# of _absspvec_hcat below. The <:Integer qualifications are necessary for correct dispatch.
-hcat(X::SparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_hcat(X...)
-hcat(X::FixedSparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_hcat(X...)
-hcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_hcat(X...)
+function hcat(Xin::AbstractSparseVector...)
+    X = map(_unsafe_unfix, Xin)
+    Tv = promote_type(map(eltype, X)...)
+    Ti = promote_type(map(indtype, X)...)
+    r = _absspvec_hcat(map(x -> convert(SparseVector{Tv,Ti}, x), X)...)
+    return @if_move_fixed Xin... r
+end
 function _absspvec_hcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti}
     # check sizes
     n = length(X)
@@ -1128,24 +1132,15 @@ function _absspvec_hcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti}
         roff += length(xnzind)
     end
     colptr[n+1] = roff
-    r = SparseMatrixCSC{Tv,Ti}(m, n, colptr, nzrow, nzval)
-    return @if_move_fixed X... r
+    return SparseMatrixCSC{Tv,Ti}(m, n, colptr, nzrow, nzval)
 end
 
-# Without the first of these methods, vertical concatenations of SparseVectors fall
-# back to the vertical concatenation method that ensures that combinations of
-# sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs, instead
-# of _absspvec_vcat below. The <:Integer qualifications are necessary for correct dispatch.
-vcat(X::SparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_vcat(X...)
-vcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti<:Integer} = _absspvec_vcat(X...)
-function vcat(X::SparseVector...)
-    commeltype = promote_type(map(eltype, X)...)
-    commindtype = promote_type(map(indtype, X)...)
-    return vcat(map(x -> SparseVector{commeltype,commindtype}(x), X)...)
-end
-function vcat(X::SVorFSV...)
-    r = vcat(map(_unsafe_unfix, X)...)
-    return @if_move_fixed X r
+function vcat(Xin::AbstractSparseVector...)
+    X = map(_unsafe_unfix, Xin)
+    Tv = promote_type(map(eltype, X)...)
+    Ti = promote_type(map(indtype, X)...)
+    r = _absspvec_vcat(map(x -> convert(SparseVector{Tv,Ti}, x), X)...)
+    return @if_move_fixed Xin... r
 end
 function _absspvec_vcat(X::AbstractSparseVector{Tv,Ti}...) where {Tv,Ti}
     # check sizes
@@ -1177,22 +1172,18 @@ end
 
 hcat(Xin::Union{Vector, AbstractSparseVector}...) = hcat(map(sparse, Xin)...)
 vcat(Xin::Union{Vector, AbstractSparseVector}...) = vcat(map(sparse, Xin)...)
-# Without the following method, vertical concatenations of SparseVectors with Vectors
-# fall back to the vertical concatenation method that ensures that combinations of
-# sparse/special/dense matrix/vector types concatenate to SparseMatrixCSCs (because
-# the vcat method immediately above is less specific, being defined in AbstractSparseVector
-# rather than SparseVector).
-vcat(X::Union{Vector,AbstractCompressedVector}...) = vcat(map(sparse, X)...)
-
 
 ### Concatenation of un/annotated sparse/special/dense vectors/matrices
 
-const _SparseArrays = Union{SparseVector, AbstractSparseMatrixCSC, Adjoint{<:Any,<:SparseVector}, Transpose{<:Any,<:SparseVector}}
+const _SparseArrays = Union{AbstractSparseVector,
+                            AbstractSparseMatrixCSC,
+                            Adjoint{<:Any,<:AbstractSparseVector},
+                            Transpose{<:Any,<:AbstractSparseVector}}
 const _SparseConcatArrays = Union{_SpecialArrays, _SparseArrays}
 
-const _Symmetric_SparseConcatArrays{T,A<:_SparseConcatArrays} = Symmetric{T,A}
-const _Hermitian_SparseConcatArrays{T,A<:_SparseConcatArrays} = Hermitian{T,A}
-const _Triangular_SparseConcatArrays{T,A<:_SparseConcatArrays} = UpperOrLowerTriangular{T,A}
+const _Symmetric_SparseConcatArrays = Symmetric{<:Any,<:_SparseConcatArrays}
+const _Hermitian_SparseConcatArrays = Hermitian{<:Any,<:_SparseConcatArrays}
+const _Triangular_SparseConcatArrays = UpperOrLowerTriangular{<:Any,<:_SparseConcatArrays}
 const _Annotated_SparseConcatArrays = Union{_Triangular_SparseConcatArrays, _Symmetric_SparseConcatArrays, _Hermitian_SparseConcatArrays}
 # It's important that _SparseConcatGroup is a larger union than _DenseConcatGroup to make
 # sparse cat-methods less specific and to kick in only if there is some sparse array present
@@ -1548,7 +1539,8 @@ end
 Base.reducedim_initarray(A::SparseVectorUnion, region, v0, ::Type{R}) where {R} =
     fill!(Array{R}(undef, Base.to_shape(Base.reduced_indices(A, region))), v0)
 
-function Base._mapreduce(f, op, ::IndexCartesian, A::SparseVectorUnion{T}) where {T}
+function Base._mapreduce(f, op, ::IndexCartesian, A::SparseVectorUnion)
+    T = eltype(A)
     isempty(A) && return Base.mapreduce_empty(f, op, T)
     z = nnz(A)
     rest, ini = if z == 0
@@ -1671,26 +1663,26 @@ end
 (/)(x::SparseVectorUnion, a::Number) =
     @if_move_fixed x SparseVector(length(x), copy(nonzeroinds(x)), nonzeros(x) / a)
 # dot
-function dot(x::AbstractVector{Tx}, y::SparseVectorUnion{Ty}) where {Tx<:Number,Ty<:Number}
+function dot(x::AbstractVector, y::SparseVectorUnion)
     require_one_based_indexing(x, y)
     n = length(x)
     length(y) == n || throw(DimensionMismatch())
     nzind = nonzeroinds(y)
     nzval = nonzeros(y)
-    s = dot(zero(Tx), zero(Ty))
+    s = dot(zero(eltype(x)), zero(eltype(y)))
     @inbounds for i = 1:length(nzind)
         s += dot(x[nzind[i]], nzval[i])
     end
     return s
 end
 
-function dot(x::SparseVectorUnion{Tx}, y::AbstractVector{Ty}) where {Tx<:Number,Ty<:Number}
+function dot(x::SparseVectorUnion, y::AbstractVector)
     require_one_based_indexing(x, y)
     n = length(y)
     length(x) == n || throw(DimensionMismatch())
     nzind = nonzeroinds(x)
     nzval = nonzeros(x)
-    s = dot(zero(Tx), zero(Ty))
+    s = dot(zero(eltype(x)), zero(eltype(y)))
     @inbounds for i = 1:length(nzind)
         s += dot(nzval[i], y[nzind[i]])
     end
@@ -1718,7 +1710,7 @@ function _spdot(f::Function,
     s
 end
 
-function dot(x::SparseVectorUnion{<:Number}, y::SparseVectorUnion{<:Number})
+function dot(x::SparseVectorUnion, y::SparseVectorUnion)
     x === y && return sum(abs2, x)
     n = length(x)
     length(y) == n || throw(DimensionMismatch())

test/ambiguous.jl

@@ -1,5 +1,33 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
-using Test, LinearAlgebra, SparseArrays
+using Test, LinearAlgebra, SparseArrays, Aqua
+
+@testset "code quality" begin
+    @testset "Method ambiguity" begin
+        # Aqua.test_ambiguities([SparseArrays, Base, Core])
+    end
+    @testset "Unbound type parameters" begin
+        @test_broken Aqua.detect_unbound_args_recursively(SparseArrays) == []
+    end
+    @testset "Undefined exports" begin
+        Aqua.test_undefined_exports(SparseArrays) == []
+    end
+    @testset "Compare Project.toml and test/Project.toml" begin
+        Aqua.test_project_extras(SparseArrays)
+    end
+    @testset "Stale dependencies" begin
+        Aqua.test_stale_deps(SparseArrays)
+    end
+    @testset "Compat bounds" begin
+        Aqua.test_deps_compat(SparseArrays)
+    end
+    @testset "Project.toml formatting" begin
+        Aqua.test_project_toml_formatting(SparseArrays)
+    end
+    @testset "Piracy" begin
+        @test_broken Aqua.Piracy.hunt(SparseArrays) == Method[]
+    end
+end
+
 @testset "detect_ambiguities" begin
     @test_nowarn detect_ambiguities(SparseArrays; recursive=true, ambiguous_bottom=false)
 end