fix: resolve ModelingToolkitBase method ambiguities (#4849)

Co-authored-by: ChrisRackauckas-Claude <accounts@chrisrackauckas.com>

Author: ChrisRackauckas-Claude

lib/ModelingToolkitBase/src/deprecations.jl

@@ -113,6 +113,24 @@ for T in [
             """
             return $T{iip, spec}(sys, merge($uCanonical, $pCanonical), tspan; kw...)
         end
+        if T === :ODEProblem
+            @eval function SciMLBase.ODEProblem{
+                    iip, SciMLBase.FunctionWrapperSpecialize,
+                }(
+                    sys::System, u0::$uType, tspan, p::$pType; kw...
+                ) where {iip}
+                ctor = string(ODEProblem{iip, SciMLBase.FunctionWrapperSpecialize})
+                uCan = string($(QuoteNode(uCanonical)))
+                pCan = string($(QuoteNode(pCanonical)))
+                @warn """
+                `$ctor(sys, u0, tspan, p; kw...)` is deprecated. Use
+                `$ctor(sys, merge($uCan, $pCan), tspan)` instead.
+                """
+                return ODEProblem{iip, SciMLBase.FunctionWrapperSpecialize}(
+                    sys, merge($uCanonical, $pCanonical), tspan; kw...
+                )
+            end
+        end
     end
 
     for pType in [SciMLBase.NullParameters, Nothing], uType in [Any, Nothing]
@@ -148,6 +166,23 @@ for T in [
             """
             return $T{iip, spec}(sys, u0, tspan; kw...)
         end
+        if T === :ODEProblem
+            @eval function SciMLBase.ODEProblem{
+                    iip, SciMLBase.FunctionWrapperSpecialize,
+                }(
+                    sys::System, u0::$uType, tspan, p::$pType; kw...
+                ) where {iip}
+                ctor = string(ODEProblem{iip, SciMLBase.FunctionWrapperSpecialize})
+                pT = string($(QuoteNode(pType)))
+                @warn """
+                `$ctor(sys, u0, tspan, p::$pT; kw...)` is deprecated. Use
+                `$ctor(sys, u0, tspan)` instead.
+                """
+                return ODEProblem{iip, SciMLBase.FunctionWrapperSpecialize}(
+                    sys, u0, tspan; kw...
+                )
+            end
+        end
     end
 end
 

lib/ModelingToolkitBase/src/problems/odeproblem.jl

@@ -116,8 +116,8 @@ function SciMLBase.ODEFunction{iip, spec}(
     return odefn
 end
 
-Base.@nospecializeinfer @fallback_iip_specialize function SciMLBase.ODEProblem{iip, spec}(
-        sys::System, @nospecialize(op), tspan;
+Base.@nospecializeinfer function _ode_problem(
+        ::Type{ODEProblem{iip, spec}}, sys::System, @nospecialize(op), tspan;
         @nospecialize(callback = nothing), check_length = true, eval_expression = false,
         expression = Val{false}, eval_module = @__MODULE__, check_compatibility = true,
         _skip_events = false, kwargs...
@@ -146,7 +146,36 @@ Base.@nospecializeinfer @fallback_iip_specialize function SciMLBase.ODEProblem{i
 
     ptype = getmetadata(sys, ProblemTypeCtx, StandardODEProblem())
     args = (; f, u0, tspan, p, ptype)
-    maybe_codegen_scimlproblem(expression, ODEProblem{_iip}, args; kwargs...)
+    return maybe_codegen_scimlproblem(expression, ODEProblem{_iip}, args; kwargs...)
+end
+
+Base.@nospecializeinfer @fallback_iip_specialize function SciMLBase.ODEProblem{iip, spec}(
+        sys::System, @nospecialize(op), tspan;
+        @nospecialize(callback = nothing), check_length = true, eval_expression = false,
+        expression = Val{false}, eval_module = @__MODULE__, check_compatibility = true,
+        _skip_events = false, kwargs...
+    ) where {iip, spec}
+    return _ode_problem(
+        ODEProblem{iip, spec}, sys, op, tspan;
+        callback, check_length, eval_expression, expression, eval_module, check_compatibility,
+        _skip_events, kwargs...
+    )
+end
+
+# SciMLBase also defines this fixed-specialization constructor for arbitrary functions.
+Base.@nospecializeinfer function SciMLBase.ODEProblem{
+        iip, SciMLBase.FunctionWrapperSpecialize,
+    }(
+        sys::System, @nospecialize(op), tspan;
+        @nospecialize(callback = nothing), check_length = true, eval_expression = false,
+        expression = Val{false}, eval_module = @__MODULE__, check_compatibility = true,
+        _skip_events = false, kwargs...
+    ) where {iip}
+    return _ode_problem(
+        ODEProblem{iip, SciMLBase.FunctionWrapperSpecialize}, sys, op, tspan;
+        callback, check_length, eval_expression, expression, eval_module, check_compatibility,
+        _skip_events, kwargs...
+    )
 end
 
 @fallback_iip_specialize function DiffEqBase.SteadyStateProblem{iip, spec}(

lib/ModelingToolkitBase/src/systems/abstractsystem.jl

@@ -1270,16 +1270,31 @@ end
 
 const AllScopes = Union{LocalScope, ParentScope, GlobalScope}
 
+_renamespace(names::AbstractVector, x) = foldr(renamespace, names, init = x)
+
 renamespace(sys, eq::Equation) = namespace_equation(eq, sys)
+renamespace(names::AbstractVector, eq::Equation) = _renamespace(names, eq)
 
-renamespace(names::AbstractVector, x) = foldr(renamespace, names, init = x)
+renamespace(names::AbstractVector, x) = _renamespace(names, x)
 
 renamespace(sys, tgt::AbstractSystem) = rename(tgt, renamespace(sys, nameof(tgt)))
+renamespace(names::AbstractVector, tgt::AbstractSystem) = _renamespace(names, tgt)
 renamespace(sys, tgt::Symbol) = Symbol(getname(sys), NAMESPACE_SEPARATOR_SYMBOL, tgt)
+renamespace(names::AbstractVector, tgt::Symbol) = _renamespace(names, tgt)
 renamespace(sys, x::Num) = Num(renamespace(sys, unwrap(x)))
+renamespace(names::AbstractVector, x::Num) = _renamespace(names, x)
 renamespace(sys, x::Arr{T, N}) where {T, N} = Arr{T, N}(renamespace(sys, unwrap(x)))
+function renamespace(names::AbstractVector, x::Arr{T, N}) where {T, N}
+    return _renamespace(names, x)
+end
 renamespace(sys, x::CallAndWrap{T}) where {T} = CallAndWrap{T}(renamespace(sys, unwrap(x)))
+function renamespace(names::AbstractVector, x::CallAndWrap{T}) where {T}
+    return _renamespace(names, x)
+end
 renamespace(sys, x::AbstractArray{SymbolicT}) = map(Base.Fix1(renamespace, sys), x)
+function renamespace(names::AbstractVector, x::AbstractArray{SymbolicT})
+    return _renamespace(names, x)
+end
 
 """
     $(TYPEDSIGNATURES)
@@ -1327,6 +1342,8 @@ function renamespace(sys, x::SymbolicT)
     end
 end
 
+renamespace(names::AbstractVector, x::SymbolicT) = _renamespace(names, x)
+
 namespace_variables(sys::AbstractSystem) = unknowns(sys, unknowns(sys))
 namespace_parameters(sys::AbstractSystem) = parameters(sys, parameters(sys))
 

lib/ModelingToolkitBase/src/systems/analysis_points.jl

@@ -177,6 +177,8 @@ function renamespace(sys, ap::AnalysisPoint)
     )
 end
 
+renamespace(names::AbstractVector, ap::AnalysisPoint) = _renamespace(names, ap)
+
 # create analysis points via `connect`
 function connect(in, ap::AnalysisPoint, outs...; verbose = true)
     return AnalysisPoint() ~ AnalysisPoint(unwrap(in), ap.name, collect(unwrap.(outs)); verbose)

lib/ModelingToolkitBase/src/systems/parameter_buffer.jl

@@ -305,29 +305,28 @@ function _split_helper(buf_v::T, recurse, raw, idx) where {T}
 end
 
 function _split_helper(::Type{<:AbstractArray}, buf_v, ::Val{N}, raw, idx) where {N}
+    iszero(N) && return _split_helper((), buf_v, (), raw, idx)
     return map(b -> _split_helper(eltype(b), b, Val(N - 1), raw, idx), buf_v)
 end
 
 function _split_helper(
         ::Type{<:AbstractArray}, buf_v::BlockedArray, ::Val{N}, raw, idx
     ) where {N}
+    iszero(N) && return _split_helper((), buf_v, (), raw, idx)
     return BlockedArray(
         map(b -> _split_helper(eltype(b), b, Val(N - 1), raw, idx), buf_v),
         blocksizes(buf_v, 1)
     )
 end
 
 function _split_helper(::Type{<:AbstractArray}, buf_v::Tuple, ::Val{N}, raw, idx) where {N}
+    iszero(N) && return _split_helper((), buf_v, (), raw, idx)
     return ntuple(
         i -> _split_helper(eltype(buf_v[i]), buf_v[i], Val(N - 1), raw, idx),
         Val(length(buf_v))
     )
 end
 
-function _split_helper(::Type{<:AbstractArray}, buf_v, ::Val{0}, raw, idx)
-    return _split_helper((), buf_v, (), raw, idx)
-end
-
 function _split_helper(_, buf_v, _, raw, idx)
     res = reshape(raw[idx[]:(idx[] + length(buf_v) - 1)], size(buf_v))
     idx[] += length(buf_v)

lib/ModelingToolkitBase/test/namespacing.jl

@@ -28,6 +28,15 @@ nsys = toggle_namespacing(sys, false)
     Equation[], t; systems = [nsys], name = :a
 )
 
+@testset "Vector namespaces" begin
+    outer = System(Equation[], t; name = :outer)
+    names = [outer, sys]
+    for value in (:value, x, D(x) ~ x, [ModelingToolkitBase.unwrap(x)])
+        expected = renamespace(outer, renamespace(sys, value))
+        @test isequal(renamespace(names, value), expected)
+    end
+end
+
 @testset "Variables of variables" begin
     @variables x(t) y(x)
     @named inner = System([D(x) ~ x, y ~ 2x + 1], t)

lib/ModelingToolkitBase/test/sciml_problem_inputs.jl

@@ -196,7 +196,9 @@ end
     @testset "$ctor" for (sys, ctor) in [
             (odesys, ODEProblem),
             (odesys, ODEProblem{true}),
-            (odesys, ODEProblem{true, SciMLBase.FullSpecialize}), (odesys, BVProblem),
+            (odesys, ODEProblem{true, SciMLBase.FullSpecialize}),
+            (odesys, ODEProblem{true, SciMLBase.FunctionWrapperSpecialize}),
+            (odesys, BVProblem),
             (odesys, BVProblem{true}),
             (odesys, BVProblem{true, SciMLBase.FullSpecialize}), (sdesys, SDEProblem),
             (sdesys, SDEProblem{true}),