Fix FieldError for Magnus/Linear integrators with OrdinaryDiffEqDifferentiation (#3232)

Magnus integrators (MagnusGL6, MagnusGL8, etc.) and other
OrdinaryDiffEqLinearExponentialAlgorithm subtypes have no `autodiff`
field — only `krylov`, `m`, `iop`. When OrdinaryDiffEqDifferentiation
is loaded (e.g. via DifferentialEquations.jl), the generic
`_alg_autodiff(::OrdinaryDiffEqExponentialAlgorithm{CS,AD})` dispatch
would call `alg.autodiff` on these types, causing a FieldError crash.

Fix:
- Import OrdinaryDiffEqLinearExponentialAlgorithm into
  OrdinaryDiffEqDifferentiation
- Add _alg_autodiff(::OrdinaryDiffEqLinearExponentialAlgorithm)
  returning Val{false}(), intercepting calls before the generic
  ExponentialAlgorithm dispatch that accesses the nonexistent field
- The existing prepare_alg override in OrdinaryDiffEqCore (line 298)
  already handles the prepare_alg path correctly

Also adds regression tests verifying _alg_autodiff, prepare_alg, and
forwarddiffs_model all work correctly for LinearExponentialAlgorithm
subtypes.

Author: Harsh Singh

lib/OrdinaryDiffEqDifferentiation/src/OrdinaryDiffEqDifferentiation.jl

@@ -36,6 +36,7 @@ using OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, OrdinaryDiffEqAdaptiveImplici
     OrdinaryDiffEqImplicitAlgorithm, CompositeAlgorithm,
     OrdinaryDiffEqExponentialAlgorithm,
     OrdinaryDiffEqAdaptiveExponentialAlgorithm,
+    OrdinaryDiffEqLinearExponentialAlgorithm,
     StochasticDiffEqNewtonAlgorithm, StochasticDiffEqNewtonAdaptiveAlgorithm,
     StochasticDiffEqJumpNewtonAdaptiveAlgorithm,
     StochasticDiffEqJumpNewtonDiffusionAdaptiveAlgorithm,

lib/OrdinaryDiffEqDifferentiation/src/alg_utils.jl

@@ -32,6 +32,12 @@ function _alg_autodiff(
     ) where {CS, AD, FDT, ST, CJ, Controller}
     return Val{AD}()
 end
+# OrdinaryDiffEqLinearExponentialAlgorithm subtypes (Magnus integrators, LieEuler,
+# CG methods, etc.) have NO autodiff field — their only fields are krylov, m, iop.
+# They must be excluded before the generic ExponentialAlgorithm dispatch below.
+function _alg_autodiff(::OrdinaryDiffEqLinearExponentialAlgorithm)
+    return Val{false}()
+end
 function _alg_autodiff(
         alg::Union{
             OrdinaryDiffEqExponentialAlgorithm{CS, AD},
@@ -66,6 +72,8 @@ Base.@pure function determine_chunksize(u, CS)
     end
 end
 
+
+
 function DiffEqBase.prepare_alg(
         alg::Union{
             OrdinaryDiffEqAdaptiveImplicitAlgorithm{

lib/OrdinaryDiffEqDifferentiation/test/differentiation_traits_tests.jl

@@ -43,3 +43,31 @@ sol = solve(prob2, Rosenbrock23(autodiff = AutoForwardDiff(chunksize = 1)))
 
 sol = solve(prob2, Rosenbrock23(autodiff = AutoFiniteDiff()))
 @test ≈(good_sol[:, end], sol[:, end], rtol = 1.0e-2)
+
+# Regression test for issue #3232:
+# OrdinaryDiffEqLinearExponentialAlgorithm subtypes (MagnusGL6, etc.)
+# have no `autodiff` field; _alg_autodiff and prepare_alg must not crash.
+using OrdinaryDiffEqDifferentiation: _alg_autodiff
+using OrdinaryDiffEqCore: OrdinaryDiffEqLinearExponentialAlgorithm
+using DiffEqBase: prepare_alg
+
+struct MockMagnusAlg <: OrdinaryDiffEqLinearExponentialAlgorithm
+    krylov::Bool
+    m::Int
+    iop::Int
+end
+
+@testset "LinearExponentialAlgorithm autodiff traits (issue #3232)" begin
+    mock = MockMagnusAlg(false, 30, 0)
+
+    # _alg_autodiff must return Val{false}() instead of accessing alg.autodiff
+    @test _alg_autodiff(mock) == Val{false}()
+
+    # prepare_alg must return the algorithm unchanged (no AD preparation needed)
+    u0 = ones(2)
+    mock_prob = ODEProblem((du, u, p, t) -> du .= 0, u0, (0.0, 1.0))
+    @test prepare_alg(mock, u0, nothing, mock_prob) === mock
+
+    # forwarddiffs_model must return false
+    @test SciMLBase.forwarddiffs_model(mock) == false
+end