Apply runic formatting to all changed files

Format long @SciMLMessage calls to use multi-line syntax for better readability.
Add missing space after = in qa_tests.jl.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: claude

src/fpsolve/fpsolve.jl

@@ -9,11 +9,15 @@ function SciMLBase.postamble!(fpsolver::FPSolver, integrator::DDEIntegrator)
 
     if OrdinaryDiffEqNonlinearSolve.nlsolvefail(fpsolver)
         integrator.stats.nfpconvfail += 1
-        @SciMLMessage(lazy"Fixed-point iteration failed to converge at t = $(integrator.t) after $(fpsolver.iter) iterations",
-            integrator.opts.verbose, :residual_control)
+        @SciMLMessage(
+            lazy"Fixed-point iteration failed to converge at t = $(integrator.t) after $(fpsolver.iter) iterations",
+            integrator.opts.verbose, :residual_control
+        )
     else
-        @SciMLMessage(lazy"Fixed-point iteration converged at t = $(integrator.t) in $(fpsolver.iter) iterations",
-            integrator.opts.verbose, :residual_control)
+        @SciMLMessage(
+            lazy"Fixed-point iteration converged at t = $(integrator.t) in $(fpsolver.iter) iterations",
+            integrator.opts.verbose, :residual_control
+        )
     end
     integrator.force_stepfail = OrdinaryDiffEqNonlinearSolve.nlsolvefail(fpsolver) ||
         integrator.force_stepfail

src/fpsolve/functional.jl

@@ -127,8 +127,10 @@ function compute_step_fixedpoint!(
     )
 
     residual = opts.internalnorm(atmp, t)
-    @SciMLMessage(lazy"Fixed-point iteration residual = $residual at t = $t",
-        opts.verbose, :residual_control)
+    @SciMLMessage(
+        lazy"Fixed-point iteration residual = $residual at t = $t",
+        opts.verbose, :residual_control
+    )
     return residual
 end
 

src/integrators/utils.jl

@@ -195,8 +195,10 @@ function OrdinaryDiffEqCore.handle_discontinuities!(integrator::DDEIntegrator)
     order = d.order
     tdir_t = integrator.tdir * integrator.t
 
-    @SciMLMessage(lazy"Handling discontinuity at t = $(integrator.t) with order $order",
-        integrator.opts.verbose, :discontinuity_tracking)
+    @SciMLMessage(
+        lazy"Handling discontinuity at t = $(integrator.t) with order $order",
+        integrator.opts.verbose, :discontinuity_tracking
+    )
 
     while OrdinaryDiffEqCore.has_discontinuity(integrator) &&
             OrdinaryDiffEqCore.first_discontinuity(integrator) == tdir_t
@@ -244,11 +246,15 @@ function add_next_discontinuities!(integrator, order, t = integrator.t)
     next_order = neutral ? order : order + 1
 
     if neutral
-        @SciMLMessage(lazy"Adding next discontinuities for neutral DDE: order remains $order",
-            integrator.opts.verbose, :neutral_delay)
+        @SciMLMessage(
+            lazy"Adding next discontinuities for neutral DDE: order remains $order",
+            integrator.opts.verbose, :neutral_delay
+        )
     else
-        @SciMLMessage(lazy"Adding next discontinuities: order increases from $order to $next_order",
-            integrator.opts.verbose, :discontinuity_tracking)
+        @SciMLMessage(
+            lazy"Adding next discontinuities: order increases from $order to $next_order",
+            integrator.opts.verbose, :discontinuity_tracking
+        )
     end
 
     # only track discontinuities up to order of the applied method

src/solve.jl

@@ -174,8 +174,10 @@ function SciMLBase.__init(
         old_dtmax = abs(dtmax)
         dtmax = tdir * min(old_dtmax, min_lag)
         if min_lag < old_dtmax
-            @SciMLMessage(lazy"Constrained algorithm: limiting dtmax from $old_dtmax to $min_lag (minimum lag)",
-                verbose_spec, :constrained_step)
+            @SciMLMessage(
+                lazy"Constrained algorithm: limiting dtmax from $old_dtmax to $min_lag (minimum lag)",
+                verbose_spec, :constrained_step
+            )
         end
     end
 

src/track.jl

@@ -10,8 +10,10 @@ function track_propagated_discontinuities!(integrator::DDEIntegrator)
     interp_points = integrator.discontinuity_interp_points
     Θs = range(zero(integrator.t); stop = oneunit(integrator.t), length = interp_points)
 
-    @SciMLMessage(lazy"Tracking discontinuities for state-dependent delays in interval [$(integrator.t), $(integrator.t + integrator.dt)]",
-        integrator.opts.verbose, :state_dependent_delay)
+    @SciMLMessage(
+        lazy"Tracking discontinuities for state-dependent delays in interval [$(integrator.t), $(integrator.t + integrator.dt)]",
+        integrator.opts.verbose, :state_dependent_delay
+    )
 
     # for dependent lags and previous discontinuities
     for lag in integrator.sol.prob.dependent_lags,
@@ -31,12 +33,16 @@ function track_propagated_discontinuities!(integrator::DDEIntegrator)
             # add new discontinuity of correct order at the estimated time point
             if integrator.sol.prob.neutral
                 d = Discontinuity(t, discontinuity.order)
-                @SciMLMessage(lazy"Propagated discontinuity found at t = $t with order $(discontinuity.order) (neutral DDE)",
-                    integrator.opts.verbose, :discontinuity_tracking)
+                @SciMLMessage(
+                    lazy"Propagated discontinuity found at t = $t with order $(discontinuity.order) (neutral DDE)",
+                    integrator.opts.verbose, :discontinuity_tracking
+                )
             else
                 d = Discontinuity(t, discontinuity.order + 1)
-                @SciMLMessage(lazy"Propagated discontinuity found at t = $t with order $(discontinuity.order + 1)",
-                    integrator.opts.verbose, :discontinuity_tracking)
+                @SciMLMessage(
+                    lazy"Propagated discontinuity found at t = $t with order $(discontinuity.order + 1)",
+                    integrator.opts.verbose, :discontinuity_tracking
+                )
             end
             push!(integrator.opts.d_discontinuities, d)
             push!(integrator.opts.tstops, t)
@@ -68,9 +74,11 @@ function discontinuity_function(integrator::DDEIntegrator, lag, T, t)
     end
 
     lag_value = lag(ut, integrator.p, t)
-    @SciMLMessage(lazy"Evaluating state-dependent delay at t = $t: lag = $lag_value",
-        integrator.opts.verbose, :delay_evaluation)
-    T + lag_value - t
+    @SciMLMessage(
+        lazy"Evaluating state-dependent delay at t = $t: lag = $lag_value",
+        integrator.opts.verbose, :delay_evaluation
+    )
+    return T + lag_value - t
 end
 
 """

test/qa/qa_tests.jl

@@ -22,6 +22,6 @@ end
 
     @test check_no_implicit_imports(DelayDiffEq; skip = (Base, Core), ignore = (Symbol("@reexport"),)) ===
         nothing
-    @test check_no_stale_explicit_imports(DelayDiffEq, ignore =(:AbstractVerbositySpecifier, :Standard)) === nothing
+    @test check_no_stale_explicit_imports(DelayDiffEq, ignore = (:AbstractVerbositySpecifier, :Standard)) === nothing
     @test check_all_qualified_accesses_via_owners(DelayDiffEq) === nothing
 end