nospecialize a few more things that gain many specializations without having significant runtime

lib/ModelingToolkitBase/src/problems/linearproblem.jl

@@ -117,15 +117,17 @@ function SciMLBase.LinearProblem{iip}(
 end
 
 function get_A_b_from_LinearFunction(
-        sys::System, f::LinearFunction, op; kws...
+        sys::System, @nospecialize(f::LinearFunction), op; kws...
     )
     return get_A_b_from_LinearFunction(sys, f, Symbolics.FixpointSubstituter{true}(op); kws...)
 end
 
 function get_A_b_from_LinearFunction(
-        sys::System, f::LinearFunction, subber::Symbolics.FixpointSubstituter{true}; eval_expression = false,
-        eval_module = @__MODULE__, expression = Val{false}, u0_constructor = identity,
-        u0_eltype = float
+        sys::System, @nospecialize(f::LinearFunction), subber::Symbolics.FixpointSubstituter{true};
+        eval_expression = false, eval_module = @__MODULE__,
+        @nospecialize(expression = Val{false}),
+        @nospecialize(u0_constructor = identity),
+        @nospecialize(u0_eltype = float)
     )
     @unpack A, b, interface = f
     if A isa Matrix{SymbolicT}

lib/ModelingToolkitBase/src/systems/codegen.jl

@@ -1213,8 +1213,8 @@ The signatures will be of the form `g(...)` with arguments:
 For example, a function `g(op, unknowns, p..., inputs, t, known_disturbances)` will be the in-place function generated if `return_inplace` is true, `ts` is a vector,
 an array of inputs `inputs` is given, `known_disturbance_inputs` is provided, and `param_only` is false for a time-dependent system.
 """
-function build_explicit_observed_function(
-        sys, ts;
+Base.@nospecializeinfer function build_explicit_observed_function(
+        sys, @nospecialize(ts);
         inputs = nothing,
         disturbance_inputs = nothing,
         known_disturbance_inputs = nothing,

lib/ModelingToolkitBase/src/systems/codegen_utils.jl

@@ -28,7 +28,11 @@ function generated_argument_name(i::Int)
     return Symbol(:__mtk_arg_, i)
 end
 
-@inline function compute_array_variable_buffer_idxs(args; ignore_vars = Set{SymbolicT}())
+function compute_array_variable_buffer_idxs(@nospecialize(args); ignore_vars = Set{SymbolicT}())
+    _compute_array_variable_buffer_idxs(args isa Vector ? args : collect(args), ignore_vars)
+end
+
+function _compute_array_variable_buffer_idxs(args::Vector, ignore_vars)
     # map array symbolic to an identically sized array where each element is (buffer_idx, idx_in_buffer)
     var_to_arridxs = Dict{SymbolicT, Vector{Tuple{Int, Int}}}()
     for (i, arg) in enumerate(args)
@@ -132,7 +136,7 @@ reconstruct array variables if they are present scalarized in `args`.
   generated function.
 """
 function array_variable_assignments(
-        args...; ignore_vars = Set{SymbolicT}(), filter_vars = nothing,
+        @nospecialize(args...); ignore_vars = Set{SymbolicT}(), filter_vars = nothing,
         argument_name = generated_argument_name, buffer_offset = 0
     )
     var_to_arridxs = compute_array_variable_buffer_idxs(args; ignore_vars)
@@ -332,7 +336,7 @@ Base.@nospecializeinfer function build_function_wrapper(
         p_start += 1
         p_end += 1
     end
-    
+
     ir_info = get_ir_info(sys)
     expr = ir_info.obs_subber(expr)
 

lib/ModelingToolkitBase/src/systems/problem_utils.jl

@@ -1548,8 +1548,8 @@ $PROBLEM_INTERNAL_KWARGS
 
 All other keyword arguments are passed as-is to `constructor`.
 """
-function process_SciMLProblem(
-        constructor, sys::AbstractSystem, op;
+Base.@nospecializeinfer function process_SciMLProblem(
+        @nospecialize(constructor), sys::AbstractSystem, @nospecialize(op);
         build_initializeprob = supports_initialization(sys),
         implicit_dae = false, t = nothing, guesses = AnyDict(),
         warn_initialize_determined = true, initialization_eqs = [],