Fix explicit imports

Author: ChrisRackauckas

ext/LinearSolveSparseArraysExt.jl

@@ -4,9 +4,10 @@ using LinearSolve: LinearSolve, BLASELTYPES, pattern_changed, ArrayInterface,
                     @get_cacheval, CHOLMODFactorization, GenericFactorization, GenericLUFactorization,
                     KLUFactorization, LUFactorization, NormalCholeskyFactorization, OperatorAssumptions,
                     QRFactorization, RFLUFactorization, UMFPACKFactorization, solve
-using LinearAlgebra
-using SparseArrays
-using SparseArrays: AbstractSparseMatrixCSC, nonzeros, rowvals, getcolptr
+using LinearAlgebra: LinearAlgebra, I, Hermitian, Symmetric, cholesky, ldiv!, lu, lu!
+using SparseArrays: SparseArrays, AbstractSparseArray, AbstractSparseMatrixCSC, SparseMatrixCSC, 
+                    nonzeros, rowvals, getcolptr, sparse, sprand
+using Base: /, \, convert
 using SciMLBase: SciMLBase, LinearProblem, ReturnCode
 
 # Can't `using KLU` because cannot have a dependency in there without

src/KLU/klu.jl

@@ -1,15 +1,20 @@
 module KLU
 
-using SparseArrays
-using SparseArrays: SparseMatrixCSC
+using SparseArrays: SparseArrays, SparseMatrixCSC
 import SparseArrays: nnz
 
 export klu, klu!
 
 const libklu = :libklu
+const libsuitesparseconfig = :libsuitesparseconfig
+using Base: Ptr, Cvoid, Cint, Cdouble, Cchar, Csize_t
 include("wrappers.jl")
 
-import Base: (\), size, getproperty, setproperty!, propertynames, show
+import Base: (\), size, getproperty, setproperty!, propertynames, show,
+             copy, eachindex, view, sortperm, unsafe_load, zeros, convert, eltype,
+             length, parent, stride, finalizer, Complex, complex, imag, real, map!,
+             summary, println, oneunit, sizeof, isdefined, setfield!, getfield,
+             OutOfMemoryError, ArgumentError, OverflowError, ErrorException, DimensionMismatch
 
 # Convert from 1-based to 0-based indices
 function decrement!(A::AbstractArray{T}) where {T <: Integer}
@@ -29,7 +34,8 @@ function increment!(A::AbstractArray{T}) where {T <: Integer}
 end
 increment(A::AbstractArray{<:Integer}) = increment!(copy(A))
 
-using LinearAlgebra
+using LinearAlgebra: LinearAlgebra, ldiv!, Adjoint, Transpose, Factorization
+import LinearAlgebra: issuccess
 
 const AdjointFact = isdefined(LinearAlgebra, :AdjointFactorization) ?
                     LinearAlgebra.AdjointFactorization : Adjoint

src/LinearSolve.jl

@@ -11,7 +11,7 @@ using LinearAlgebra: LinearAlgebra, BlasInt, LU, Adjoint, BLAS, Bidiagonal, Bunc
                     ColumnNorm, Diagonal, Factorization, Hermitian, I, LAPACK, NoPivot, 
                     RowMaximum, RowNonZero, SymTridiagonal, Symmetric, Transpose, 
                     Tridiagonal, UniformScaling, axpby!, axpy!, bunchkaufman, bunchkaufman!,
-                    cholesky, cholesky!, diagind, dot, ldiv!, ldlt!, lu, lu!, mul!, norm,
+                    cholesky, cholesky!, diagind, dot, inv, ldiv!, ldlt!, lu, lu!, mul!, norm,
                     qr, qr!, svd, svd!
 using LazyArrays: @~, BroadcastArray
 using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator,
@@ -97,6 +97,11 @@ issparsematrix(A) = false
 make_SparseMatrixCSC(A) = nothing
 makeempty_SparseMatrixCSC(A) = nothing
 
+# Stub functions for SparseArrays - overridden in extension
+getcolptr(A) = error("SparseArrays extension not loaded")
+rowvals(A) = error("SparseArrays extension not loaded")
+nonzeros(A) = error("SparseArrays extension not loaded")
+
 EnumX.@enumx DefaultAlgorithmChoice begin
     LUFactorization
     QRFactorization

src/common.jl

@@ -207,7 +207,8 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm,
     elseif b isa Array
         copy(b)
     elseif issparsematrixcsc(b)
-        SparseMatrixCSC(size(b)..., getcolptr(b), rowvals(b), nonzeros(b))
+        # Extension must be loaded if issparsematrixcsc returns true
+        make_SparseMatrixCSC(b)
     else
         deepcopy(b)
     end

test/qa.jl

@@ -1,7 +1,5 @@
 using LinearSolve, Aqua
 using ExplicitImports
-using LinearAlgebra, Markdown, Reexport, DocStringExtensions, Libdl, SparseArrays
-import CommonSolve
 
 @testset "Aqua" begin
     Aqua.find_persistent_tasks_deps(LinearSolve)
@@ -17,16 +15,18 @@ end
 
 @testset "Explicit Imports" begin
     # Get extension modules that might be unanalyzable
-    klu_mod = try; Base.get_extension(LinearSolve, :LinearSolveSparseArraysExt).KLU; catch; nothing; end
+    klu_mod = try
+        Base.get_extension(LinearSolve, :LinearSolveSparseArraysExt).KLU
+    catch
+        nothing
+    end
     unanalyzable_mods = (LinearSolve.OperatorCondition, LinearSolve.DefaultAlgorithmChoice)
     if klu_mod !== nothing
         unanalyzable_mods = (unanalyzable_mods..., klu_mod)
     end
 
-    @test check_no_implicit_imports(
-        LinearSolve; skip = (Base, Core, SciMLBase, LinearAlgebra, SparseArrays, CommonSolve),
-        allow_unanalyzable = unanalyzable_mods
-    ) === nothing
+    @test check_no_implicit_imports(LinearSolve; skip = (Base, Core), 
+        allow_unanalyzable = unanalyzable_mods) === nothing
     @test check_no_stale_explicit_imports(LinearSolve; allow_unanalyzable = unanalyzable_mods) === nothing
     @test check_all_qualified_accesses_via_owners(LinearSolve) === nothing
 end