Use explicit imports

.github/workflows/CI.yml

@@ -25,6 +25,7 @@ jobs:
           - Downstream
           - ODEInterfaceRegression
           - Multithreading
+          - QA
 
           - OrdinaryDiffEqAdamsBashforthMoulton
           - OrdinaryDiffEqBDF

Project.toml

@@ -184,6 +184,7 @@ DiffEqCallbacks = "459566f4-90b8-5000-8ac3-15dfb0a30def"
 DiffEqDevTools = "f3b72e0c-5b89-59e1-b016-84e28bfd966d"
 DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63"
 ElasticArrays = "fdbdab4c-e67f-52f5-8c3f-e7b388dad3d4"
+ExplicitImports = "7876af07-990d-54b4-ab0e-23690620f79a"
 IncompleteLU = "40713840-3770-5561-ab4c-a76e7d0d7895"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
@@ -207,4 +208,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [targets]
-test = ["Calculus", "ComponentArrays", "Symbolics", "AlgebraicMultigrid", "IncompleteLU", "DiffEqCallbacks", "DifferentiationInterface", "DiffEqDevTools", "ODEProblemLibrary", "ElasticArrays", "InteractiveUtils", "ParameterizedFunctions", "PoissonRandom", "Printf", "Random", "ReverseDiff", "SafeTestsets", "SparseArrays", "Statistics", "StructArrays", "Test", "Unitful", "ModelingToolkit", "Pkg", "NLsolve", "RecursiveFactorization", "SparseConnectivityTracer", "SparseMatrixColorings"]
+test = ["Calculus", "ComponentArrays", "Symbolics", "AlgebraicMultigrid", "IncompleteLU", "DiffEqCallbacks", "DifferentiationInterface", "DiffEqDevTools", "ODEProblemLibrary", "ElasticArrays", "ExplicitImports", "InteractiveUtils", "ParameterizedFunctions", "PoissonRandom", "Printf", "Random", "ReverseDiff", "SafeTestsets", "SparseArrays", "Statistics", "StructArrays", "Test", "Unitful", "ModelingToolkit", "Pkg", "NLsolve", "RecursiveFactorization", "SparseConnectivityTracer", "SparseMatrixColorings"]

lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl

@@ -24,17 +24,20 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!,
                            _process_AD_choice
 using OrdinaryDiffEqSDIRK: ImplicitEulerConstantCache, ImplicitEulerCache
 
-using TruncatedStacktraces, MuladdMacro, MacroTools, FastBroadcast, RecursiveArrayTools
+using TruncatedStacktraces: @truncate_stacktrace
+using MuladdMacro: @muladd
+using MacroTools: @capture
+using FastBroadcast: @..
+using RecursiveArrayTools: recursivefill!
 import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA
 using LinearAlgebra: mul!, I
-using ArrayInterface
+using ArrayInterface: ismutable
 import OrdinaryDiffEqCore
 using OrdinaryDiffEqDifferentiation: UJacobianWrapper
 using OrdinaryDiffEqNonlinearSolve: NLNewton, du_alias_or_new, build_nlsolver,
                                     nlsolve!, nlsolvefail, isnewton, markfirststage!,
                                     set_new_W!, DIRK, compute_step!, COEFFICIENT_MULTISTEP,
                                     NonlinearSolveAlg
-import ADTypes
 import ADTypes: AutoForwardDiff, AutoFiniteDiff, AbstractADType
 
 using Reexport

lib/OrdinaryDiffEqBDF/src/algorithms.jl

@@ -444,7 +444,7 @@ function QNDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
         extrapolant, kappa, controller, step_limiter!, AD_choice)
 end
 
-TruncatedStacktraces.@truncate_stacktrace QNDF
+@truncate_stacktrace QNDF
 
 @doc BDF_docstring("The second order Modified Extended BDF method,
     which has improved stability properties over the standard BDF.
@@ -549,7 +549,7 @@ function FBDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
         controller, step_limiter!, AD_choice)
 end
 
-TruncatedStacktraces.@truncate_stacktrace FBDF
+@truncate_stacktrace FBDF
 
 """
 QBDF1: Multistep Method
@@ -771,4 +771,4 @@ function DFBDF(; max_order::Val{MO} = Val{5}(), chunk_size = Val{0}(),
         controller, AD_choice)
 end
 
-TruncatedStacktraces.@truncate_stacktrace DFBDF
+@truncate_stacktrace DFBDF

lib/OrdinaryDiffEqBDF/src/bdf_caches.jl

@@ -418,7 +418,7 @@ end
     step_limiter!::StepLimiter
 end
 
-TruncatedStacktraces.@truncate_stacktrace QNDFCache 1
+@truncate_stacktrace QNDFCache 1
 
 function alg_cache(alg::QNDF{MO}, u, rate_prototype, ::Type{uEltypeNoUnits},
         ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, uprev2, f, t,
@@ -609,7 +609,7 @@ end
     step_limiter!::StepLimiter
 end
 
-TruncatedStacktraces.@truncate_stacktrace FBDFCache 1
+@truncate_stacktrace FBDFCache 1
 
 function alg_cache(alg::FBDF{MO}, u, rate_prototype, ::Type{uEltypeNoUnits},
         ::Type{uBottomEltypeNoUnits}, ::Type{tTypeNoUnits}, uprev, uprev2, f, t,

lib/OrdinaryDiffEqCore/src/OrdinaryDiffEqCore.jl

@@ -11,15 +11,15 @@ using Reexport
 
 using Logging
 
-using MuladdMacro, FastClosures
+using MuladdMacro: @muladd
 
-using LinearAlgebra
+using LinearAlgebra: opnorm, I, UniformScaling, diag, rank, isdiag
 
 using PrecompileTools
 
 import FillArrays: Trues, Falses
 
-import FastPower
+import FastPower: fastpower
 
 # Interfaces
 import DiffEqBase: solve!, step!, initialize!, isadaptive
@@ -38,9 +38,13 @@ using DiffEqBase: DEIntegrator
 
 import RecursiveArrayTools: chain, recursivecopy!
 
-using SimpleUnPack, RecursiveArrayTools, DataStructures, ArrayInterface
+using SimpleUnPack: @unpack
+using RecursiveArrayTools
+using DataStructures: BinaryHeap, FasterForward
+import DataStructures
+using ArrayInterface: issingular
 
-import TruncatedStacktraces
+import TruncatedStacktraces: @truncate_stacktrace, VERBOSE_MSG
 
 import StaticArraysCore: SArray, MVector, SVector, StaticArray, MMatrix,
                          StaticMatrix
@@ -71,15 +75,15 @@ import DiffEqBase: calculate_residuals,
                    islinear, timedepentdtmin
 
 import Polyester
-using MacroTools, Adapt
+# MacroTools and Adapt imported but not directly used in OrdinaryDiffEqCore
+# using MacroTools, Adapt
 import ADTypes: AutoFiniteDiff, AutoForwardDiff, AbstractADType, AutoSparse
 import Accessors: @reset
 
-using SciMLStructures: canonicalize, Tunable, isscimlstructure
+# SciMLStructures symbols imported but not directly used in OrdinaryDiffEqCore
+# using SciMLStructures: canonicalize, Tunable, isscimlstructure
 
-using SymbolicIndexingInterface: state_values, parameter_values, is_variable,
-                                 variable_index,
-                                 symbolic_type, NotSymbolic
+using SymbolicIndexingInterface: state_values, parameter_values
 
 const CompiledFloats = Union{Float32, Float64}
 import Preferences

lib/OrdinaryDiffEqCore/src/algorithms.jl

@@ -100,7 +100,7 @@ struct CompositeAlgorithm{CS, T, F} <: OrdinaryDiffEqCompositeAlgorithm
     end
 end
 
-TruncatedStacktraces.@truncate_stacktrace CompositeAlgorithm 1
+@truncate_stacktrace CompositeAlgorithm 1
 
 if isdefined(Base, :Experimental) && isdefined(Base.Experimental, :silence!)
     Base.Experimental.silence!(CompositeAlgorithm)

lib/OrdinaryDiffEqCore/src/integrators/controllers.jl

@@ -68,7 +68,7 @@ end
         q = inv(qmax)
     else
         expo = 1 / (get_current_adaptive_order(alg, integrator.cache) + 1)
-        qtmp = FastPower.fastpower(EEst, expo) / gamma
+        qtmp = fastpower(EEst, expo) / gamma
         @fastmath q = DiffEqBase.value(max(inv(qmax), min(inv(qmin), qtmp)))
         # TODO: Shouldn't this be in `step_accept_controller!` as for the PI controller?
         integrator.qold = DiffEqBase.value(integrator.dt) / q
@@ -141,8 +141,8 @@ end
     if iszero(EEst)
         q = inv(qmax)
     else
-        q11 = FastPower.fastpower(EEst, convert(typeof(EEst), beta1))
-        q = q11 / FastPower.fastpower(qold, convert(typeof(EEst), beta2))
+        q11 = fastpower(EEst, convert(typeof(EEst), beta1))
+        q = q11 / fastpower(qold, convert(typeof(EEst), beta2))
         integrator.q11 = q11
         @fastmath q = max(inv(qmax), min(inv(qmin), q / gamma))
     end
@@ -419,7 +419,7 @@ end
             fac = min(gamma, (1 + 2 * maxiters) * gamma / (iter + 2 * maxiters))
         end
         expo = 1 / (get_current_adaptive_order(alg, integrator.cache) + 1)
-        qtmp = FastPower.fastpower(EEst, expo) / fac
+        qtmp = fastpower(EEst, expo) / fac
         @fastmath q = DiffEqBase.value(max(inv(qmax), min(inv(qmin), qtmp)))
         integrator.qold = q
     end
@@ -434,7 +434,7 @@ function step_accept_controller!(integrator, controller::PredictiveController, a
     if integrator.success_iter > 0
         expo = 1 / (get_current_adaptive_order(alg, integrator.cache) + 1)
         qgus = (integrator.dtacc / integrator.dt) *
-               FastPower.fastpower((EEst^2) / integrator.erracc, expo)
+               fastpower((EEst^2) / integrator.erracc, expo)
         qgus = max(inv(qmax), min(inv(qmin), qgus / gamma))
         qacc = max(q, qgus)
     else

lib/OrdinaryDiffEqCore/src/solve.jl

@@ -51,7 +51,7 @@ function DiffEqBase.__init(
         failfactor = 2,
         maxiters = anyadaptive(alg) ? 1000000 : typemax(Int),
         internalnorm = ODE_DEFAULT_NORM,
-        internalopnorm = LinearAlgebra.opnorm,
+        internalopnorm = opnorm,
         isoutofdomain = ODE_DEFAULT_ISOUTOFDOMAIN,
         unstable_check = ODE_DEFAULT_UNSTABLE_CHECK,
         verbose = true,

lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl

@@ -15,8 +15,10 @@ import LinearAlgebra: Diagonal, I, UniformScaling, diagind, mul!, lmul!, axpby!,
 import LinearAlgebra: LowerTriangular, UpperTriangular
 import SparseArrays: SparseMatrixCSC, AbstractSparseMatrix, nonzeros, sparse, spzeros
 import ArrayInterface
+import ArrayInterface: fast_scalar_indexing, zeromatrix, lu_instance
 
-import StaticArrayInterface
+# StaticArrayInterface imported but not used
+# import StaticArrayInterface
 import StaticArrays
 import StaticArrays: SArray, MVector, SVector, @SVector, StaticArray, MMatrix, SA,
                      StaticMatrix
@@ -25,8 +27,9 @@ using DiffEqBase: TimeGradientWrapper,
                   UJacobianWrapper, TimeDerivativeWrapper,
                   UDerivativeWrapper
 using SciMLBase: AbstractSciMLOperator, constructorof, @set
-using SciMLOperators
-import SparseMatrixColorings
+using SciMLOperators: IdentityOperator, update_coefficients!
+import SparseMatrixColorings: ConstantColoringAlgorithm, GreedyColoringAlgorithm, ColoringProblem,
+                               ncolors, column_colors, coloring, sparsity_pattern
 import OrdinaryDiffEqCore
 using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, OrdinaryDiffEqAdaptiveImplicitAlgorithm,
                           DAEAlgorithm,
@@ -45,7 +48,8 @@ using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, OrdinaryDiffEqAdaptiveImplici
 
 import OrdinaryDiffEqCore: get_chunksize, resize_J_W!, resize_nlsolver!, alg_autodiff, _get_fwd_tag
 
-using ConstructionBase
+import ConstructionBase
+using ConstructionBase: constructorof
 
 import DifferentiationInterface as DI
 

lib/OrdinaryDiffEqDifferentiation/src/alg_utils.jl

@@ -132,8 +132,8 @@ function prepare_user_sparsity(ad_alg, prob)
         sparsity = sparsity isa MatrixOperator ? sparsity.A : sparsity
 
         color_alg = DiffEqBase.has_colorvec(prob.f) ?
-                    SparseMatrixColorings.ConstantColoringAlgorithm(
-            sparsity, prob.f.colorvec) : SparseMatrixColorings.GreedyColoringAlgorithm()
+                    ConstantColoringAlgorithm(
+            sparsity, prob.f.colorvec) : GreedyColoringAlgorithm()
 
         sparsity_detector = ADTypes.KnownJacobianSparsityDetector(sparsity)
 

lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl

@@ -794,7 +794,7 @@ function build_J_W(alg, u, uprev, p, t, dt, f::F, jac_config, ::Type{uEltypeNoUn
                 if isnothing(f.sparsity)
                     !isnothing(jac_config) ?
                     convert.(
-                        eltype(u), SparseMatrixColorings.sparsity_pattern(jac_config[1])) :
+                        eltype(u), sparsity_pattern(jac_config[1])) :
                     spzeros(eltype(u), length(u), length(u))
                 elseif eltype(f.sparsity) == Bool
                     convert.(eltype(u), f.sparsity)
@@ -825,7 +825,7 @@ function build_J_W(alg, u, uprev, p, t, dt, f::F, jac_config, ::Type{uEltypeNoUn
             if alg_autodiff(alg) isa AutoSparse
 
                 if isnothing(f.sparsity)
-                    !isnothing(jac_config) ? convert.(eltype(u), SparseMatrixColorings.sparsity_pattern(jac_config[1])) :
+                    !isnothing(jac_config) ? convert.(eltype(u), sparsity_pattern(jac_config[1])) :
                     spzeros(eltype(u), length(u), length(u))
                 elseif eltype(f.sparsity) == Bool
                     convert.(eltype(u), f.sparsity)

lib/OrdinaryDiffEqDifferentiation/src/derivative_wrappers.jl

@@ -185,7 +185,7 @@ function jacobian!(J::AbstractMatrix{<:Number}, f, x::AbstractArray{<:Number},
 
     if dense isa AutoForwardDiff
         if alg_autodiff(alg) isa AutoSparse
-            integrator.stats.nf += maximum(SparseMatrixColorings.ncolors(jac_config[1]))
+            integrator.stats.nf += maximum(ncolors(jac_config[1]))
         else
             sparsity, colorvec = sparsity_colorvec(integrator.f, x)
             maxcolor = maximum(colorvec)
@@ -375,9 +375,9 @@ function sparsity_colorvec(f, x)
         end
     end
 
-    col_alg = SparseMatrixColorings.GreedyColoringAlgorithm()
-    col_prob = SparseMatrixColorings.ColoringProblem()
+    col_alg = GreedyColoringAlgorithm()
+    col_prob = ColoringProblem()
     colorvec = DiffEqBase.has_colorvec(f) ? f.colorvec :
-               (isnothing(sparsity) ? (1:length(x)) : SparseMatrixColorings.column_colors(SparseMatrixColorings.coloring(sparsity, col_prob, col_alg)))
+               (isnothing(sparsity) ? (1:length(x)) : column_colors(coloring(sparsity, col_prob, col_alg)))
     sparsity, colorvec
 end

lib/OrdinaryDiffEqExplicitRK/src/OrdinaryDiffEqExplicitRK.jl

@@ -7,7 +7,8 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, alg_stability_size,
                            OrdinaryDiffEqMutableCache, initialize!, perform_step!, isfsal,
                            CompositeAlgorithm, calculate_residuals!, calculate_residuals,
                            full_cache, get_fsalfirstlast
-using TruncatedStacktraces, RecursiveArrayTools, FastBroadcast, MuladdMacro, DiffEqBase
+using TruncatedStacktraces: @truncate_stacktrace
+using RecursiveArrayTools, FastBroadcast, MuladdMacro, DiffEqBase
 import LinearAlgebra: norm
 import OrdinaryDiffEqCore
 

lib/OrdinaryDiffEqExplicitRK/src/algorithms.jl

@@ -54,4 +54,4 @@ struct ExplicitRK{TabType} <: OrdinaryDiffEqAdaptiveAlgorithm
 end
 ExplicitRK(; tableau = ODE_DEFAULT_TABLEAU) = ExplicitRK(tableau)
 
-TruncatedStacktraces.@truncate_stacktrace ExplicitRK
+@truncate_stacktrace ExplicitRK

lib/OrdinaryDiffEqLinear/src/OrdinaryDiffEqLinear.jl

@@ -10,7 +10,7 @@ import OrdinaryDiffEqCore: alg_order, alg_extrapolates, dt_required,
                            calculate_residuals!, get_fsalfirstlast,
                            _vec, isdtchangeable, full_cache,
                            generic_solver_docstring
-using LinearAlgebra: mul!, I
+using LinearAlgebra: mul!, I, inv
 using SciMLOperators: AbstractSciMLOperator
 using ExponentialUtilities
 using RecursiveArrayTools

lib/OrdinaryDiffEqNonlinearSolve/src/OrdinaryDiffEqNonlinearSolve.jl

@@ -1,6 +1,6 @@
 module OrdinaryDiffEqNonlinearSolve
 
-using ADTypes
+using ADTypes: dense_ad, AutoForwardDiff, AutoFiniteDiff
 
 import SciMLBase
 import SciMLBase: init, solve, solve!, remake
@@ -9,17 +9,19 @@ using SciMLBase: DAEFunction, DEIntegrator, NonlinearFunction, NonlinearProblem,
                  update_coefficients!, get_tmp_cache, AbstractSciMLOperator, ReturnCode,
                  AbstractNonlinearProblem, LinearAliasSpecifier
 import DiffEqBase
-import PreallocationTools
+import PreallocationTools: dualcache, get_tmp
 using SimpleNonlinearSolve: SimpleTrustRegion, SimpleGaussNewton
 using NonlinearSolve: FastShortcutNonlinearPolyalg, FastShortcutNLLSPolyalg, NewtonRaphson,
                       step!
-using MuladdMacro, FastBroadcast
+using MuladdMacro: @muladd
+using FastBroadcast: @..
 import FastClosures: @closure
 using LinearAlgebra: UniformScaling, UpperTriangular, givens, cond, dot, lmul!, axpy!
 import LinearAlgebra
-import ArrayInterface
+import ArrayInterface: ismutable, restructure
+import LinearSolve: OperatorAssumptions
 import LinearSolve
-import ForwardDiff
+import ForwardDiff: pickchunksize
 using ForwardDiff: Dual
 using LinearSolve: I, rmul!, norm, mul!, ldiv!
 using RecursiveArrayTools: recursivecopy!

lib/OrdinaryDiffEqRosenbrock/src/OrdinaryDiffEqRosenbrock.jl

@@ -8,15 +8,15 @@ import OrdinaryDiffEqCore: alg_order, alg_adaptive_order, isWmethod, isfsal, _un
                            _vec, _reshape, perform_step!, trivial_limiter!,
                            OrdinaryDiffEqRosenbrockAdaptiveAlgorithm,
                            OrdinaryDiffEqRosenbrockAlgorithm, generic_solver_docstring,
-                           namify, initialize!, perform_step!, get_fsalfirstlast,
+                           initialize!, perform_step!, get_fsalfirstlast,
                            constvalue, only_diagonal_mass_matrix,
                            calculate_residuals, has_stiff_interpolation, ODEIntegrator,
                            resize_non_user_cache!, _ode_addsteps!, full_cache,
                            DerivativeOrderNotPossibleError, _bool_to_ADType,
                            _process_AD_choice, LinearAliasSpecifier
 using MuladdMacro, FastBroadcast, RecursiveArrayTools
 import MacroTools
-using MacroTools: @capture
+using MacroTools: @capture, namify
 using DiffEqBase: @def
 import DifferentiationInterface as DI
 import LinearSolve

lib/OrdinaryDiffEqSDIRK/src/OrdinaryDiffEqSDIRK.jl

@@ -15,7 +15,8 @@ import OrdinaryDiffEqCore: alg_order, calculate_residuals!,
                            isesdirk, issplit,
                            ssp_coefficient, get_fsalfirstlast, generic_solver_docstring,
                            _bool_to_ADType, _process_AD_choice, current_extrapolant!
-using TruncatedStacktraces, MuladdMacro, MacroTools, FastBroadcast, RecursiveArrayTools
+using TruncatedStacktraces: @truncate_stacktrace
+using MuladdMacro, MacroTools, FastBroadcast, RecursiveArrayTools
 using SciMLBase: SplitFunction
 using LinearAlgebra: mul!, I
 import OrdinaryDiffEqCore

lib/OrdinaryDiffEqSDIRK/src/algorithms.jl

@@ -255,7 +255,7 @@ function TRBDF2(;
         smooth_est, extrapolant, controller, step_limiter!, AD_choice)
 end
 
-TruncatedStacktraces.@truncate_stacktrace TRBDF2
+@truncate_stacktrace TRBDF2
 
 @doc SDIRK_docstring("SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method",
     "SDIRK2";
@@ -1025,7 +1025,7 @@ function KenCarp4(; chunk_size = Val{0}(), autodiff = AutoForwardDiff(),
         smooth_est, extrapolant, controller, step_limiter!, AD_choice)
 end
 
-TruncatedStacktraces.@truncate_stacktrace KenCarp4
+@truncate_stacktrace KenCarp4
 
 @doc SDIRK_docstring(
     "An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting.",