Try to make it non-breaking as much as possible

Author: avik-pal

Project.toml

@@ -16,7 +16,6 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 PackageExtensionCompat = "65ce6f38-6b18-4e1d-a461-8949797d7930"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
-SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SciMLOperators = "c0aeaf25-5076-4817-a8d5-81caf7dfa961"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
@@ -50,7 +49,6 @@ LinearAlgebra = "1.6"
 PackageExtensionCompat = "1"
 Random = "1.6"
 Reexport = "1"
-SciMLBase = "2"
 SciMLOperators = "0.3.7"
 Setfield = "1"
 SparseArrays = "1.6"

src/SparseDiffTools.jl

@@ -18,7 +18,7 @@ import ArrayInterface: matrix_colors
 import StaticArrays
 import StaticArrays: StaticArray
 # Others
-using SciMLBase, SciMLOperators, LinearAlgebra, Random
+using SciMLOperators, LinearAlgebra, Random
 import DataStructures: DisjointSets, find_root!, union!
 import SciMLOperators: update_coefficients, update_coefficients!
 import Setfield: @set!

src/differentiation/common.jl

@@ -42,30 +42,50 @@ function JacFunctionWrapper(f::F, fu_, u, p, t) where {F}
     # The warning instead of error ensures a non-breaking change for users relying on an
     # undefined / undocumented feature
     fu = fu_ === nothing ? copy(u) : copy(fu_)
+
+    # Check this first else we were breaking things
+    # In the next breaking release, we will fix the ordering of the checks
+    iip = static_hasmethod(f, typeof((fu, u)))
+    oop = static_hasmethod(f, typeof((u,)))
+    if iip || oop
+        if p !== nothing || t !== nothing
+            Base.depwarn("""`p` and/or `t` provided and are not `nothing`. But we
+            potentially detected `f(du, u)` or `f(u)`. This can be caused by:
+
+            1. `f(du, u)` or `f(u)` is defined, in-which case `p` and/or `t` should not be
+               supplied.
+            2. `f(args...)` is defined, in which case `hasmethod` can be spurious.
+
+            Currently, we perform the check for `f(du, u)` and `f(u)` first, but in future
+            breaking releases, this check will be performed last, which means that if `t`
+            is provided `f(du, u, p, t)`/`f(u, p, t)` will be given precedence, similarly
+            if `p` is provided `f(du, u, p)`/`f(u, p)` will be given precedence.""",
+                :JacFunctionWrapper)
+        end
+        return JacFunctionWrapper{iip, oop, 3, F, typeof(fu), typeof(p), typeof(t)}(f,
+            fu, p, t)
+    end
+
     if t !== nothing
         iip = static_hasmethod(f, typeof((fu, u, p, t)))
         oop = static_hasmethod(f, typeof((u, p, t)))
         if !iip && !oop
-            @warn """`p` and `t` provided but `f(u, p, t)` or `f(fu, u, p, t)` not defined
-            for `f`! Will fallback to `f(u)` or `f(fu, u)`.""" maxlog=1
-        else
-            return JacFunctionWrapper{iip, oop, 1, F, typeof(fu), typeof(p), typeof(t)}(f,
-                fu, p, t)
+            throw(ArgumentError("""`p` and `t` provided but `f(u, p, t)` or `f(fu, u, p, t)`
+            not defined for `f`!"""))
         end
-    elseif p !== nothing && !(p isa SciMLBase.NullParameters)
+        return JacFunctionWrapper{iip, oop, 1, F, typeof(fu), typeof(p), typeof(t)}(f,
+            fu, p, t)
+    elseif p !== nothing
         iip = static_hasmethod(f, typeof((fu, u, p)))
         oop = static_hasmethod(f, typeof((u, p)))
         if !iip && !oop
-            @warn """`p` provided but `f(u, p)` or `f(fu, u, p)` not defined for `f`! Will
-            fallback to `f(u)` or `f(fu, u)`.""" maxlog=1
-        else
-            return JacFunctionWrapper{iip, oop, 2, F, typeof(fu), typeof(p), typeof(t)}(f,
-                fu, p, t)
+            throw(ArgumentError("""`p` is provided but `f(u, p)` or `f(fu, u, p)`
+            not defined for `f`!"""))
         end
+        return JacFunctionWrapper{iip, oop, 2, F, typeof(fu), typeof(p), typeof(t)}(f,
+            fu, p, t)
     end
-    iip = static_hasmethod(f, typeof((fu, u)))
-    oop = static_hasmethod(f, typeof((u,)))
-    !iip && !oop && throw(ArgumentError("`f(u)` or `f(fu, u)` not defined for `f`"))
-    return JacFunctionWrapper{iip, oop, 3, F, typeof(fu), typeof(p), typeof(t)}(f,
-        fu, p, t)
+
+    throw(ArgumentError("""Couldn't determine the function signature of `f` to construct a
+    JacobianWrapper!"""))
 end