From 4cbee4ae8e1ff8e5940159b6368b4d546ba4228b Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Sun, 11 May 2025 22:22:43 -0400
Subject: [PATCH 1/4] fix isinplace inference and add inference tests

---
 src/problems/optimization_problems.jl    |   3 +-
 src/scimlfunctions.jl                    |  22 +-
 test/aqua.jl                             |   2 +-
 test/function_building_error_messages.jl | 270 +++++++++++------------
 4 files changed, 152 insertions(+), 145 deletions(-)

diff --git a/src/problems/optimization_problems.jl b/src/problems/optimization_problems.jl
index 6d6033ea9..cd3d4436b 100644
--- a/src/problems/optimization_problems.jl
+++ b/src/problems/optimization_problems.jl
@@ -131,8 +131,7 @@ function OptimizationProblem(
     OptimizationProblem{isinplace(f)}(f, args...; kwargs...)
 end
 function OptimizationProblem(f, args...; kwargs...)
-    isinplace(f, 2, has_two_dispatches = false)
-    OptimizationProblem{true}(OptimizationFunction{true}(f), args...; kwargs...)
+    OptimizationProblem(OptimizationFunction(f), args...; kwargs...)
 end
 
 function OptimizationFunction(
diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl
index 1b61bd491..97eeeb10a 100644
--- a/src/scimlfunctions.jl
+++ b/src/scimlfunctions.jl
@@ -4199,7 +4199,10 @@ IntervalNonlinearFunction(f::IntervalNonlinearFunction; kwargs...) = f
 struct NoAD <: AbstractADType end
 
 (f::OptimizationFunction)(args...) = f.f(args...)
-OptimizationFunction(args...; kwargs...) = OptimizationFunction{true}(args...; kwargs...)
+function OptimizationFunction(f, args...; kwargs...)
+    isinplace(f, 2, outofplace_param_number=2)
+    OptimizationFunction{true}(f, args...; kwargs...)
+end
 
 function OptimizationFunction{iip}(f, adtype::AbstractADType = NoAD();
         grad = nothing, fg = nothing, hess = nothing, hv = nothing, fgh = nothing,
@@ -4251,8 +4254,9 @@ end
 (f::MultiObjectiveOptimizationFunction)(args...) = f.f(args...)
 
 # Convenience constructor
-function MultiObjectiveOptimizationFunction(args...; kwargs...)
-    MultiObjectiveOptimizationFunction{true}(args...; kwargs...)
+function MultiObjectiveOptimizationFunction(f, args...; kwargs...)
+    isinplace(f, 2, outofplace_param_number=2)
+    MultiObjectiveOptimizationFunction{true}(f, args...; kwargs...)
 end
 
 # Constructor with keyword arguments
@@ -4339,7 +4343,8 @@ function BVPFunction{iip, specialize, twopoint}(f, bc;
         if iip_f
             jac = update_coefficients! #(J,u,p,t)
         else
-            jac = (u, p, t) -> update_coefficients!(deepcopy(jac_prototype), u, p, t)
+            jac_prototype_copy = deepcopy(jac_prototype)
+            jac = (u, p, t) -> update_coefficients!(jac_prototype_copy, u, p, t)
         end
     end
 
@@ -4347,7 +4352,8 @@ function BVPFunction{iip, specialize, twopoint}(f, bc;
         if iip_bc
             bcjac = update_coefficients! #(J,u,p,t)
         else
-            bcjac = (u, p, t) -> update_coefficients!(deepcopy(bcjac_prototype), u, p, t)
+            bcjac_prototype_copy = deepcopy(bcjac_prototype)
+            bcjac = (u, p, t) -> update_coefficients!(bcjac_prototype_copy, u, p, t)
         end
     end
 
@@ -4512,7 +4518,8 @@ function DynamicalBVPFunction{iip, specialize, twopoint}(f, bc;
         if iip_f
             jac = update_coefficients! #(J,u,p,t)
         else
-            jac = (u, p, t) -> update_coefficients!(deepcopy(jac_prototype), u, p, t)
+            jac_prototype_copy = deepcopy(jac_prototype)
+            jac = (u, p, t) -> update_coefficients!(jac_prototype_copy, u, p, t)
         end
     end
 
@@ -4520,7 +4527,8 @@ function DynamicalBVPFunction{iip, specialize, twopoint}(f, bc;
         if iip_bc
             bcjac = update_coefficients! #(J,u,p,t)
         else
-            bcjac = (u, p, t) -> update_coefficients!(deepcopy(bcjac_prototype), u, p, t)
+            bcjac_prototype_copy = deepcopy(jac_prototype)
+            bcjac = (u, p, t) -> update_coefficients!(bcjac_prototype_copy, u, p, t)
         end
     end
 
diff --git a/test/aqua.jl b/test/aqua.jl
index d3bdc5240..0989ee391 100644
--- a/test/aqua.jl
+++ b/test/aqua.jl
@@ -29,7 +29,7 @@ end
     # for method_ambiguity in ambs
     #     @show method_ambiguity
     # end
-    @warn "Number of method ambiguities: $(length(ambs))"
+    !isempty(ambs) &&@warn "Number of method ambiguities: $(length(ambs))"
     @test length(ambs) ≤ 8
 end
 
diff --git a/test/function_building_error_messages.jl b/test/function_building_error_messages.jl
index ee7ee4af7..15141af55 100644
--- a/test/function_building_error_messages.jl
+++ b/test/function_building_error_messages.jl
@@ -54,18 +54,18 @@ ofboth(u, p, t) = u
 ofboth(du, u, p, t) = du .= u
 
 ODEFunction(ofboth)
-ODEFunction{true}(ofboth)
-ODEFunction{false}(ofboth)
+@inferred ODEFunction{true}(ofboth)
+@inferred ODEFunction{false}(ofboth)
 
 jac(u, t) = [1.0]
-@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jac = jac)
+@test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, jac = jac)
 jac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac)
 ODEFunction(foop, jac = jac)
 jac(du, u, p, t) = [1.0]
-ODEFunction(fiip, jac = jac)
-ODEFunction(foop, jac = jac)
+@inferred ODEFunction(fiip, jac = jac)
+@inferred ODEFunction(foop, jac = jac)
 
 Wfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact = Wfact)
@@ -75,10 +75,10 @@ Wfact(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact = Wfact)
 Wfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact = Wfact)
-ODEFunction(foop, Wfact = Wfact)
+@inferred ODEFunction(foop, Wfact = Wfact)
 Wfact(du, u, p, gamma, t) = [1.0]
-ODEFunction(fiip, Wfact = Wfact)
-ODEFunction(foop, Wfact = Wfact)
+@inferred ODEFunction(fiip, Wfact = Wfact)
+@inferred ODEFunction(foop, Wfact = Wfact)
 
 Wfact_t(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t)
@@ -88,10 +88,10 @@ Wfact_t(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact_t = Wfact_t)
 Wfact_t(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact_t = Wfact_t)
-ODEFunction(foop, Wfact_t = Wfact_t)
+@inferred ODEFunction(foop, Wfact_t = Wfact_t)
 Wfact_t(du, u, p, gamma, t) = [1.0]
-ODEFunction(fiip, Wfact_t = Wfact_t)
-ODEFunction(foop, Wfact_t = Wfact_t)
+@inferred ODEFunction(fiip, Wfact_t = Wfact_t)
+@inferred ODEFunction(foop, Wfact_t = Wfact_t)
 
 tgrad(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, tgrad = tgrad)
@@ -100,18 +100,18 @@ tgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, tgrad = tgrad)
 ODEFunction(foop, tgrad = tgrad)
 tgrad(du, u, p, t) = [1.0]
-ODEFunction(fiip, tgrad = tgrad)
-ODEFunction(foop, tgrad = tgrad)
+@inferred ODEFunction(fiip, tgrad = tgrad)
+@inferred ODEFunction(foop, tgrad = tgrad)
 
 paramjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, paramjac = paramjac)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, paramjac = paramjac)
 paramjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, paramjac = paramjac)
-ODEFunction(foop, paramjac = paramjac)
+@inferred ODEFunction(foop, paramjac = paramjac)
 paramjac(du, u, p, t) = [1.0]
-ODEFunction(fiip, paramjac = paramjac)
-ODEFunction(foop, paramjac = paramjac)
+@inferred ODEFunction(fiip, paramjac = paramjac)
+@inferred ODEFunction(foop, paramjac = paramjac)
 
 jvp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jvp = jvp)
@@ -120,18 +120,18 @@ jvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jvp = jvp)
 ODEFunction(foop, jvp = jvp)
 jvp(du, u, v, p, t) = [1.0]
-ODEFunction(fiip, jvp = jvp)
-ODEFunction(foop, jvp = jvp)
+@inferred ODEFunction(fiip, jvp = jvp)
+@inferred ODEFunction(foop, jvp = jvp)
 
 vjp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, vjp = vjp)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, vjp = vjp)
 vjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, vjp = vjp)
-ODEFunction(foop, vjp = vjp)
+@inferred ODEFunction(foop, vjp = vjp)
 vjp(du, u, v, p, t) = [1.0]
-ODEFunction(fiip, vjp = vjp)
-ODEFunction(foop, vjp = vjp)
+@inferred ODEFunction(fiip, vjp = vjp)
+@inferred ODEFunction(foop, vjp = vjp)
 
 # SDE
 
@@ -141,8 +141,8 @@ goop(u, p, t) = u
 fiip(du, u, p, t) = du .= u
 giip(du, u, p, t) = du .= u
 
-SDEFunction(fiip, giip)
-SDEFunction(foop, goop)
+@inferred SDEFunction(fiip, giip)
+@inferred SDEFunction(foop, goop)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(foop, giip)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop)
 
@@ -151,19 +151,19 @@ sfboth(du, u, p, t) = du .= u
 sgboth(u, p, t) = u
 sgboth(du, u, p, t) = du .= u
 
-SDEFunction(sfboth, sgboth)
-SDEFunction{true}(sfboth, sgboth)
-SDEFunction{false}(sfboth, sgboth)
+@inferred SDEFunction(sfboth, sgboth)
+@inferred SDEFunction{true}(sfboth, sgboth)
+@inferred SDEFunction{false}(sfboth, sgboth)
 
 sjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jac = sjac)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jac = sjac)
 sjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jac = sjac)
-SDEFunction(foop, goop, jac = sjac)
+@inferred SDEFunction(foop, goop, jac = sjac)
 sjac(du, u, p, t) = [1.0]
-SDEFunction(fiip, giip, jac = sjac)
-SDEFunction(foop, goop, jac = sjac)
+@inferred SDEFunction(fiip, giip, jac = sjac)
+@inferred SDEFunction(foop, goop, jac = sjac)
 
 sWfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact = sWfact)
@@ -175,10 +175,10 @@ sWfact(u, p, t) = [1.0]
 sWfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, Wfact = sWfact)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop, Wfact = sWfact)
-SDEFunction(foop, goop, Wfact = sWfact)
+@inferred SDEFunction(foop, goop, Wfact = sWfact)
 sWfact(du, u, p, gamma, t) = [1.0]
-SDEFunction(fiip, giip, Wfact = sWfact)
-SDEFunction(foop, goop, Wfact = sWfact)
+@inferred SDEFunction(fiip, giip, Wfact = sWfact)
+@inferred SDEFunction(foop, goop, Wfact = sWfact)
 
 sWfact_t(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t)
@@ -189,7 +189,7 @@ sWfact_t(u, p, t) = [1.0]
 sWfact_t(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip,
     Wfact_t = sWfact_t)
-SDEFunction(foop, goop, Wfact_t = sWfact_t)
+@inferred SDEFunction(foop, goop, Wfact_t = sWfact_t)
 sWfact_t(du, u, p, gamma, t) = [1.0]
 SDEFunction(fiip, giip, Wfact_t = sWfact_t)
 SDEFunction(foop, goop, Wfact_t = sWfact_t)
@@ -199,10 +199,10 @@ stgrad(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, tgrad = stgrad)
 stgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, tgrad = stgrad)
-SDEFunction(foop, goop, tgrad = stgrad)
+@inferred SDEFunction(foop, goop, tgrad = stgrad)
 stgrad(du, u, p, t) = [1.0]
-SDEFunction(fiip, giip, tgrad = stgrad)
-SDEFunction(foop, goop, tgrad = stgrad)
+@inferred SDEFunction(fiip, giip, tgrad = stgrad)
+@inferred SDEFunction(foop, goop, tgrad = stgrad)
 
 sparamjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, paramjac = sparamjac)
@@ -210,38 +210,38 @@ sparamjac(u, t) = [1.0]
 sparamjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip,
     paramjac = sparamjac)
-SDEFunction(foop, goop, paramjac = sparamjac)
+@inferred SDEFunction(foop, goop, paramjac = sparamjac)
 sparamjac(du, u, p, t) = [1.0]
-SDEFunction(fiip, giip, paramjac = sparamjac)
-SDEFunction(foop, goop, paramjac = sparamjac)
+@inferred SDEFunction(fiip, giip, paramjac = sparamjac)
+@inferred SDEFunction(foop, goop, paramjac = sparamjac)
 
 sjvp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jvp = sjvp)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jvp = sjvp)
 sjvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jvp = sjvp)
-SDEFunction(foop, goop, jvp = sjvp)
+@inferred SDEFunction(foop, goop, jvp = sjvp)
 sjvp(du, u, v, p, t) = [1.0]
-SDEFunction(fiip, giip, jvp = sjvp)
-SDEFunction(foop, goop, jvp = sjvp)
+@inferred SDEFunction(fiip, giip, jvp = sjvp)
+@inferred SDEFunction(foop, goop, jvp = sjvp)
 
 svjp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, vjp = svjp)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, vjp = svjp)
 svjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, vjp = svjp)
-SDEFunction(foop, goop, vjp = svjp)
+@inferred SDEFunction(foop, goop, vjp = svjp)
 svjp(du, u, v, p, t) = [1.0]
-SDEFunction(fiip, giip, vjp = svjp)
-SDEFunction(foop, goop, vjp = svjp)
+@inferred SDEFunction(fiip, giip, vjp = svjp)
+@inferred SDEFunction(foop, goop, vjp = svjp)
 
 # RODEFunction
 
 froop(u, p, t, W) = W
 friip(du, p, t, W) = (du .= W)
 
-RODEFunction(froop)
-RODEFunction(friip)
+@inferred RODEFunction(froop)
+@inferred RODEFunction(friip)
 
 frboth(u, p, t, W) = W
 frboth(du, u, p, t, W) = (du .= W)
@@ -270,9 +270,9 @@ dfiip(res, du, u, p, t) = res .= du .+ u
 dfboth(du, u, p, t) = du .+ u
 dfboth(res, du, u, p, t) = res .= du .+ u
 
-DAEFunction(dfboth)
-DAEFunction{true}(dfboth)
-DAEFunction{false}(dfboth)
+@inferred DAEFunction(dfboth)
+@inferred DAEFunction{true}(dfboth)
+@inferred DAEFunction{false}(dfboth)
 
 djac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jac = djac)
@@ -287,8 +287,8 @@ djac(du, u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jac = djac)
 DAEFunction(dfoop, jac = djac)
 djac(res, du, u, p, gamma, t) = [1.0]
-DAEFunction(dfiip, jac = djac)
-DAEFunction(dfoop, jac = djac)
+@inferred DAEFunction(dfiip, jac = djac)
+@inferred DAEFunction(dfoop, jac = djac)
 
 djvp(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp)
@@ -304,10 +304,10 @@ djvp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp)
 djvp(du, u, v, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jvp = djvp)
-DAEFunction(dfoop, jvp = djvp)
+@inferred DAEFunction(dfoop, jvp = djvp)
 djvp(res, du, u, v, p, gamma, t) = [1.0]
-DAEFunction(dfiip, jvp = djvp)
-DAEFunction(dfoop, jvp = djvp)
+@inferred DAEFunction(dfiip, jvp = djvp)
+@inferred DAEFunction(dfoop, jvp = djvp)
 
 dvjp(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp)
@@ -325,9 +325,9 @@ dvjp(du, u, v, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, vjp = dvjp)
 DAEFunction(dfoop, vjp = dvjp)
 dvjp(res, du, u, v, p, gamma, t) = [1.0]
-DAEFunction(dfiip, vjp = dvjp)
-DAEFunction(dfoop, vjp = dvjp)
-DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1)
+@inferred DAEFunction(dfiip, vjp = dvjp)
+@inferred DAEFunction(dfoop, vjp = dvjp)
+@inferred DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1)
 
 # DDEFunction
 
@@ -337,9 +337,9 @@ ddefiip(du, u, h, p, t) = du .= u
 ddeofboth(u, h, p, t) = u
 ddeofboth(du, u, h, p, t) = du .= u
 
-DDEFunction(ddeofboth)
-DDEFunction{true}(ddeofboth)
-DDEFunction{false}(ddeofboth)
+@inferred DDEFunction(ddeofboth)
+@inferred DDEFunction{true}(ddeofboth)
+@inferred DDEFunction{false}(ddeofboth)
 
 ddejac(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, jac = ddejac)
@@ -348,8 +348,8 @@ ddejac(u, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jac = ddejac)
 DDEFunction(ddefoop, jac = ddejac)
 ddejac(du, u, h, p, t) = [1.0]
-DDEFunction(ddefiip, jac = ddejac)
-DDEFunction(ddefoop, jac = ddejac)
+@inferred DDEFunction(ddefiip, jac = ddejac)
+@inferred DDEFunction(ddefoop, jac = ddejac)
 
 ddeWfact(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact)
@@ -359,10 +359,10 @@ ddeWfact(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact)
 ddeWfact(u, h, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, Wfact = ddeWfact)
-DDEFunction(ddefoop, Wfact = ddeWfact)
+@inferred DDEFunction(ddefoop, Wfact = ddeWfact)
 ddeWfact(du, u, h, p, gamma, t) = [1.0]
-DDEFunction(ddefiip, Wfact = ddeWfact)
-DDEFunction(ddefoop, Wfact = ddeWfact)
+@inferred DDEFunction(ddefiip, Wfact = ddeWfact)
+@inferred DDEFunction(ddefoop, Wfact = ddeWfact)
 
 ddeWfact_t(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
@@ -373,20 +373,20 @@ ddeWfact_t(u, h, p, t) = [1.0]
 ddeWfact_t(u, h, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip,
     Wfact_t = ddeWfact_t)
-DDEFunction(ddefoop, Wfact_t = Wfact_t)
+@inferred DDEFunction(ddefoop, Wfact_t = Wfact_t)
 ddeWfact_t(du, u, h, p, gamma, t) = [1.0]
-DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
-DDEFunction(ddefoop, Wfact_t = ddeWfact_t)
+@inferred DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
+@inferred DDEFunction(ddefoop, Wfact_t = ddeWfact_t)
 
 ddetgrad(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, tgrad = ddetgrad)
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, tgrad = ddetgrad)
 ddetgrad(u, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, tgrad = ddetgrad)
-DDEFunction(ddefoop, tgrad = ddetgrad)
+@inferred DDEFunction(ddefoop, tgrad = ddetgrad)
 ddetgrad(du, u, h, p, t) = [1.0]
-DDEFunction(ddefiip, tgrad = ddetgrad)
-DDEFunction(ddefoop, tgrad = ddetgrad)
+@inferred DDEFunction(ddefiip, tgrad = ddetgrad)
+@inferred DDEFunction(ddefoop, tgrad = ddetgrad)
 
 ddeparamjac(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, paramjac = ddeparamjac)
@@ -404,20 +404,20 @@ ddejvp(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, jvp = ddejvp)
 ddejvp(u, v, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jvp = ddejvp)
-DDEFunction(ddefoop, jvp = ddejvp)
+@inferred DDEFunction(ddefoop, jvp = ddejvp)
 ddejvp(du, u, v, h, p, t) = [1.0]
-DDEFunction(ddefiip, jvp = ddejvp)
-DDEFunction(ddefoop, jvp = ddejvp)
+@inferred DDEFunction(ddefiip, jvp = ddejvp)
+@inferred DDEFunction(ddefoop, jvp = ddejvp)
 
 ddevjp(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, vjp = ddevjp)
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, vjp = ddevjp)
 ddevjp(u, v, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, vjp = ddevjp)
-DDEFunction(ddefoop, vjp = ddevjp)
+@inferred DDEFunction(ddefoop, vjp = ddevjp)
 ddevjp(du, u, v, h, p, t) = [1.0]
-DDEFunction(ddefiip, vjp = ddevjp)
-DDEFunction(ddefoop, vjp = ddevjp)
+@inferred DDEFunction(ddefiip, vjp = ddevjp)
+@inferred DDEFunction(ddefoop, vjp = ddevjp)
 
 # NonlinearFunction
 
@@ -427,19 +427,19 @@ nfiip(du, u, p) = du .= u
 nfboth(u, p) = u
 nfboth(du, u, p) = du .= u
 
-NonlinearFunction(nfboth)
-NonlinearFunction{true}(nfboth)
-NonlinearFunction{false}(nfboth)
+@inferred NonlinearFunction(nfboth)
+@inferred NonlinearFunction{true}(nfboth)
+@inferred NonlinearFunction{false}(nfboth)
 
 njac(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jac = njac)
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jac = njac)
 njac(u, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jac = njac)
-NonlinearFunction(nfoop, jac = njac)
+@inferred NonlinearFunction(nfoop, jac = njac)
 njac(du, u, p) = [1.0]
-NonlinearFunction(nfiip, jac = njac)
-NonlinearFunction(nfoop, jac = njac)
+@inferred NonlinearFunction(nfiip, jac = njac)
+@inferred NonlinearFunction(nfoop, jac = njac)
 
 njvp(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jvp = njvp)
@@ -449,10 +449,10 @@ njvp(u, p) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jvp = njvp)
 njvp(u, v, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jvp = njvp)
-NonlinearFunction(nfoop, jvp = njvp)
+@inferred NonlinearFunction(nfoop, jvp = njvp)
 njvp(du, u, v, p) = [1.0]
-NonlinearFunction(nfiip, jvp = njvp)
-NonlinearFunction(nfoop, jvp = njvp)
+@inferred NonlinearFunction(nfiip, jvp = njvp)
+@inferred NonlinearFunction(nfoop, jvp = njvp)
 
 nvjp(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, vjp = nvjp)
@@ -462,10 +462,10 @@ nvjp(u, p) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, vjp = nvjp)
 nvjp(u, v, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, vjp = nvjp)
-NonlinearFunction(nfoop, vjp = nvjp)
+@inferred NonlinearFunction(nfoop, vjp = nvjp)
 nvjp(du, u, v, p) = [1.0]
-NonlinearFunction(nfiip, vjp = nvjp)
-NonlinearFunction(nfoop, vjp = nvjp)
+@inferred NonlinearFunction(nfiip, vjp = nvjp)
+@inferred NonlinearFunction(nfoop, vjp = nvjp)
 
 # Integrals
 intfew(u) = 1.0
@@ -485,16 +485,16 @@ for (f, kws, iip) in (
         (intfiip, (; nout = 3), true),
         (IntegralFunction(intfiip, zeros(3)), (;), true)
     ), domain in (((0.0, 1.0),), (([0.0], [1.0]),), (0.0, 1.0), ([0.0], [1.0]))
-    IntegralProblem(f, domain...; kws...)
-    IntegralProblem(f, domain..., p; kws...)
-    IntegralProblem{iip}(f, domain...; kws...)
-    IntegralProblem{iip}(f, domain..., p; kws...)
+    @inferred IntegralProblem(f, domain...; kws...)
+    @inferred IntegralProblem(f, domain..., p; kws...)
+    @inferred IntegralProblem{iip}(f, domain...; kws...)
+    @inferred IntegralProblem{iip}(f, domain..., p; kws...)
 end
 
 x = [1.0, 2.0]
 y = rand(2, 2)
-SampledIntegralProblem(y, x)
-SampledIntegralProblem(y, x; dim = 2)
+@inferred SampledIntegralProblem(y, x)
+@inferred SampledIntegralProblem(y, x; dim = 2)
 
 # Optimization
 
@@ -502,8 +502,8 @@ optf(u) = 1.0
 @test_throws SciMLBase.TooFewArgumentsError OptimizationFunction(optf)
 @test_throws SciMLBase.TooFewArgumentsError OptimizationProblem(optf, 1.0)
 optf(u, p) = 1.0
-OptimizationFunction(optf)
-OptimizationProblem(optf, 1.0)
+@inferred OptimizationFunction(optf)
+@inferred OptimizationProblem(optf, 1.0)
 
 # BVPFunction
 
@@ -519,9 +519,9 @@ bciip(res, u, p, t) = res .= u
 bcfboth(u, p, t) = u
 bcfboth(du, u, p, t) = du .= u
 
-BVPFunction(bfboth, bcfboth)
-BVPFunction{true}(bfboth, bcfboth)
-BVPFunction{false}(bfboth, bcfboth)
+@inferred BVPFunction(bfboth, bcfboth)
+@inferred BVPFunction{true}(bfboth, bcfboth)
+@inferred BVPFunction{false}(bfboth, bcfboth)
 
 bjac(u, t) = [1.0]
 bcjac(u, t) = [1.0]
@@ -555,10 +555,10 @@ bcjac(u, p, t) = [1.0]
     bciip,
     jac = bjac,
     bcjac = bcjac)
-BVPFunction(bfoop, bcoop, jac = bjac)
+@inferred BVPFunction(bfoop, bcoop, jac = bjac)
 bjac(du, u, p, t) = [1.0]
 bcjac(du, u, p, t) = [1.0]
-BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac)
+@inferred BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     jac = bjac,
@@ -567,7 +567,7 @@ BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac)
     bcoop,
     jac = bjac,
     bcjac = bcjac)
-BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac)
+@inferred BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac)
 
 bWfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact)
@@ -579,7 +579,7 @@ bWfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, Wfact = bWfact)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact)
 bWfact(du, u, p, gamma, t) = [1.0]
-BVPFunction(bfiip, bciip, Wfact = bWfact)
+@inferred BVPFunction(bfiip, bciip, Wfact = bWfact)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact)
 
 bWfact_t(u, t) = [1.0]
@@ -596,7 +596,7 @@ bWfact_t(u, p, gamma, t) = [1.0]
     bciip,
     Wfact_t = bWfact_t)
 bWfact_t(du, u, p, gamma, t) = [1.0]
-BVPFunction(bfiip, bciip, Wfact_t = bWfact_t)
+@inferred BVPFunction(bfiip, bciip, Wfact_t = bWfact_t)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     Wfact_t = bWfact_t)
@@ -608,7 +608,7 @@ btgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, tgrad = btgrad)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad)
 btgrad(du, u, p, t) = [1.0]
-BVPFunction(bfiip, bciip, tgrad = btgrad)
+@inferred BVPFunction(bfiip, bciip, tgrad = btgrad)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad)
 
 bparamjac(u, t) = [1.0]
@@ -622,7 +622,7 @@ bparamjac(u, p, t) = [1.0]
     bciip,
     paramjac = bparamjac)
 bparamjac(du, u, p, t) = [1.0]
-BVPFunction(bfiip, bciip, paramjac = bparamjac)
+@inferred BVPFunction(bfiip, bciip, paramjac = bparamjac)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     paramjac = bparamjac)
@@ -634,7 +634,7 @@ bjvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, jvp = bjvp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp)
 bjvp(du, u, v, p, t) = [1.0]
-BVPFunction(bfiip, bciip, jvp = bjvp)
+@inferred BVPFunction(bfiip, bciip, jvp = bjvp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp)
 
 bvjp(u, p, t) = [1.0]
@@ -644,7 +644,7 @@ bvjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, vjp = bvjp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp)
 bvjp(du, u, v, p, t) = [1.0]
-BVPFunction(bfiip, bciip, vjp = bvjp)
+@inferred BVPFunction(bfiip, bciip, vjp = bvjp)
 
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp)
 
@@ -662,9 +662,9 @@ dbciip(res, du, u, p, t) = res .= du .- u
 dbcfboth(du, u, p, t) = u
 dbcfboth(res, du, u, p, t) = res .= du .- u
 
-DynamicalBVPFunction(dbfboth, dbcfboth)
-DynamicalBVPFunction{true}(dbfboth, dbcfboth)
-DynamicalBVPFunction{false}(dbfboth, dbcfboth)
+@inferred DynamicalBVPFunction(dbfboth, dbcfboth)
+@inferred DynamicalBVPFunction{true}(dbfboth, dbcfboth)
+@inferred DynamicalBVPFunction{false}(dbfboth, dbcfboth)
 
 dbjac(du, u, t) = [1.0]
 dbcjac(du, u, t) = [1.0]
@@ -698,10 +698,10 @@ dbcjac(du, u, p, t) = [1.0]
     dbciip,
     jac = dbjac,
     bcjac = dbcjac)
-DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac)
+@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac)
 dbjac(ddu, du, u, p, t) = [1.0]
 dbcjac(ddu, du, u, p, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     jac = dbjac,
@@ -710,7 +710,7 @@ DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac)
     dbcoop,
     jac = dbjac,
     bcjac = dbcjac)
-DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac)
+@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac)
 
 dbWfact(du, u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(
@@ -728,7 +728,7 @@ dbWfact(du, u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, Wfact = dbWfact)
 dbWfact(ddu, du, u, p, gamma, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, Wfact = dbWfact)
 
@@ -750,7 +750,7 @@ dbWfact_t(du, u, p, gamma, t) = [1.0]
     dbciip,
     Wfact_t = dbWfact_t)
 dbWfact_t(ddu, du, u, p, gamma, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     Wfact_t = dbWfact_t)
@@ -766,7 +766,7 @@ dbtgrad(du, u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, tgrad = dbtgrad)
 dbtgrad(ddu, du, u, p, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, tgrad = dbtgrad)
 
@@ -783,7 +783,7 @@ dbparamjac(du, u, p, t) = [1.0]
     dbciip,
     paramjac = dbparamjac)
 dbparamjac(ddu, du, u, p, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     paramjac = dbparamjac)
@@ -799,7 +799,7 @@ dbjvp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, jvp = dbjvp)
 dbjvp(ddu, du, u, v, p, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, jvp = dbjvp)
 
@@ -814,7 +814,7 @@ dbvjp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, vjp = dbvjp)
 dbvjp(ddu, du, u, v, p, t) = [1.0]
-DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp)
+@inferred DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp)
 
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, vjp = dbvjp)
@@ -826,14 +826,14 @@ iiip(y, u, p) = y .= u * p
 i1(u) = u
 itoo(y, u, p, a) = y .= u * p
 
-IntegralFunction(ioop)
-IntegralFunction(ioop, 0.0)
-IntegralFunction(iiip, Float64[])
+@inferred IntegralFunction(ioop)
+@inferred IntegralFunction(ioop, 0.0)
+@inferred IntegralFunction(iiip, Float64[])
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError IntegralFunction(iiip)
 @test_throws SciMLBase.TooFewArgumentsError IntegralFunction(i1)
-@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo)
-@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo, Float64[])
+@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(itoo)
+@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(itoo, Float64[])
 
 # BatchIntegralFunction
 
@@ -842,14 +842,14 @@ biip(y, u, p) = y .= p .* u
 bi1(u) = u
 bitoo(y, u, p, a) = y .= p .* u
 
-BatchIntegralFunction(boop)
-BatchIntegralFunction(boop, max_batch = 20)
-BatchIntegralFunction(boop, Float64[])
-BatchIntegralFunction(boop, Float64[], max_batch = 20)
-BatchIntegralFunction(biip, Float64[])
-BatchIntegralFunction(biip, Float64[], max_batch = 20)
+@inferred BatchIntegralFunction(boop)
+@inferred BatchIntegralFunction(boop, max_batch = 20)
+@inferred BatchIntegralFunction(boop, Float64[])
+@inferred BatchIntegralFunction(boop, Float64[], max_batch = 20)
+@inferred BatchIntegralFunction(biip, Float64[])
+@inferred BatchIntegralFunction(biip, Float64[], max_batch = 20)
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError BatchIntegralFunction(biip)
 @test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bi1)
-@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo)
-@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo, Float64[])
+@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bitoo)
+@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bitoo, Float64[])

From de658fd4567cc804ee0d3a61356c7dbbca9916d5 Mon Sep 17 00:00:00 2001
From: oscarddssmith <oscar.smith@juliacomputing.com>
Date: Mon, 12 May 2025 12:01:57 -0400
Subject: [PATCH 2/4] fixes

---
 test/function_building_error_messages.jl | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/function_building_error_messages.jl b/test/function_building_error_messages.jl
index 15141af55..a6f6956e1 100644
--- a/test/function_building_error_messages.jl
+++ b/test/function_building_error_messages.jl
@@ -58,7 +58,7 @@ ODEFunction(ofboth)
 @inferred ODEFunction{false}(ofboth)
 
 jac(u, t) = [1.0]
-@test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac)
+@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jac = jac)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, jac = jac)
 jac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac)
@@ -832,8 +832,8 @@ itoo(y, u, p, a) = y .= u * p
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError IntegralFunction(iiip)
 @test_throws SciMLBase.TooFewArgumentsError IntegralFunction(i1)
-@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(itoo)
-@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(itoo, Float64[])
+@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo)
+@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo, Float64[])
 
 # BatchIntegralFunction
 
@@ -851,5 +851,5 @@ bitoo(y, u, p, a) = y .= p .* u
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError BatchIntegralFunction(biip)
 @test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bi1)
-@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bitoo)
-@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bitoo, Float64[])
+@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo)
+@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo, Float64[])

From 95f608bbe9237c9fe09a97bef94c507076ba2adc Mon Sep 17 00:00:00 2001
From: oscarddssmith <oscar.smith@juliacomputing.com>
Date: Mon, 12 May 2025 12:31:20 -0400
Subject: [PATCH 3/4] fixes

---
 test/function_building_error_messages.jl | 244 +++++++++++------------
 1 file changed, 122 insertions(+), 122 deletions(-)

diff --git a/test/function_building_error_messages.jl b/test/function_building_error_messages.jl
index a6f6956e1..931283ebe 100644
--- a/test/function_building_error_messages.jl
+++ b/test/function_building_error_messages.jl
@@ -64,8 +64,8 @@ jac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac)
 ODEFunction(foop, jac = jac)
 jac(du, u, p, t) = [1.0]
-@inferred ODEFunction(fiip, jac = jac)
-@inferred ODEFunction(foop, jac = jac)
+ODEFunction(fiip, jac = jac)
+ODEFunction(foop, jac = jac)
 
 Wfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact = Wfact)
@@ -75,10 +75,10 @@ Wfact(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact = Wfact)
 Wfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact = Wfact)
-@inferred ODEFunction(foop, Wfact = Wfact)
+ODEFunction(foop, Wfact = Wfact)
 Wfact(du, u, p, gamma, t) = [1.0]
-@inferred ODEFunction(fiip, Wfact = Wfact)
-@inferred ODEFunction(foop, Wfact = Wfact)
+ODEFunction(fiip, Wfact = Wfact)
+ODEFunction(foop, Wfact = Wfact)
 
 Wfact_t(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t)
@@ -88,10 +88,10 @@ Wfact_t(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact_t = Wfact_t)
 Wfact_t(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact_t = Wfact_t)
-@inferred ODEFunction(foop, Wfact_t = Wfact_t)
+ODEFunction(foop, Wfact_t = Wfact_t)
 Wfact_t(du, u, p, gamma, t) = [1.0]
-@inferred ODEFunction(fiip, Wfact_t = Wfact_t)
-@inferred ODEFunction(foop, Wfact_t = Wfact_t)
+ODEFunction(fiip, Wfact_t = Wfact_t)
+ODEFunction(foop, Wfact_t = Wfact_t)
 
 tgrad(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, tgrad = tgrad)
@@ -100,18 +100,18 @@ tgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, tgrad = tgrad)
 ODEFunction(foop, tgrad = tgrad)
 tgrad(du, u, p, t) = [1.0]
-@inferred ODEFunction(fiip, tgrad = tgrad)
-@inferred ODEFunction(foop, tgrad = tgrad)
+ODEFunction(fiip, tgrad = tgrad)
+ODEFunction(foop, tgrad = tgrad)
 
 paramjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, paramjac = paramjac)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, paramjac = paramjac)
 paramjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, paramjac = paramjac)
-@inferred ODEFunction(foop, paramjac = paramjac)
+ODEFunction(foop, paramjac = paramjac)
 paramjac(du, u, p, t) = [1.0]
-@inferred ODEFunction(fiip, paramjac = paramjac)
-@inferred ODEFunction(foop, paramjac = paramjac)
+ODEFunction(fiip, paramjac = paramjac)
+ODEFunction(foop, paramjac = paramjac)
 
 jvp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jvp = jvp)
@@ -120,18 +120,18 @@ jvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jvp = jvp)
 ODEFunction(foop, jvp = jvp)
 jvp(du, u, v, p, t) = [1.0]
-@inferred ODEFunction(fiip, jvp = jvp)
-@inferred ODEFunction(foop, jvp = jvp)
+ODEFunction(fiip, jvp = jvp)
+ODEFunction(foop, jvp = jvp)
 
 vjp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, vjp = vjp)
 @test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, vjp = vjp)
 vjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, vjp = vjp)
-@inferred ODEFunction(foop, vjp = vjp)
+ODEFunction(foop, vjp = vjp)
 vjp(du, u, v, p, t) = [1.0]
-@inferred ODEFunction(fiip, vjp = vjp)
-@inferred ODEFunction(foop, vjp = vjp)
+ODEFunction(fiip, vjp = vjp)
+ODEFunction(foop, vjp = vjp)
 
 # SDE
 
@@ -141,8 +141,8 @@ goop(u, p, t) = u
 fiip(du, u, p, t) = du .= u
 giip(du, u, p, t) = du .= u
 
-@inferred SDEFunction(fiip, giip)
-@inferred SDEFunction(foop, goop)
+SDEFunction(fiip, giip)
+SDEFunction(foop, goop)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(foop, giip)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop)
 
@@ -151,19 +151,19 @@ sfboth(du, u, p, t) = du .= u
 sgboth(u, p, t) = u
 sgboth(du, u, p, t) = du .= u
 
-@inferred SDEFunction(sfboth, sgboth)
-@inferred SDEFunction{true}(sfboth, sgboth)
-@inferred SDEFunction{false}(sfboth, sgboth)
+SDEFunction(sfboth, sgboth)
+SDEFunction{true}(sfboth, sgboth)
+SDEFunction{false}(sfboth, sgboth)
 
 sjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jac = sjac)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jac = sjac)
 sjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jac = sjac)
-@inferred SDEFunction(foop, goop, jac = sjac)
+SDEFunction(foop, goop, jac = sjac)
 sjac(du, u, p, t) = [1.0]
-@inferred SDEFunction(fiip, giip, jac = sjac)
-@inferred SDEFunction(foop, goop, jac = sjac)
+SDEFunction(fiip, giip, jac = sjac)
+SDEFunction(foop, goop, jac = sjac)
 
 sWfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact = sWfact)
@@ -175,10 +175,10 @@ sWfact(u, p, t) = [1.0]
 sWfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, Wfact = sWfact)
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop, Wfact = sWfact)
-@inferred SDEFunction(foop, goop, Wfact = sWfact)
+SDEFunction(foop, goop, Wfact = sWfact)
 sWfact(du, u, p, gamma, t) = [1.0]
-@inferred SDEFunction(fiip, giip, Wfact = sWfact)
-@inferred SDEFunction(foop, goop, Wfact = sWfact)
+SDEFunction(fiip, giip, Wfact = sWfact)
+SDEFunction(foop, goop, Wfact = sWfact)
 
 sWfact_t(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t)
@@ -189,7 +189,7 @@ sWfact_t(u, p, t) = [1.0]
 sWfact_t(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip,
     Wfact_t = sWfact_t)
-@inferred SDEFunction(foop, goop, Wfact_t = sWfact_t)
+SDEFunction(foop, goop, Wfact_t = sWfact_t)
 sWfact_t(du, u, p, gamma, t) = [1.0]
 SDEFunction(fiip, giip, Wfact_t = sWfact_t)
 SDEFunction(foop, goop, Wfact_t = sWfact_t)
@@ -199,10 +199,10 @@ stgrad(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, tgrad = stgrad)
 stgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, tgrad = stgrad)
-@inferred SDEFunction(foop, goop, tgrad = stgrad)
+SDEFunction(foop, goop, tgrad = stgrad)
 stgrad(du, u, p, t) = [1.0]
-@inferred SDEFunction(fiip, giip, tgrad = stgrad)
-@inferred SDEFunction(foop, goop, tgrad = stgrad)
+SDEFunction(fiip, giip, tgrad = stgrad)
+SDEFunction(foop, goop, tgrad = stgrad)
 
 sparamjac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, paramjac = sparamjac)
@@ -210,38 +210,38 @@ sparamjac(u, t) = [1.0]
 sparamjac(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip,
     paramjac = sparamjac)
-@inferred SDEFunction(foop, goop, paramjac = sparamjac)
+SDEFunction(foop, goop, paramjac = sparamjac)
 sparamjac(du, u, p, t) = [1.0]
-@inferred SDEFunction(fiip, giip, paramjac = sparamjac)
-@inferred SDEFunction(foop, goop, paramjac = sparamjac)
+SDEFunction(fiip, giip, paramjac = sparamjac)
+SDEFunction(foop, goop, paramjac = sparamjac)
 
 sjvp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jvp = sjvp)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jvp = sjvp)
 sjvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jvp = sjvp)
-@inferred SDEFunction(foop, goop, jvp = sjvp)
+SDEFunction(foop, goop, jvp = sjvp)
 sjvp(du, u, v, p, t) = [1.0]
-@inferred SDEFunction(fiip, giip, jvp = sjvp)
-@inferred SDEFunction(foop, goop, jvp = sjvp)
+SDEFunction(fiip, giip, jvp = sjvp)
+SDEFunction(foop, goop, jvp = sjvp)
 
 svjp(u, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, vjp = svjp)
 @test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, vjp = svjp)
 svjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, vjp = svjp)
-@inferred SDEFunction(foop, goop, vjp = svjp)
+SDEFunction(foop, goop, vjp = svjp)
 svjp(du, u, v, p, t) = [1.0]
-@inferred SDEFunction(fiip, giip, vjp = svjp)
-@inferred SDEFunction(foop, goop, vjp = svjp)
+SDEFunction(fiip, giip, vjp = svjp)
+SDEFunction(foop, goop, vjp = svjp)
 
 # RODEFunction
 
 froop(u, p, t, W) = W
 friip(du, p, t, W) = (du .= W)
 
-@inferred RODEFunction(froop)
-@inferred RODEFunction(friip)
+RODEFunction(froop)
+RODEFunction(friip)
 
 frboth(u, p, t, W) = W
 frboth(du, u, p, t, W) = (du .= W)
@@ -270,9 +270,9 @@ dfiip(res, du, u, p, t) = res .= du .+ u
 dfboth(du, u, p, t) = du .+ u
 dfboth(res, du, u, p, t) = res .= du .+ u
 
-@inferred DAEFunction(dfboth)
-@inferred DAEFunction{true}(dfboth)
-@inferred DAEFunction{false}(dfboth)
+DAEFunction(dfboth)
+DAEFunction{true}(dfboth)
+DAEFunction{false}(dfboth)
 
 djac(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jac = djac)
@@ -287,8 +287,8 @@ djac(du, u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jac = djac)
 DAEFunction(dfoop, jac = djac)
 djac(res, du, u, p, gamma, t) = [1.0]
-@inferred DAEFunction(dfiip, jac = djac)
-@inferred DAEFunction(dfoop, jac = djac)
+DAEFunction(dfiip, jac = djac)
+DAEFunction(dfoop, jac = djac)
 
 djvp(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp)
@@ -304,10 +304,10 @@ djvp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp)
 djvp(du, u, v, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jvp = djvp)
-@inferred DAEFunction(dfoop, jvp = djvp)
+DAEFunction(dfoop, jvp = djvp)
 djvp(res, du, u, v, p, gamma, t) = [1.0]
-@inferred DAEFunction(dfiip, jvp = djvp)
-@inferred DAEFunction(dfoop, jvp = djvp)
+DAEFunction(dfiip, jvp = djvp)
+DAEFunction(dfoop, jvp = djvp)
 
 dvjp(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp)
@@ -325,9 +325,9 @@ dvjp(du, u, v, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, vjp = dvjp)
 DAEFunction(dfoop, vjp = dvjp)
 dvjp(res, du, u, v, p, gamma, t) = [1.0]
-@inferred DAEFunction(dfiip, vjp = dvjp)
-@inferred DAEFunction(dfoop, vjp = dvjp)
-@inferred DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1)
+DAEFunction(dfiip, vjp = dvjp)
+DAEFunction(dfoop, vjp = dvjp)
+DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1)
 
 # DDEFunction
 
@@ -337,9 +337,9 @@ ddefiip(du, u, h, p, t) = du .= u
 ddeofboth(u, h, p, t) = u
 ddeofboth(du, u, h, p, t) = du .= u
 
-@inferred DDEFunction(ddeofboth)
-@inferred DDEFunction{true}(ddeofboth)
-@inferred DDEFunction{false}(ddeofboth)
+DDEFunction(ddeofboth)
+DDEFunction{true}(ddeofboth)
+DDEFunction{false}(ddeofboth)
 
 ddejac(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, jac = ddejac)
@@ -348,8 +348,8 @@ ddejac(u, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jac = ddejac)
 DDEFunction(ddefoop, jac = ddejac)
 ddejac(du, u, h, p, t) = [1.0]
-@inferred DDEFunction(ddefiip, jac = ddejac)
-@inferred DDEFunction(ddefoop, jac = ddejac)
+DDEFunction(ddefiip, jac = ddejac)
+DDEFunction(ddefoop, jac = ddejac)
 
 ddeWfact(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact)
@@ -359,10 +359,10 @@ ddeWfact(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact)
 ddeWfact(u, h, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, Wfact = ddeWfact)
-@inferred DDEFunction(ddefoop, Wfact = ddeWfact)
+DDEFunction(ddefoop, Wfact = ddeWfact)
 ddeWfact(du, u, h, p, gamma, t) = [1.0]
-@inferred DDEFunction(ddefiip, Wfact = ddeWfact)
-@inferred DDEFunction(ddefoop, Wfact = ddeWfact)
+DDEFunction(ddefiip, Wfact = ddeWfact)
+DDEFunction(ddefoop, Wfact = ddeWfact)
 
 ddeWfact_t(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
@@ -373,20 +373,20 @@ ddeWfact_t(u, h, p, t) = [1.0]
 ddeWfact_t(u, h, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip,
     Wfact_t = ddeWfact_t)
-@inferred DDEFunction(ddefoop, Wfact_t = Wfact_t)
+DDEFunction(ddefoop, Wfact_t = Wfact_t)
 ddeWfact_t(du, u, h, p, gamma, t) = [1.0]
-@inferred DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
-@inferred DDEFunction(ddefoop, Wfact_t = ddeWfact_t)
+DDEFunction(ddefiip, Wfact_t = ddeWfact_t)
+DDEFunction(ddefoop, Wfact_t = ddeWfact_t)
 
 ddetgrad(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, tgrad = ddetgrad)
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, tgrad = ddetgrad)
 ddetgrad(u, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, tgrad = ddetgrad)
-@inferred DDEFunction(ddefoop, tgrad = ddetgrad)
+DDEFunction(ddefoop, tgrad = ddetgrad)
 ddetgrad(du, u, h, p, t) = [1.0]
-@inferred DDEFunction(ddefiip, tgrad = ddetgrad)
-@inferred DDEFunction(ddefoop, tgrad = ddetgrad)
+DDEFunction(ddefiip, tgrad = ddetgrad)
+DDEFunction(ddefoop, tgrad = ddetgrad)
 
 ddeparamjac(u, h, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, paramjac = ddeparamjac)
@@ -404,20 +404,20 @@ ddejvp(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, jvp = ddejvp)
 ddejvp(u, v, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jvp = ddejvp)
-@inferred DDEFunction(ddefoop, jvp = ddejvp)
+DDEFunction(ddefoop, jvp = ddejvp)
 ddejvp(du, u, v, h, p, t) = [1.0]
-@inferred DDEFunction(ddefiip, jvp = ddejvp)
-@inferred DDEFunction(ddefoop, jvp = ddejvp)
+DDEFunction(ddefiip, jvp = ddejvp)
+DDEFunction(ddefoop, jvp = ddejvp)
 
 ddevjp(u, h, p, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, vjp = ddevjp)
 @test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, vjp = ddevjp)
 ddevjp(u, v, h, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, vjp = ddevjp)
-@inferred DDEFunction(ddefoop, vjp = ddevjp)
+DDEFunction(ddefoop, vjp = ddevjp)
 ddevjp(du, u, v, h, p, t) = [1.0]
-@inferred DDEFunction(ddefiip, vjp = ddevjp)
-@inferred DDEFunction(ddefoop, vjp = ddevjp)
+DDEFunction(ddefiip, vjp = ddevjp)
+DDEFunction(ddefoop, vjp = ddevjp)
 
 # NonlinearFunction
 
@@ -427,7 +427,7 @@ nfiip(du, u, p) = du .= u
 nfboth(u, p) = u
 nfboth(du, u, p) = du .= u
 
-@inferred NonlinearFunction(nfboth)
+NonlinearFunction(nfboth)
 @inferred NonlinearFunction{true}(nfboth)
 @inferred NonlinearFunction{false}(nfboth)
 
@@ -436,10 +436,10 @@ njac(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jac = njac)
 njac(u, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jac = njac)
-@inferred NonlinearFunction(nfoop, jac = njac)
+NonlinearFunction(nfoop, jac = njac)
 njac(du, u, p) = [1.0]
-@inferred NonlinearFunction(nfiip, jac = njac)
-@inferred NonlinearFunction(nfoop, jac = njac)
+NonlinearFunction(nfiip, jac = njac)
+NonlinearFunction(nfoop, jac = njac)
 
 njvp(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jvp = njvp)
@@ -449,10 +449,10 @@ njvp(u, p) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jvp = njvp)
 njvp(u, v, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jvp = njvp)
-@inferred NonlinearFunction(nfoop, jvp = njvp)
+NonlinearFunction(nfoop, jvp = njvp)
 njvp(du, u, v, p) = [1.0]
-@inferred NonlinearFunction(nfiip, jvp = njvp)
-@inferred NonlinearFunction(nfoop, jvp = njvp)
+NonlinearFunction(nfiip, jvp = njvp)
+NonlinearFunction(nfoop, jvp = njvp)
 
 nvjp(u) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, vjp = nvjp)
@@ -462,10 +462,10 @@ nvjp(u, p) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, vjp = nvjp)
 nvjp(u, v, p) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, vjp = nvjp)
-@inferred NonlinearFunction(nfoop, vjp = nvjp)
+NonlinearFunction(nfoop, vjp = nvjp)
 nvjp(du, u, v, p) = [1.0]
-@inferred NonlinearFunction(nfiip, vjp = nvjp)
-@inferred NonlinearFunction(nfoop, vjp = nvjp)
+NonlinearFunction(nfiip, vjp = nvjp)
+NonlinearFunction(nfoop, vjp = nvjp)
 
 # Integrals
 intfew(u) = 1.0
@@ -485,16 +485,16 @@ for (f, kws, iip) in (
         (intfiip, (; nout = 3), true),
         (IntegralFunction(intfiip, zeros(3)), (;), true)
     ), domain in (((0.0, 1.0),), (([0.0], [1.0]),), (0.0, 1.0), ([0.0], [1.0]))
-    @inferred IntegralProblem(f, domain...; kws...)
-    @inferred IntegralProblem(f, domain..., p; kws...)
-    @inferred IntegralProblem{iip}(f, domain...; kws...)
-    @inferred IntegralProblem{iip}(f, domain..., p; kws...)
+    IntegralProblem(f, domain...; kws...)
+    IntegralProblem(f, domain..., p; kws...)
+    IntegralProblem{iip}(f, domain...; kws...)
+    IntegralProblem{iip}(f, domain..., p; kws...)
 end
 
 x = [1.0, 2.0]
 y = rand(2, 2)
-@inferred SampledIntegralProblem(y, x)
-@inferred SampledIntegralProblem(y, x; dim = 2)
+SampledIntegralProblem(y, x)
+SampledIntegralProblem(y, x; dim = 2)
 
 # Optimization
 
@@ -502,8 +502,8 @@ optf(u) = 1.0
 @test_throws SciMLBase.TooFewArgumentsError OptimizationFunction(optf)
 @test_throws SciMLBase.TooFewArgumentsError OptimizationProblem(optf, 1.0)
 optf(u, p) = 1.0
-@inferred OptimizationFunction(optf)
-@inferred OptimizationProblem(optf, 1.0)
+OptimizationFunction(optf)
+OptimizationProblem(optf, 1.0)
 
 # BVPFunction
 
@@ -519,7 +519,7 @@ bciip(res, u, p, t) = res .= u
 bcfboth(u, p, t) = u
 bcfboth(du, u, p, t) = du .= u
 
-@inferred BVPFunction(bfboth, bcfboth)
+BVPFunction(bfboth, bcfboth)
 @inferred BVPFunction{true}(bfboth, bcfboth)
 @inferred BVPFunction{false}(bfboth, bcfboth)
 
@@ -555,10 +555,10 @@ bcjac(u, p, t) = [1.0]
     bciip,
     jac = bjac,
     bcjac = bcjac)
-@inferred BVPFunction(bfoop, bcoop, jac = bjac)
+BVPFunction(bfoop, bcoop, jac = bjac)
 bjac(du, u, p, t) = [1.0]
 bcjac(du, u, p, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac)
+BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     jac = bjac,
@@ -567,7 +567,7 @@ bcjac(du, u, p, t) = [1.0]
     bcoop,
     jac = bjac,
     bcjac = bcjac)
-@inferred BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac)
+BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac)
 
 bWfact(u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact)
@@ -579,7 +579,7 @@ bWfact(u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, Wfact = bWfact)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact)
 bWfact(du, u, p, gamma, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, Wfact = bWfact)
+BVPFunction(bfiip, bciip, Wfact = bWfact)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact)
 
 bWfact_t(u, t) = [1.0]
@@ -596,7 +596,7 @@ bWfact_t(u, p, gamma, t) = [1.0]
     bciip,
     Wfact_t = bWfact_t)
 bWfact_t(du, u, p, gamma, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, Wfact_t = bWfact_t)
+BVPFunction(bfiip, bciip, Wfact_t = bWfact_t)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     Wfact_t = bWfact_t)
@@ -608,7 +608,7 @@ btgrad(u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, tgrad = btgrad)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad)
 btgrad(du, u, p, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, tgrad = btgrad)
+BVPFunction(bfiip, bciip, tgrad = btgrad)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad)
 
 bparamjac(u, t) = [1.0]
@@ -622,7 +622,7 @@ bparamjac(u, p, t) = [1.0]
     bciip,
     paramjac = bparamjac)
 bparamjac(du, u, p, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, paramjac = bparamjac)
+BVPFunction(bfiip, bciip, paramjac = bparamjac)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop,
     bciip,
     paramjac = bparamjac)
@@ -634,7 +634,7 @@ bjvp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, jvp = bjvp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp)
 bjvp(du, u, v, p, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, jvp = bjvp)
+BVPFunction(bfiip, bciip, jvp = bjvp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp)
 
 bvjp(u, p, t) = [1.0]
@@ -644,7 +644,7 @@ bvjp(u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, vjp = bvjp)
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp)
 bvjp(du, u, v, p, t) = [1.0]
-@inferred BVPFunction(bfiip, bciip, vjp = bvjp)
+BVPFunction(bfiip, bciip, vjp = bvjp)
 
 @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp)
 
@@ -662,7 +662,7 @@ dbciip(res, du, u, p, t) = res .= du .- u
 dbcfboth(du, u, p, t) = u
 dbcfboth(res, du, u, p, t) = res .= du .- u
 
-@inferred DynamicalBVPFunction(dbfboth, dbcfboth)
+DynamicalBVPFunction(dbfboth, dbcfboth)
 @inferred DynamicalBVPFunction{true}(dbfboth, dbcfboth)
 @inferred DynamicalBVPFunction{false}(dbfboth, dbcfboth)
 
@@ -698,10 +698,10 @@ dbcjac(du, u, p, t) = [1.0]
     dbciip,
     jac = dbjac,
     bcjac = dbcjac)
-@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac)
+DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac)
 dbjac(ddu, du, u, p, t) = [1.0]
 dbcjac(ddu, du, u, p, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac)
+DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     jac = dbjac,
@@ -710,7 +710,7 @@ dbcjac(ddu, du, u, p, t) = [1.0]
     dbcoop,
     jac = dbjac,
     bcjac = dbcjac)
-@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac)
+DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac)
 
 dbWfact(du, u, t) = [1.0]
 @test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(
@@ -728,7 +728,7 @@ dbWfact(du, u, p, gamma, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, Wfact = dbWfact)
 dbWfact(ddu, du, u, p, gamma, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact)
+DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, Wfact = dbWfact)
 
@@ -750,7 +750,7 @@ dbWfact_t(du, u, p, gamma, t) = [1.0]
     dbciip,
     Wfact_t = dbWfact_t)
 dbWfact_t(ddu, du, u, p, gamma, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t)
+DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     Wfact_t = dbWfact_t)
@@ -766,7 +766,7 @@ dbtgrad(du, u, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, tgrad = dbtgrad)
 dbtgrad(ddu, du, u, p, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad)
+DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, tgrad = dbtgrad)
 
@@ -783,7 +783,7 @@ dbparamjac(du, u, p, t) = [1.0]
     dbciip,
     paramjac = dbparamjac)
 dbparamjac(ddu, du, u, p, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac)
+DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop,
     dbciip,
     paramjac = dbparamjac)
@@ -799,7 +799,7 @@ dbjvp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, jvp = dbjvp)
 dbjvp(ddu, du, u, v, p, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp)
+DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp)
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, jvp = dbjvp)
 
@@ -814,7 +814,7 @@ dbvjp(du, u, v, p, t) = [1.0]
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, vjp = dbvjp)
 dbvjp(ddu, du, u, v, p, t) = [1.0]
-@inferred DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp)
+DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp)
 
 @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(
     dbfoop, dbciip, vjp = dbvjp)
@@ -826,9 +826,9 @@ iiip(y, u, p) = y .= u * p
 i1(u) = u
 itoo(y, u, p, a) = y .= u * p
 
-@inferred IntegralFunction(ioop)
-@inferred IntegralFunction(ioop, 0.0)
-@inferred IntegralFunction(iiip, Float64[])
+IntegralFunction(ioop)
+IntegralFunction(ioop, 0.0)
+IntegralFunction(iiip, Float64[])
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError IntegralFunction(iiip)
 @test_throws SciMLBase.TooFewArgumentsError IntegralFunction(i1)
@@ -842,12 +842,12 @@ biip(y, u, p) = y .= p .* u
 bi1(u) = u
 bitoo(y, u, p, a) = y .= p .* u
 
-@inferred BatchIntegralFunction(boop)
-@inferred BatchIntegralFunction(boop, max_batch = 20)
-@inferred BatchIntegralFunction(boop, Float64[])
-@inferred BatchIntegralFunction(boop, Float64[], max_batch = 20)
-@inferred BatchIntegralFunction(biip, Float64[])
-@inferred BatchIntegralFunction(biip, Float64[], max_batch = 20)
+BatchIntegralFunction(boop)
+BatchIntegralFunction(boop, max_batch = 20)
+BatchIntegralFunction(boop, Float64[])
+BatchIntegralFunction(boop, Float64[], max_batch = 20)
+BatchIntegralFunction(biip, Float64[])
+BatchIntegralFunction(biip, Float64[], max_batch = 20)
 
 @test_throws SciMLBase.IntegrandMismatchFunctionError BatchIntegralFunction(biip)
 @test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bi1)

From 4b195f587bd1acd8f327cab4583efac467ecfa98 Mon Sep 17 00:00:00 2001
From: oscarddssmith <oscar.smith@juliacomputing.com>
Date: Mon, 12 May 2025 13:18:42 -0400
Subject: [PATCH 4/4] address review

---
 src/scimlfunctions.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl
index 97eeeb10a..9704ccbce 100644
--- a/src/scimlfunctions.jl
+++ b/src/scimlfunctions.jl
@@ -948,7 +948,7 @@ dt: the time step
 
 ```julia
 ImplicitDiscreteFunction{iip,specialize}(f;
-                                analytic = __has_analytic(f) ? f.analytic : nothing, 
+                                analytic = __has_analytic(f) ? f.analytic : nothing,
                                 resid_prototype = __has_resid_prototype(f) ? f.resid_prototype : nothing)
 ```
 
@@ -2107,7 +2107,7 @@ A representation of a ODE function `f` with inputs, defined by:
 ```math
 \frac{dx}{dt} = f(x, u, p, t)
 ```
-where `x` are the states of the system and `u` are the inputs (which may represent 
+where `x` are the states of the system and `u` are the inputs (which may represent
 different things in different contexts, such as control variables in optimal control).
 
 Includes all of its related functions, such as the Jacobian of `f`, its gradient
@@ -2134,7 +2134,7 @@ ODEInputFunction{iip, specialize}(f;
     sys = __has_sys(f) ? f.sys : nothing)
 ```
 
-`f` should be given as `f(x_out,x,u,p,t)` or `out = f(x,u,p,t)`. 
+`f` should be given as `f(x_out,x,u,p,t)` or `out = f(x,u,p,t)`.
 See the section on `iip` for more details on in-place vs out-of-place handling.
 
 - `mass_matrix`: the mass matrix `M` represented in the BVP function. Can be used
@@ -4255,7 +4255,7 @@ end
 
 # Convenience constructor
 function MultiObjectiveOptimizationFunction(f, args...; kwargs...)
-    isinplace(f, 2, outofplace_param_number=2)
+    isinplace(f, 3)
     MultiObjectiveOptimizationFunction{true}(f, args...; kwargs...)
 end