Remove unnecessary @generated functions for isinplace checks

SciMLBase.isinplace extracts a type parameter and returns a compile-time
constant (true/false). The compiler constant-folds it, so @generated
functions are unnecessary for eliminating dead branches. Regular functions
with if SciMLBase.isinplace(prob) infer identically.

Reverted: incompatible_backend_and_problem, evaluate_f!!, evaluate_f,
should_cache_fx, and prepare_jacobian back to regular functions.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ChrisRackauckas

lib/NonlinearSolveBase/src/autodiff.jl

@@ -105,22 +105,12 @@ function select_jacobian_autodiff(prob::AbstractNonlinearProblem, ::Nothing)
                          or the loaded backends don't support the problem."))
 end
 
-@generated function incompatible_backend_and_problem(
+function incompatible_backend_and_problem(
         prob::AbstractNonlinearProblem, ad::AbstractADType
     )
-    iip = prob <: AbstractNonlinearProblem{<:Any, true}
-    if iip
-        return quote
-            !DI.check_available(ad) && return true
-            !DI.check_inplace(ad) && return true
-            return additional_incompatible_backend_check(prob, ad)
-        end
-    else
-        return quote
-            !DI.check_available(ad) && return true
-            return additional_incompatible_backend_check(prob, ad)
-        end
-    end
+    !DI.check_available(ad) && return true
+    SciMLBase.isinplace(prob) && !DI.check_inplace(ad) && return true
+    return additional_incompatible_backend_check(prob, ad)
 end
 
 additional_incompatible_backend_check(::AbstractNonlinearProblem, ::AbstractADType) = false

lib/NonlinearSolveBase/src/utils.jl

@@ -7,7 +7,7 @@ using LinearAlgebra: LinearAlgebra, Diagonal, Symmetric, norm, dot, cond, diagin
 using MaybeInplace: @bb
 using RecursiveArrayTools: AbstractVectorOfArray, ArrayPartition, recursivecopy!
 using SciMLOperators: AbstractSciMLOperator
-using SciMLBase: SciMLBase, AbstractNonlinearProblem, NonlinearFunction, AbstractNonlinearFunction
+using SciMLBase: SciMLBase, AbstractNonlinearProblem, NonlinearFunction
 using StaticArraysCore: StaticArray, SArray, SMatrix
 
 using ..NonlinearSolveBase: NonlinearSolveBase, L2_NORM, Linf_NORM
@@ -174,33 +174,22 @@ function evaluate_f!!(prob::AbstractNonlinearProblem, fu, u, p = prob.p)
     return evaluate_f!!(prob.f, fu, u, p)
 end
 
-@generated function evaluate_f!!(f::NonlinearFunction, fu, u, p)
-    iip = f <: AbstractNonlinearFunction{true}
-    if iip
-        return quote
-            f(fu, u, p)
-            return fu
-        end
-    else
-        return quote
-            return f(u, p)
-        end
+function evaluate_f!!(f::NonlinearFunction, fu, u, p)
+    if SciMLBase.isinplace(f)
+        f(fu, u, p)
+        return fu
     end
+    return f(u, p)
 end
 
-@generated function evaluate_f(prob::AbstractNonlinearProblem, u)
-    iip = prob <: AbstractNonlinearProblem{<:Any, true}
-    if iip
-        return quote
-            fu = prob.f.resid_prototype === nothing ? similar(u) :
-                similar(prob.f.resid_prototype)
-            prob.f(fu, u, prob.p)
-            return fu
-        end
+function evaluate_f(prob::AbstractNonlinearProblem, u)
+    if SciMLBase.isinplace(prob)
+        fu = prob.f.resid_prototype === nothing ? similar(u) :
+            similar(prob.f.resid_prototype)
+        prob.f(fu, u, prob.p)
+        return fu
     else
-        return quote
-            return prob.f(u, prob.p)
-        end
+        return prob.f(u, prob.p)
     end
 end
 

lib/SimpleNonlinearSolve/src/utils.jl

@@ -19,11 +19,8 @@ const NLBUtils = NonlinearSolveBase.Utils
 end
 
 # GPU-compatible helper to check if fx should be cached
-@generated function should_cache_fx(prob::SciMLBase.AbstractNonlinearProblem, f)
-    iip = prob <: SciMLBase.AbstractNonlinearProblem{<:Any, true}
-    return quote
-        $iip && !SciMLBase.has_jac(f)
-    end
+@inline function should_cache_fx(prob::SciMLBase.AbstractNonlinearProblem, f)
+    return SciMLBase.isinplace(prob) && !SciMLBase.has_jac(f)
 end
 
 function identity_jacobian(u::Number, fu::Number, α = true)
@@ -98,27 +95,21 @@ function prepare_jacobian(prob, autodiff, _, x::Number)
     return DINoPreparation()
 end
 
-@generated function prepare_jacobian(prob, autodiff, fx, x)
-    iip = prob <: SciMLBase.AbstractNonlinearProblem{<:Any, true}
-    if iip
-        return quote
-            SciMLBase.has_jac(prob.f) && return AnalyticJacobian()
-            return DIExtras(
-                DI.prepare_jacobian(
-                    prob.f, fx, autodiff, x, Constant(prob.p), strict = Val(false)
-                )
+function prepare_jacobian(prob, autodiff, fx, x)
+    SciMLBase.has_jac(prob.f) && return AnalyticJacobian()
+    if SciMLBase.isinplace(prob.f)
+        return DIExtras(
+            DI.prepare_jacobian(
+                prob.f, fx, autodiff, x, Constant(prob.p), strict = Val(false)
             )
-        end
+        )
     else
-        return quote
-            SciMLBase.has_jac(prob.f) && return AnalyticJacobian()
-            x isa SArray && return DINoPreparation()
-            return DIExtras(
-                DI.prepare_jacobian(
-                    prob.f, autodiff, x, Constant(prob.p), strict = Val(false)
-                )
+        x isa SArray && return DINoPreparation()
+        return DIExtras(
+            DI.prepare_jacobian(
+                prob.f, autodiff, x, Constant(prob.p), strict = Val(false)
             )
-        end
+        )
     end
 end