re-arrange tests to test all subpackages locally and pass

Author: ChrisRackauckas

Project.toml

@@ -16,3 +16,9 @@ IfElse = "0.1"
 Static = "0.6"
 julia = "1.6"
 
+[extras]
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Pkg", "Test"]

lib/ArrayInterfaceBandedMatrices/Project.toml

@@ -12,9 +12,7 @@ BandedMatrices = "0.17"
 julia = "1.6"
 
 [extras]
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["ArrayInterfaceCore","BandedMatrices","Test"]
+test = ["Test"]

lib/ArrayInterfaceBandedMatrices/src/ArrayInterfaceBandedMatrices.jl

@@ -3,8 +3,6 @@ module ArrayInterfaceBandedMatrices
 using ArrayInterfaceCore
 using BandedMatrices
 
-const CanonicalInt = Union{Int,StaticInt}
-
 struct BandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     rowsize::Int

lib/ArrayInterfaceBlockBandedMatrices/Project.toml

@@ -17,10 +17,7 @@ BlockArrays = "0.16"
 julia = "1.6"
 
 [extras]
-ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
-BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["ArrayInterfaceCore","BlockArrays","BlockBandedMatrices","Test"]
+test = ["Test"]

lib/ArrayInterfaceBlockBandedMatrices/src/ArrayInterfaceBlockBandedMatrices.jl

@@ -5,8 +5,6 @@ using ArrayInterfaceBandedMatrices
 using BlockArrays
 using BlockBandedMatrices
 
-const CanonicalInt = Union{Int,StaticInt}
-
 struct BlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     refinds::Array{Int,1}

lib/ArrayInterfaceCUDA/src/ArrayInterfaceCUDA.jl

@@ -4,8 +4,6 @@ using Adapt
 using ArrayInterface
 using CUDA
 
-const CanonicalInt = Union{Int,StaticInt}
-
 ArrayInterface.fast_scalar_indexing(::Type{<:CUDA.CuArray}) = false
 @inline ArrayInterface.allowed_getindex(x::CUDA.CuArray, i...) = CUDA.@allowscalar(x[i...])
 @inline ArrayInterface.allowed_setindex!(x::CUDA.CuArray, v, i...) = (CUDA.@allowscalar(x[i...] = v))

lib/ArrayInterfaceCore/src/ArrayInterfaceCore.jl

@@ -40,16 +40,6 @@ parent_type(::Type{T}) where {T} = T
 parent_type(::Type{R}) where {S,T,A,N,R<:Base.ReinterpretArray{T,N,S,A}} = A
 parent_type(::Type{Diagonal{T,V}}) where {T,V} = V
 
-"""
-    has_parent(::Type{T}) -> StaticBool
-
-Returns `static(true)` if `parent_type(T)` a type unique to `T`.
-"""
-has_parent(x) = has_parent(typeof(x))
-has_parent(::Type{T}) where {T} = _has_parent(parent_type(T), T)
-_has_parent(::Type{T}, ::Type{T}) where {T} = False()
-_has_parent(::Type{T1}, ::Type{T2}) where {T1,T2} = True()
-
 """
     buffer(x)
 
@@ -370,151 +360,6 @@ end
 """
 can_avx(::Any) = false
 
-"""
-    insert(collection, index, item)
-
-Returns a new instance of `collection` with `item` inserted into at the given `index`.
-"""
-Base.@propagate_inbounds function insert(collection, index, item)
-    @boundscheck checkbounds(collection, index)
-    ret = similar(collection, length(collection) + 1)
-    @inbounds for i = firstindex(ret):(index-1)
-        ret[i] = collection[i]
-    end
-    @inbounds ret[index] = item
-    @inbounds for i = (index+1):lastindex(ret)
-        ret[i] = collection[i-1]
-    end
-    return ret
-end
-
-function insert(x::Tuple{Vararg{Any,N}}, index::Integer, item) where {N}
-    @boundscheck if !checkindex(Bool, StaticInt{1}():StaticInt{N}(), index)
-        throw(BoundsError(x, index))
-    end
-    return unsafe_insert(x, Int(index), item)
-end
-
-@inline function unsafe_insert(x::Tuple, i::Int, item)
-    if i === 1
-        return (item, x...)
-    else
-        return (first(x), unsafe_insert(tail(x), i - 1, item)...)
-    end
-end
-
-"""
-    deleteat(collection, index)
-
-Returns a new instance of `collection` with the item at the given `index` removed.
-"""
-Base.@propagate_inbounds function deleteat(collection::AbstractVector, index)
-    @boundscheck if !checkindex(Bool, eachindex(collection), index)
-        throw(BoundsError(collection, index))
-    end
-    return unsafe_deleteat(collection, index)
-end
-Base.@propagate_inbounds function deleteat(collection::Tuple{Vararg{Any,N}}, index) where {N}
-    @boundscheck if !checkindex(Bool, StaticInt{1}():StaticInt{N}(), index)
-        throw(BoundsError(collection, index))
-    end
-    return unsafe_deleteat(collection, index)
-end
-
-function unsafe_deleteat(src::AbstractVector, index::Integer)
-    dst = similar(src, length(src) - 1)
-    @inbounds for i in indices(dst)
-        if i < index
-            dst[i] = src[i]
-        else
-            dst[i] = src[i+1]
-        end
-    end
-    return dst
-end
-
-@inline function unsafe_deleteat(src::AbstractVector, inds::AbstractVector)
-    dst = similar(src, length(src) - length(inds))
-    dst_index = firstindex(dst)
-    @inbounds for src_index in indices(src)
-        if !in(src_index, inds)
-            dst[dst_index] = src[src_index]
-            dst_index += one(dst_index)
-        end
-    end
-    return dst
-end
-
-@inline function unsafe_deleteat(src::Tuple, inds::AbstractVector)
-    dst = Vector{eltype(src)}(undef, length(src) - length(inds))
-    dst_index = firstindex(dst)
-    @inbounds for src_index in OneTo(length(src))
-        if !in(src_index, inds)
-            dst[dst_index] = src[src_index]
-            dst_index += one(dst_index)
-        end
-    end
-    return Tuple(dst)
-end
-
-@inline unsafe_deleteat(x::Tuple{T}, i::Integer) where {T} = ()
-@inline unsafe_deleteat(x::Tuple{T1,T2}, i::Integer) where {T1,T2} =
-    isone(i) ? (x[2],) : (x[1],)
-@inline function unsafe_deleteat(x::Tuple, i::Integer)
-    if i === one(i)
-        return tail(x)
-    elseif i == length(x)
-        return Base.front(x)
-    else
-        return (first(x), unsafe_deleteat(tail(x), i - one(i))...)
-    end
-end
-
-"""
-    is_lazy_conjugate(::AbstractArray) -> Bool
-
-Determine if a given array will lazyily take complex conjugates, such as with `Adjoint`. This will work with
-nested wrappers, so long as there is no type in the chain of wrappers such that `parent_type(T) == T`
-
-Examples
-
-    julia> a = transpose([1 + im, 1-im]')
-    2×1 transpose(adjoint(::Vector{Complex{Int64}})) with eltype Complex{Int64}:
-     1 - 1im
-     1 + 1im
-
-    julia> ArrayInterfaceCore.is_lazy_conjugate(a)
-    True()
-
-    julia> b = a'
-    1×2 adjoint(transpose(adjoint(::Vector{Complex{Int64}}))) with eltype Complex{Int64}:
-     1+1im  1-1im
-
-    julia> ArrayInterfaceCore.is_lazy_conjugate(b)
-    False()
-
-"""
-is_lazy_conjugate(::T) where {T<:AbstractArray} = _is_lazy_conjugate(T, False())
-is_lazy_conjugate(::AbstractArray{<:Real}) = False()
-
-function _is_lazy_conjugate(::Type{T}, isconj) where {T<:AbstractArray}
-    Tp = parent_type(T)
-    if T !== Tp
-        _is_lazy_conjugate(Tp, isconj)
-    else
-        isconj
-    end
-end
-
-function _is_lazy_conjugate(::Type{T}, isconj) where {T<:Adjoint}
-    Tp = parent_type(T)
-    if T !== Tp
-        _is_lazy_conjugate(Tp, !isconj)
-    else
-        !isconj
-    end
-end
-
 """
     fast_scalar_indexing(::Type{T}) -> Bool