Setup the codebase to use explicit imports

Author: ChrisRackauckas

Project.toml

@@ -77,6 +77,7 @@ ChainRulesCore = "1.22"
 ConcreteStructs = "0.2.3"
 DocStringExtensions = "0.9.3"
 EnumX = "1.0.4"
+ExplicitImports = "1"
 EnzymeCore = "0.8.1"
 FastAlmostBandedMatrices = "0.1"
 FastLapackInterface = "2"
@@ -122,6 +123,7 @@ julia = "1.10"
 [extras]
 AllocCheck = "9b6a8646-10ed-4001-bbdc-1d2f46dfbb1a"
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+ExplicitImports = "7d51a73a-1435-4ff3-83d9-f097790105c7"
 BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0"
 FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e"
@@ -150,4 +152,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [targets]
-test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "FastLapackInterface", "SparseArrays"]
+test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "FastLapackInterface", "SparseArrays", "ExplicitImports"]

ext/LinearSolveCUDAExt.jl

@@ -1,7 +1,9 @@
 module LinearSolveCUDAExt
 
 using CUDA
-using LinearSolve
+using LinearSolve: LinearSolve, is_cusparse, defaultalg, cudss_loaded, DefaultLinearSolver, 
+                   DefaultAlgorithmChoice, ALREADY_WARNED_CUDSS, LinearCache, needs_concrete_A,
+                   error_no_cudss_lu, CUDSS_LOADED, init_cacheval
 using LinearSolve.LinearAlgebra, LinearSolve.SciMLBase, LinearSolve.ArrayInterface
 using SciMLBase: AbstractSciMLOperator
 

ext/LinearSolveCUDSSExt.jl

@@ -1,6 +1,6 @@
 module LinearSolveCUDSSExt
 
-using LinearSolve
+using LinearSolve: LinearSolve, cudss_loaded
 using CUDSS
 
 LinearSolve.cudss_loaded(A::CUDSS.CUDA.CUSPARSE.CuSparseMatrixCSR) = true

ext/LinearSolveEnzymeExt.jl

@@ -1,6 +1,8 @@
 module LinearSolveEnzymeExt
 
-using LinearSolve
+using LinearSolve: LinearSolve, SciMLLinearSolveAlgorithm, init, solve!, LinearProblem, 
+                   LinearCache, AbstractKrylovSubspaceMethod, DefaultLinearSolver, 
+                   defaultalg_adjoint_eval
 using LinearSolve.LinearAlgebra
 using EnzymeCore
 using EnzymeCore: EnzymeRules

ext/LinearSolveRecursiveFactorizationExt.jl

@@ -1,7 +1,8 @@
 module LinearSolveRecursiveFactorizationExt
 
-using LinearSolve
+using LinearSolve: LinearSolve, userecursivefactorization, LinearCache, @get_cacheval, RFLUFactorization
 using LinearSolve.LinearAlgebra, LinearSolve.ArrayInterface, RecursiveFactorization
+using SciMLBase: SciMLBase, ReturnCode
 
 LinearSolve.userecursivefactorization(A::Union{Nothing, AbstractMatrix}) = true
 

ext/LinearSolveSparseArraysExt.jl

@@ -1,9 +1,13 @@
 module LinearSolveSparseArraysExt
 
-using LinearSolve, LinearAlgebra
+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 LinearSolve: BLASELTYPES, pattern_changed, ArrayInterface
+using SciMLBase: SciMLBase, LinearProblem, ReturnCode
 
 # Can't `using KLU` because cannot have a dependency in there without
 # requiring the user does `using KLU`

src/LinearSolve.jl

@@ -5,27 +5,33 @@ if isdefined(Base, :Experimental) &&
 end
 
 import PrecompileTools
-using ArrayInterface
-using Base: cache_dependencies, Bool
-using LinearAlgebra
+using ArrayInterface: ArrayInterface
+using Base: Bool, convert, copyto!, adjoint, transpose, /, \, require_one_based_indexing
+using LinearAlgebra: LinearAlgebra, BlasInt, LU, Adjoint, BLAS, Bidiagonal, BunchKaufman, 
+                    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,
+                    qr, qr!, svd, svd!
 using LazyArrays: @~, BroadcastArray
-using SciMLBase: AbstractLinearAlgorithm, LinearAliasSpecifier
-using SciMLOperators
-using SciMLOperators: AbstractSciMLOperator, IdentityOperator
-using Setfield
-using UnPack
-using DocStringExtensions
-using EnumX
-using Markdown
-using ChainRulesCore
+using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator,
+                 init, solve!, reinit!, solve, ReturnCode, LinearProblem
+using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator, MatrixOperator,
+                     has_ldiv!, issquare
+using Setfield: @set, @set!
+using UnPack: @unpack
+using DocStringExtensions: DocStringExtensions
+using EnumX: EnumX, @enumx
+using Markdown: Markdown, @doc_str
+using ChainRulesCore: ChainRulesCore
+using Reexport: Reexport, @reexport
+using Libdl: Libdl, dlsym_e
 import InteractiveUtils
 import RecursiveArrayTools
 
-import StaticArraysCore: StaticArray, SVector, MVector, SMatrix, MMatrix
+import StaticArraysCore: StaticArray, SVector, SMatrix
 
-using LinearAlgebra: BlasInt, LU
-using LinearAlgebra.LAPACK: require_one_based_indexing,
-                            chkfinite, chkstride1,
+using LinearAlgebra.LAPACK: chkfinite, chkstride1,
                             @blasfunc, chkargsok
 
 import GPUArraysCore
@@ -34,8 +40,6 @@ import ConcreteStructs: @concrete
 
 # wrap
 import Krylov
-using SciMLBase
-import Preferences
 
 const CRC = ChainRulesCore
 
@@ -51,9 +55,7 @@ else
     const usemkl = false
 end
 
-using Reexport
 @reexport using SciMLBase
-using SciMLBase: _unwrap_val
 
 abstract type SciMLLinearSolveAlgorithm <: SciMLBase.AbstractLinearAlgorithm end
 abstract type AbstractFactorization <: SciMLLinearSolveAlgorithm end

src/appleaccelerate.jl

@@ -252,7 +252,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::AppleAccelerateLUFactorizatio
     end
 
     A, info = @get_cacheval(cache, :AppleAccelerateLUFactorization)
-    LinearAlgebra.require_one_based_indexing(cache.u, cache.b)
+    require_one_based_indexing(cache.u, cache.b)
     m, n = size(A, 1), size(A, 2)
     if m > n
         Bc = copy(cache.b)

src/default.jl

@@ -125,7 +125,7 @@ function defaultalg(A::GPUArraysCore.AnyGPUArray, b::GPUArraysCore.AnyGPUArray,
     end
 end
 
-function defaultalg(A::SciMLBase.AbstractSciMLOperator, b,
+function defaultalg(A::SciMLOperators.AbstractSciMLOperator, b,
         assump::OperatorAssumptions{Bool})
     if has_ldiv!(A)
         return DefaultLinearSolver(DefaultAlgorithmChoice.DirectLdiv!)
@@ -142,7 +142,7 @@ function defaultalg(A::SciMLBase.AbstractSciMLOperator, b,
 end
 
 # Fix ambiguity
-function defaultalg(A::SciMLBase.AbstractSciMLOperator, b::GPUArraysCore.AnyGPUArray,
+function defaultalg(A::SciMLOperators.AbstractSciMLOperator, b::GPUArraysCore.AnyGPUArray,
         assump::OperatorAssumptions{Bool})
     if has_ldiv!(A)
         return DefaultLinearSolver(DefaultAlgorithmChoice.DirectLdiv!)

test/qa.jl

@@ -1,4 +1,8 @@
 using LinearSolve, Aqua
+using ExplicitImports
+using LinearAlgebra, Markdown, Reexport, DocStringExtensions, Libdl, SparseArrays
+import CommonSolve
+
 @testset "Aqua" begin
     Aqua.find_persistent_tasks_deps(LinearSolve)
     Aqua.test_ambiguities(LinearSolve, recursive = false, broken = true)
@@ -10,3 +14,19 @@ using LinearSolve, Aqua
     Aqua.test_unbound_args(LinearSolve)
     Aqua.test_undefined_exports(LinearSolve)
 end
+
+@testset "Explicit Imports" begin
+    # Get extension modules that might be unanalyzable
+    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_stale_explicit_imports(LinearSolve; allow_unanalyzable = unanalyzable_mods) === nothing
+    @test check_all_qualified_accesses_via_owners(LinearSolve) === nothing
+end