Update PR

Author: devmotion

ext/SparseArraysExt.jl

@@ -1,6 +1,6 @@
 module SparseArraysExt
 
-using DistributedArrays: DArray, localpart
+using DistributedArrays: DArray, SubDArray, SubOrDArray, localpart
 using DistributedArrays.Distributed: remotecall_fetch
 using SparseArrays: SparseArrays, nnz
 
@@ -11,4 +11,21 @@ function SparseArrays.nnz(A::DArray)
     return reduce(+, B)
 end
 
+# Fix method ambiguities
+# TODO: Improve efficiency?
+Base.copyto!(dest::SubOrDArray{<:Any,2}, src::SparseArrays.AbstractSparseMatrixCSC) = copyto!(dest, Matrix(src))
+@static if isdefined(SparseArrays, :CHOLMOD)
+    Base.copyto!(dest::SubOrDArray, src::SparseArrays.CHOLMOD.Dense) = copyto!(dest, Array(src))
+    Base.copyto!(dest::SubOrDArray{T}, src::SparseArrays.CHOLMOD.Dense{T}) where {T<:Union{Float32,Float64,ComplexF32,ComplexF64}} = copyto!(dest, Array(src))
+    Base.copyto!(dest::SubOrDArray{T,2}, src::SparseArrays.CHOLMOD.Dense{T}) where {T<:Union{Float32,Float64,ComplexF32,ComplexF64}} = copyto!(dest, Array(src))
+end
+
+# Fix method ambiguities
+for T in (:DArray, :SubDArray)
+    @eval begin
+        Base.:(==)(d1::$T{<:Any,1}, d2::SparseArrays.ReadOnly) = d1 == parent(d2)
+        Base.:(==)(d1::SparseArrays.ReadOnly, d2::$T{<:Any,1}) = parent(d1) == d2
+    end
+end
+
 end

src/DistributedArrays.jl

@@ -10,8 +10,6 @@ using Serialization: Serialization, AbstractSerializer, deserialize, serialize
 
 using Primes: factor
 
-import SparseArrays
-
 # DArray exports
 export DArray, SubDArray, SubOrDArray, @DArray
 export dzeros, dones, dfill, drand, drandn, distribute, localpart, localindices, ppeval

src/darray.jl

@@ -369,7 +369,7 @@ end
 
 # shortcut to set/get localparts of a distributed object
 Base.getindex(d::DArray, s::Symbol) = _getindex(d, s)
-Base.getindex(d::DistributedArrays.DArray{<:Any, 1}, s::Symbol) = _getindex(d, s)
+Base.getindex(d::DArray{<:Any, 1}, s::Symbol) = _getindex(d, s)
 function _getindex(d::DArray, s::Symbol)
     @assert s in [:L, :l, :LP, :lp]
     return localpart(d)
@@ -440,14 +440,6 @@ function Base.:(==)(d1::SubDArray, d2::SubDArray)
     return t
 end
 
-# Fix method ambiguities
-for T in (:DArray, :SubDArray)
-    @eval begin
-        Base.:(==)(d1::$T{<:Any,1}, d2::SparseArrays.ReadOnly) = d1 == parent(d2)
-        Base.:(==)(d1::SparseArrays.ReadOnly, d2::$T{<:Any,1}) = parent(d1) == d2
-    end
-end
-
 """
     locate(d::DArray, I::Int...)
 
@@ -664,9 +656,6 @@ function Base.getindex(d::DArray{<:Any,N}, i::Vararg{Int,N}) where {N}
     _scalarindexingallowed()
     return getindex_tuple(d, i)
 end
-function Base.getindex(d::DArray{<:Any,N}, I::Vararg{Any,N}) where {N}
-    return view(d, I...)
-end                                                
 Base.getindex(d::DArray) = d[1]
 Base.getindex(d::SubDArray, I::Int...) = invoke(getindex, Tuple{SubArray{<:Any,N},Vararg{Int,N}} where N, d, I...)
 Base.getindex(d::SubOrDArray, I::Union{Int,UnitRange{Int},Colon,Vector{Int},StepRange{Int,Int}}...) = view(d, I...)
@@ -697,15 +686,6 @@ function Base.copyto!(dest::SubOrDArray, src::AbstractArray)
     return dest
 end
 
-# Fix method ambiguities
-# TODO: Improve efficiency?
-Base.copyto!(dest::SubOrDArray{<:Any,2}, src::SparseArrays.AbstractSparseMatrixCSC) = copyto!(dest, Matrix(src))
-@static if isdefined(SparseArrays, :CHOLMOD)
-    Base.copyto!(dest::SubOrDArray, src::SparseArrays.CHOLMOD.Dense) = copyto!(dest, Array(src))
-    Base.copyto!(dest::SubOrDArray{T}, src::SparseArrays.CHOLMOD.Dense{T}) where {T<:Union{Float32,Float64,ComplexF32,ComplexF64}} = copyto!(dest, Array(src))
-    Base.copyto!(dest::SubOrDArray{T,2}, src::SparseArrays.CHOLMOD.Dense{T}) where {T<:Union{Float32,Float64,ComplexF32,ComplexF64}} = copyto!(dest, Array(src))
-end
-
 function Base.deepcopy(src::DArray)
     dest = similar(src)
     @sync for p in procs(src)

src/spmd.jl

@@ -43,7 +43,7 @@ struct WorkerChannelDict
 end
 const WORKERCHANNELS = WorkerChannelDict()
 
-Base.get!(f, x::WorkerChannelDict, id::Int) = @lock x.lock get!(f, x.data, id)
+Base.get!(f::Function, x::WorkerChannelDict, id::Int) = @lock x.lock get!(f, x.data, id)
 
 # mapping between a context id and context object
 struct SPMDContextDict
@@ -54,7 +54,7 @@ end
 const CONTEXTS = SPMDContextDict()
 
 Base.delete!(x::SPMDContextDict, id::Tuple{Int,Int}) = @lock x.lock delete!(x.data, id)
-Base.get!(f, x::SPMDContextDict, id::Tuple{Int,Int}) = @lock x.lock get!(f, x.data, id)
+Base.get!(f::Function, x::SPMDContextDict, id::Tuple{Int,Int}) = @lock x.lock get!(f, x.data, id)
 
 function context_local_storage()
     ctxt = get_ctxt_from_id(task_local_storage(:SPMD_CTXT))

test/aqua.jl

@@ -2,5 +2,5 @@ using DistributedArrays, Test
 import Aqua
 
 @testset "Aqua" begin
-    Aqua.test_all(DistributedArrays)
+    Aqua.test_all(DistributedArrays; ambiguities = (; broken = true))
 end