QA: run_qa v1.6 form + ExplicitImports (#319)

* QA: run_qa v1.6 form + ExplicitImports

Convert test/qa/qa.jl from a hand-rolled Aqua testset to SciMLTesting's
run_qa (v1.6) with ExplicitImports enabled. The bespoke JET `@test_opt`
constructor type-stability checks stay in test/qa/jet_tests.jl (run_qa's
`JET.test_package` error analysis does not subsume them); run_qa keeps its
JET off via `jet = false` so loading JET in jet_tests.jl does not
auto-enable it.

ExplicitImports findings resolved:
- no_implicit_imports: add SciMLBase.DiscreteProblem to the explicit imports
  (was used implicitly).
- no_stale_explicit_imports: drop genuinely-unused imports
  NonlinearLeastSquaresProblem, init, reinit!, solve! (SciMLBase) and ldiv!
  (LinearAlgebra) — each was only ever accessed in qualified/extended form
  (SciMLBase.reinit! etc.) or not at all. derivative_discontinuity! is kept
  and ignored: it is imported inside the @static-if SciMLBase v2/v3 rename
  shim and used bare on v3, which the static scan cannot see through.
- all_qualified_accesses_via_owners: change SciMLBase.copyto! to bare copyto!
  in the manifold projection (copyto! is Base's, already imported from
  LinearAlgebra).
- Remaining other-package non-public qualified accesses / explicit imports
  ignored via ei_kwargs (SciMLBase / LinearAlgebra / Base / DiffEqBase
  internals; several are `public` on 1.11+ but flagged on the LTS).

test/qa/Project.toml: add SciMLTesting (compat "1.6"); ExplicitImports comes
transitively via SciMLTesting; Aqua and JET stay direct deps (Aqua's
ambiguities child-proc and the bespoke JET check need them).

Verified locally against released SciMLTesting 1.6.0: QA group green on both
lanes (Julia 1.12: jet_tests 15/15, qa.jl 17/17; Julia 1.10 LTS: jet_tests 1
broken [JET-skip-on-LTS, preserved], qa.jl 17/17). Full Core lane green on
1.12 (manifold 25/25, domain 19/19, terminatesteadystate 11/11).

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* QA: trim redundant public-API EI ignores (SciMLTesting 1.7 + released base libs)

SciMLTesting 1.7.0 runs the two public-API ExplicitImports checks
(check_all_qualified_accesses_are_public / check_all_explicit_imports_are_public)
only on Julia >= 1.11 and skips them on the LTS, and SciMLBase 3.24.0 made
several formerly-internal names public. With those released, the per-name
public-API ignore-lists in test/qa/qa.jl are largely redundant.

Drop the entries that are now public on the registered releases (verified on
Julia 1.12 against SciMLBase 3.24.0):
  - all_qualified_accesses_are_public: remove numargs, successful_retcode,
    Success, ConvergenceFailure, InitialFailure (SciMLBase), depwarn (Base),
    reverse (Base.Iterators).

Keep only what the public checks still flag against the registered releases:
  - all_qualified_accesses_are_public: AbstractDEProblem, AbstractODEIntegrator,
    INITIALIZE_DEFAULT, _unwrap_val, alg_order, isadaptive (SciMLBase 3.24.0,
    still non-public), QRCompactWY (LinearAlgebra), RefValue (Base).
  - all_explicit_imports_are_public: get_tstops, get_tstops_array,
    get_tstops_max (DiffEqBase 7.5.7, still non-public).

The no_stale_explicit_imports ignore (derivative_discontinuity!) is unchanged.
qa/Project.toml needs no compat change: SciMLTesting="1.6" already admits 1.7,
and the base-lib floors transitively admit the released versions.

Verified locally against registered releases (SciMLTesting 1.7.0, SciMLBase
3.24.0, DiffEqBase 7.5.7, ExplicitImports 1.15.0):
  - Julia 1.12 (public checks run): QA group 32/32 pass.
  - Julia 1.10 LTS (public checks skipped): QA group 15 pass + 1 broken
    (pre-existing JET-skip-on-LTS marker), 0 fail.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* QA: migrate DiffEqBase.X -> SciMLBase.X callers; strip now-public EI ignores

DiffEqBase 7.6.0 / SciMLBase 3.27.0 make the previously-internal names
public, so the public-API ExplicitImports ignores can be trimmed and the
qualified-access callers pointed at the owning module (SciMLBase):

- src: rewrite `DiffEqBase.isinplace/addsteps!/get_du!/DiscreteProblem`
  (all SciMLBase-owned, now public, identity-equal re-exports) to
  `SciMLBase.X`; drop the now-unused `DiffEqBase` module self-binding from
  the import (only the DiffEqBase-own `get_tstops*` are still used bare);
  fix the PresetTimeCallback docstring to `SciMLBase.INITIALIZE_DEFAULT`.
- qa.jl: empty `all_explicit_imports_are_public` (get_tstops* now public in
  DiffEqBase 7.6.0) and drop `AbstractDEProblem/alg_order/isadaptive` from
  `all_qualified_accesses_are_public` (now public in SciMLBase 3.27.0).

Survivors kept (verified still non-public on Julia 1.12 / SciMLBase 3.27.0,
DiffEqBase 7.6.0, stdlib): AbstractODEIntegrator, INITIALIZE_DEFAULT,
_unwrap_val (SciMLBase), QRCompactWY (LinearAlgebra), RefValue (Base).

Verified: QA group 17/17 on Julia 1.12 (public-API checks run), 15/15 on
Julia 1.10 (public-API checks gated off by SciMLTesting 1.7); 0 fail/error.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* QA: eliminate fixable EI exceptions (migrate/local-define), keep only stdlib internals

ExplicitImports exceptions in test/qa/qa.jl reduced from 6 to 2 by fixing the
root cause instead of ignoring:

- derivative_discontinuity! (no_stale_explicit_imports ignore): the v2/v3 rename
  shim used `using SciMLBase: derivative_discontinuity!` on one branch and a
  `const ... = SciMLBase.u_modified!` on the other, which EI flagged as a stale
  import. Replaced with a single `const` bound to whichever public name the
  loaded SciMLBase provides; behavior is identical on both v2 (u_modified!) and
  v3 (derivative_discontinuity!), both of which are public. Drops the ignore.

- AbstractODEIntegrator (all_qualified_accesses_are_public ignore): now public in
  SciMLBase 3.30.0 and already accessed via the public owner SciMLBase; ignore is
  redundant and dropped.

- INITIALIZE_DEFAULT: defined a local no-op `INITIALIZE_DEFAULT(cb,u,t,integrator)
  = derivative_discontinuity!(integrator, false)` matching SciMLBase's non-public
  const (no identity comparison exists for it anywhere in SciMLBase/DiffEqBase/
  OrdinaryDiffEqCore, so a local binding is behavior-preserving) and use it as the
  PresetTimeCallback default. Drops the ignore.

- _unwrap_val: defined a local `_unwrap_val` (the leading-underscore SciMLBase
  internal that will not be made public) reproducing its exact behavior, used in
  manifold.jl. Drops the ignore.

Remaining 2 ignores are genuinely-irreducible concrete stdlib internal types with
no public spelling: LinearAlgebra.QRCompactWY (dispatch target of fact_successful)
and Base.RefValue (concrete Ref type in a parametric NamedTuple alias).

No new direct deps: all migrations went to local definitions or to already-imported
public SciMLBase API. Verified on Julia 1.12 / SciMLBase 3.30.0 / SciMLTesting 1.7.0:
QA group 17/17 pass; print_explicit_imports reports only the 2 stdlib internals.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

---------

Co-authored-by: ChrisRackauckas-Claude <accounts@chrisrackauckas.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

src/DiffEqCallbacks.jl

@@ -2,32 +2,46 @@ module DiffEqCallbacks
 
 using ConcreteStructs: @concrete
 using DataStructures: DataStructures, BinaryMaxHeap, BinaryMinHeap
-using DiffEqBase: DiffEqBase, get_tstops, get_tstops_array, get_tstops_max
+using DiffEqBase: get_tstops, get_tstops_array, get_tstops_max
 using DifferentiationInterface: DifferentiationInterface, Constant
-using LinearAlgebra: LinearAlgebra, adjoint, axpy!, copyto!, diagind, mul!, ldiv!
+using LinearAlgebra: LinearAlgebra, adjoint, axpy!, copyto!, diagind, mul!
 using Markdown: @doc_str
 using PrecompileTools: PrecompileTools
 using RecipesBase: @recipe
 using RecursiveArrayTools: RecursiveArrayTools, DiffEqArray, copyat_or_push!
-using SciMLBase: SciMLBase, CallbackSet, DiscreteCallback, NonlinearFunction,
-    NonlinearLeastSquaresProblem, NonlinearProblem, RODEProblem,
+using SciMLBase: SciMLBase, CallbackSet, DiscreteCallback, DiscreteProblem,
+    NonlinearFunction, NonlinearProblem, RODEProblem,
     ReturnCode, SDEProblem, add_tstop!, check_error, get_du,
-    get_proposed_dt, get_tmp_cache, init, reinit!,
-    set_proposed_dt!, solve!, terminate!
+    get_proposed_dt, get_tmp_cache,
+    set_proposed_dt!, terminate!
 using StaticArraysCore: StaticArraysCore
 
 # SciMLBase v3 renamed `u_modified!` → `derivative_discontinuity!` (with
 # an `@deprecate` on the old name). Support both SciMLBase v2 and v3 by
-# aliasing to whichever name the loaded SciMLBase provides.
-@static if isdefined(SciMLBase, :derivative_discontinuity!)
-    using SciMLBase: derivative_discontinuity!
+# binding a const to whichever name the loaded SciMLBase provides. Both
+# `derivative_discontinuity!` and `u_modified!` are public in their
+# respective SciMLBase versions, so the qualified access is to public API; a
+# `const` (rather than a `using` import on one branch) keeps the name a single
+# local binding and avoids a stale-import false positive.
+const derivative_discontinuity! = if isdefined(SciMLBase, :derivative_discontinuity!)
+    SciMLBase.derivative_discontinuity!
 else
-    const derivative_discontinuity! = SciMLBase.u_modified!
+    SciMLBase.u_modified!
 end
 
 const DI = DifferentiationInterface
 true_condition(u, t, integrator) = true
 
+# Local reproduction of SciMLBase's `_unwrap_val` (a leading-underscore internal
+# that will not be made public): pull the value out of a `Val`, pass anything
+# else through unchanged.
+_unwrap_val(B) = B
+_unwrap_val(::Val{B}) where {B} = B
+
+# No-op default `initialize` for `DiscreteCallback`, matching SciMLBase's
+# (non-public) `INITIALIZE_DEFAULT`: reset the derivative-discontinuity flag.
+INITIALIZE_DEFAULT(cb, u, t, integrator) = derivative_discontinuity!(integrator, false)
+
 include("functor_helpers.jl")
 include("autoabstol.jl")
 include("manifold.jl")

src/function_caller.jl

@@ -19,7 +19,7 @@ function (affect!::FunctionCallingAffect)(integrator, force_func = false)
         if curt != integrator.t # If <t, interpolate
             if integrator isa SciMLBase.AbstractODEIntegrator
                 # Expand lazy dense for interpolation
-                DiffEqBase.addsteps!(integrator)
+                SciMLBase.addsteps!(integrator)
             end
             if integrator.u isa Union{Number, StaticArraysCore.SArray}
                 curu = integrator(curt)

src/integrating.jl

@@ -181,7 +181,7 @@ function (affect!::SavingIntegrandAffect)(integrator)
     for i in 1:n
         t_temp = ((integrator.t - integrator.tprev) / 2) * gauss_points[n][i] +
             (integrator.t + integrator.tprev) / 2
-        if DiffEqBase.isinplace(integrator.sol.prob)
+        if SciMLBase.isinplace(integrator.sol.prob)
             curu = first(get_tmp_cache(integrator))
             integrator(curu, t_temp)
             if affect!.integrand_cache == nothing

src/integrating_GK_affect.jl

@@ -178,7 +178,7 @@ function integrate_gk!(
     affect!.gk_err_cache = recursive_zero!(affect!.gk_err_cache)
     for i in 1:(2 * order + 1)
         t_temp = (gk_points[order][i] + 1) * ((bound_r - bound_l) / 2) + bound_l
-        if DiffEqBase.isinplace(integrator.sol.prob)
+        if SciMLBase.isinplace(integrator.sol.prob)
             curu = first(get_tmp_cache(integrator))
             integrator(curu, t_temp)
             if affect!.integrand_cache == nothing

src/integrating_GK_sum.jl

@@ -19,7 +19,7 @@ function integrate_gk!(
     )
     affect!.gk_step_cache = recursive_zero!(affect!.gk_step_cache)
     affect!.gk_err_cache = recursive_zero!(affect!.gk_err_cache)
-    isinplace_prob = DiffEqBase.isinplace(integrator.sol.prob)
+    isinplace_prob = SciMLBase.isinplace(integrator.sol.prob)
     inplace_integrand = affect!.integrand_inplace === nothing ?
         (isinplace_prob && affect!.integrand_cache !== nothing) :
         affect!.integrand_inplace

src/integrating_sum.jl

@@ -88,7 +88,7 @@ function (affect!::SavingIntegrandSumAffect)(integrator)
         n = div(SciMLBase.alg_order(integrator.alg) + 1, 2)
     end
     accumulation_cache = recursive_zero!(affect!.accumulation_cache)
-    isinplace_prob = DiffEqBase.isinplace(integrator.sol.prob)
+    isinplace_prob = SciMLBase.isinplace(integrator.sol.prob)
     inplace_integrand = affect!.integrand_inplace === nothing ?
         (isinplace_prob && affect!.integrand_cache !== nothing) :
         affect!.integrand_inplace

src/manifold.jl

@@ -114,7 +114,7 @@ function (proj::ManifoldProjection)(integrator)
         return
     end
 
-    return SciMLBase.copyto!(integrator.u, u)
+    return copyto!(integrator.u, u)
 end
 
 function initialize_manifold_projection(cb, u, t, integrator)
@@ -152,7 +152,7 @@ export ManifoldProjection
 # wrapper for non-autonomous functions
 function wrap_autonomous_function(autonomous::Union{Val{true}, Val{false}}, g)
     g === nothing && return nothing
-    return TypedNonAutonomousFunction{SciMLBase._unwrap_val(autonomous)}(g, nothing)
+    return TypedNonAutonomousFunction{_unwrap_val(autonomous)}(g, nothing)
 end
 function wrap_autonomous_function(autonomous::Union{Bool, Nothing}, g)
     g === nothing && return nothing

src/preset_time.jl

@@ -34,7 +34,7 @@ end
 """
 ```julia
 PresetTimeCallback(tstops, user_affect!;
-    initialize = DiffEqBase.INITIALIZE_DEFAULT,
+    initialize = INITIALIZE_DEFAULT,
     filter_tstops = true,
     kwargs...)
 ```
@@ -55,7 +55,7 @@ automatic.
 """
 function PresetTimeCallback(
         tstops, user_affect!;
-        initialize = SciMLBase.INITIALIZE_DEFAULT,
+        initialize = INITIALIZE_DEFAULT,
         filter_tstops = true,
         sort_inplace = false, kwargs...
     )

src/saving.jl

@@ -52,9 +52,9 @@ function (affect!::SavingAffect)(integrator, force_save = false)
         if curt != integrator.t # If <t, interpolate
             if integrator isa SciMLBase.AbstractODEIntegrator
                 # Expand lazy dense for interpolation
-                DiffEqBase.addsteps!(integrator)
+                SciMLBase.addsteps!(integrator)
             end
-            if !DiffEqBase.isinplace(integrator.sol.prob)
+            if !SciMLBase.isinplace(integrator.sol.prob)
                 curu = integrator(curt)
             else
                 curu = first(get_tmp_cache(integrator))

src/terminatesteadystate.jl

@@ -8,23 +8,23 @@ function allDerivPass(integrator, abstol, reltol, min_t)
     end
 
     testval = if integrator.sol.prob isa DiscreteProblem
-        if DiffEqBase.isinplace(integrator.sol.prob)
+        if SciMLBase.isinplace(integrator.sol.prob)
             testval = first(get_tmp_cache(integrator))
             @. testval = integrator.u - integrator.uprev
         else
             testval = integrator.u .- integrator.uprev
         end
     else
-        if DiffEqBase.isinplace(integrator.sol.prob)
+        if SciMLBase.isinplace(integrator.sol.prob)
             testval = first(get_tmp_cache(integrator))
-            DiffEqBase.get_du!(testval, integrator)
-            if integrator.sol.prob isa DiffEqBase.DiscreteProblem
+            SciMLBase.get_du!(testval, integrator)
+            if integrator.sol.prob isa SciMLBase.DiscreteProblem
                 @. testval = testval - integrator.u
             end
             testval
         else
             testval = get_du(integrator)
-            if integrator.sol.prob isa DiffEqBase.DiscreteProblem
+            if integrator.sol.prob isa SciMLBase.DiscreteProblem
                 testval = testval - integrator.u
             end
             testval