fix: DefaultCache trim compatibility

- Eagerly initialize all 6 sub-caches in the constructor instead of
  lazily via init_ith_default_cache, so the trimmer can statically
  resolve all alg_cache calls.
- Add @generated _reset_alg_opts_default! that enumerates (old, new)
  algorithm index pairs at compile time, replacing dynamic tuple
  indexing that the trimmer cannot resolve.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: asinghvi17

lib/OrdinaryDiffEqCore/src/caches/basic_caches.jl

@@ -99,25 +99,14 @@ function alg_cache(
         args, alg.choice_function, 1, u
     )
     algs = alg.algs
-    # If the type is a bitstype we need to initialize it correctly here since isdefined will always return true.
-    if isbitstype(T1)
-        cache.cache1 = alg_cache(algs[1], args...)
-    end
-    if isbitstype(T2)
-        cache.cache2 = alg_cache(algs[2], args...)
-    end
-    if isbitstype(T3)
-        cache.cache3 = alg_cache(algs[3], args...)
-    end
-    if isbitstype(T4)
-        cache.cache4 = alg_cache(algs[4], args...)
-    end
-    if isbitstype(T5)
-        cache.cache5 = alg_cache(algs[5], args...)
-    end
-    if isbitstype(T6)
-        cache.cache6 = alg_cache(algs[6], args...)
-    end
+    # Eagerly initialize all caches for trim compatibility (the trimmer cannot
+    # resolve lazy alg_cache calls through splatted args).
+    cache.cache1 = alg_cache(algs[1], args...)
+    cache.cache2 = alg_cache(algs[2], args...)
+    cache.cache3 = alg_cache(algs[3], args...)
+    cache.cache4 = alg_cache(algs[4], args...)
+    cache.cache5 = alg_cache(algs[5], args...)
+    cache.cache6 = alg_cache(algs[6], args...)
     return cache
 end
 

lib/OrdinaryDiffEqCore/src/perform_step/composite_perform_step.jl

@@ -1,29 +1,8 @@
+# All caches are now eagerly initialized in alg_cache for
+# CompositeAlgorithm{CS, Tuple{A1..A6}}, so this is a no-op.
+# Kept for API compatibility with callers.
 function init_ith_default_cache(cache::DefaultCache, algs, i)
-    return if i == 1
-        if !isdefined(cache, :cache1)
-            cache.cache1 = alg_cache(algs[1], cache.args...)
-        end
-    elseif i == 2
-        if !isdefined(cache, :cache2)
-            cache.cache2 = alg_cache(algs[2], cache.args...)
-        end
-    elseif i == 3
-        if !isdefined(cache, :cache3)
-            cache.cache3 = alg_cache(algs[3], cache.args...)
-        end
-    elseif i == 4
-        if !isdefined(cache, :cache4)
-            cache.cache4 = alg_cache(algs[4], cache.args...)
-        end
-    elseif i == 5
-        if !isdefined(cache, :cache5)
-            cache.cache5 = alg_cache(algs[5], cache.args...)
-        end
-    elseif i == 6
-        if !isdefined(cache, :cache6)
-            cache.cache6 = alg_cache(algs[6], cache.args...)
-        end
-    end
+    return nothing
 end
 
 function initialize!(integrator, cache::DefaultCache)
@@ -274,11 +253,35 @@ function choose_algorithm!(integrator, cache::DefaultCache)
             old_cache = cache.cache6
         end
 
-        reset_alg_dependent_opts!(integrator, algs[old_current], algs[new_current])
+        # Use static tuple indexing for trim compatibility (the trimmer
+        # cannot resolve dynamic algs[runtime_int] on a heterogeneous tuple).
+        _reset_alg_opts_default!(integrator, algs, old_current, new_current)
         transfer_cache!(integrator, old_cache, new_cache)
     end
 end
 
+# Trim-safe version of reset_alg_dependent_opts! for DefaultCache:
+# enumerates all (old, new) index pairs at compile time so the trimmer
+# sees only statically-resolved tuple indexing.
+@generated function _reset_alg_opts_default!(
+        integrator, algs::T, old_current, new_current
+    ) where {T <: Tuple}
+    n = length(T.types)
+    expr = Expr(:block)
+    for i in 1:n
+        for j in 1:n
+            i == j && continue
+            push!(expr.args, quote
+                if old_current == $i && new_current == $j
+                    return reset_alg_dependent_opts!(integrator, algs[$i], algs[$j])
+                end
+            end)
+        end
+    end
+    push!(expr.args, :(return nothing))
+    return expr
+end
+
 """
 Generic fallback for composite caches that are not CompositeCache or DefaultCache
 (e.g. StochasticCompositeCache). Uses the `is_composite_cache` trait.