Fix sublibrary QA findings (JET, Aqua, syntax)

Address the JET/Aqua static-analysis failures across sublibraries:

JET "possibly undefined local" (conditional definition / closure boxing):
- GCMAES: define the gradient closure `g` unconditionally (the QA pass's
  `local g` + conditional assignment is what JET flagged).
- NLopt: drop the theta-memoization and write constraints/Jacobian into the
  preallocated caches in place, so no captured variable is reassigned/boxed.
- OptimizationBase (DISparseExt): hoist `cons_oop`/`lagrangian` out of the
  `if f.cons === nothing` else-branch so they are defined on all paths.

JET "no matching method ... ::Nothing":
- PRIMA: `get_solve_func` now errors in an else branch, so its return type
  (and `optfunc`) no longer includes Nothing.
- NOMAD: merge the `bb`/`bbcons` definition and the NomadProblem construction
  into a single if/else so the callback isn't seen as possibly-undefined.

Real bugs surfaced by JET:
- SciPy: `pytypeof` -> `pytype` (pytypeof does not exist in PythonCall; the
  fallback branch would have errored).
- SimpleOptimization: guard `open_brkt_ind` against `nothing` before
  subtracting, in the AD-package-not-loaded error path.

Aqua / syntax:
- Manopt: remove the stray second `;` in the `Aqua.test_all` call (syntax error).
- QuadDIRECT: add `Test` compat (Aqua check_extras) and raise SciMLBase floor
  to 2.122.1 to match OptimizationBase.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jClugstor

lib/OptimizationBase/src/OptimizationDISparseExt.jl

@@ -142,25 +142,25 @@ function instantiate_function(
         cons = let f = f, p = p
             (res, θ, p_call = p) -> f.cons(res, θ, p_call)
         end
+    end
 
-        function cons_oop(x)
-            _res = zeros(eltype(x), num_cons)
-            f.cons(_res, x, p)
-            return _res
-        end
+    function cons_oop(x)
+        _res = zeros(eltype(x), num_cons)
+        f.cons(_res, x, p)
+        return _res
+    end
 
-        function cons_oop(x, i)
-            _res = zeros(eltype(x), num_cons)
-            f.cons(_res, x, p)
-            return _res[i]
-        end
+    function cons_oop(x, i)
+        _res = zeros(eltype(x), num_cons)
+        f.cons(_res, x, p)
+        return _res[i]
+    end
 
-        function lagrangian(θ, σ, λ, p)
-            if eltype(θ) <: SparseConnectivityTracer.AbstractTracer || !iszero(θ)
-                return σ * f.f(θ, p) + dot(λ, cons_oop(θ))
-            else
-                return dot(λ, cons_oop(θ))
-            end
+    function lagrangian(θ, σ, λ, p)
+        if eltype(θ) <: SparseConnectivityTracer.AbstractTracer || !iszero(θ)
+            return σ * f.f(θ, p) + dot(λ, cons_oop(θ))
+        else
+            return dot(λ, cons_oop(θ))
         end
     end
 
@@ -452,10 +452,10 @@ function instantiate_function(
         cons = let f = f, p = p
             (x, p_call = p) -> f.cons(x, p_call)
         end
+    end
 
-        function lagrangian(θ, σ, λ, p)
-            return σ * f.f(θ, p) + dot(λ, f.cons(θ, p))
-        end
+    function lagrangian(θ, σ, λ, p)
+        return σ * f.f(θ, p) + dot(λ, f.cons(θ, p))
     end
 
     cons_jac_prototype = f.cons_jac_prototype

lib/OptimizationGCMAES/src/OptimizationGCMAES.jl

@@ -72,12 +72,9 @@ function SciMLBase.__solve(cache::OptimizationCache{O}) where {O <: GCMAESOpt}
         return x[1]
     end
 
-    local g
-    if !isnothing(cache.f.grad)
-        g = function (θ)
-            cache.f.grad(G, θ)
-            return G
-        end
+    g = function (θ)
+        cache.f.grad(G, θ)
+        return G
     end
 
     maxiters = OptimizationBase._check_and_convert_maxiters(cache.solver_args.maxiters)

lib/OptimizationManopt/test/qa/qa.jl

@@ -9,10 +9,8 @@ using Test
     # Manifolds is declared because the curvature analysis path may pull it in,
     # but no symbol from it is currently used in src — ignore it for now.
     Aqua.test_all(
-
         OptimizationManopt;
-        undefined_exports = (; broken = true)
-        ;
+        undefined_exports = (; broken = true),
         stale_deps = (; ignore = [:Manifolds])
     )
 end

lib/OptimizationNLopt/src/OptimizationNLopt.jl

@@ -196,14 +196,9 @@ function SciMLBase.__solve(cache::OptimizationCache{O}) where {
         eqinds = map((y) -> y[1] == y[2], zip(cache.lcons, cache.ucons))
         ineqinds = map((y) -> y[1] != y[2], zip(cache.lcons, cache.ucons))
         cons_cache = zeros(eltype(cache.u0), sum(eqinds) + sum(ineqinds))
-        thetacache = rand(size(cache.u0))
-        Jthetacache = rand(size(cache.u0))
         Jcache = zeros(eltype(cache.u0), sum(ineqinds) + sum(eqinds), length(cache.u0))
         evalcons = function (θ, ineqoreq)
-            if thetacache != θ
-                cache.f.cons(cons_cache, θ)
-                thetacache = copy(θ)
-            end
+            cache.f.cons(cons_cache, θ)
             if ineqoreq == :eq
                 return @view(cons_cache[eqinds])
             else
@@ -212,11 +207,7 @@ function SciMLBase.__solve(cache::OptimizationCache{O}) where {
         end
 
         evalconj = function (θ, ineqoreq)
-            if Jthetacache != θ
-                cache.f.cons_j(Jcache, θ)
-                Jthetacache = copy(θ)
-            end
-
+            cache.f.cons_j(Jcache, θ)
             if ineqoreq == :eq
                 return @view(Jcache[eqinds, :])'
             else

lib/OptimizationNOMAD/src/OptimizationNOMAD.jl

@@ -75,14 +75,23 @@ function SciMLBase.__solve(
     end
 
     bb = nothing
-    bbcons = nothing
+    bounds = (;)
+    if !isnothing(prob.lb)
+        bounds = (; bounds..., lower_bound = prob.lb)
+    end
+
+    if !isnothing(prob.ub)
+        bounds = (; bounds..., upper_bound = prob.ub)
+    end
+
     if prob.f.cons === nothing
         bb = function (x)
             l = _loss(x)
             success = !isnan(l) && !isinf(l)
             count_eval = true
             return (success, count_eval, [l])
         end
+        opt_setup = NOMAD.NomadProblem(length(prob.u0), 1, ["OBJ"], bb; bounds...)
     else
         eqinds = findall(i -> prob.lcons[i] == prob.ucons[i], 1:length(prob.ucons))
         bbcons = function (x)
@@ -97,20 +106,6 @@ function SciMLBase.__solve(
             count_eval = true
             return (success, count_eval, vcat(l, c))
         end
-    end
-
-    bounds = (;)
-    if !isnothing(prob.lb)
-        bounds = (; bounds..., lower_bound = prob.lb)
-    end
-
-    if !isnothing(prob.ub)
-        bounds = (; bounds..., upper_bound = prob.ub)
-    end
-
-    if prob.f.cons === nothing
-        opt_setup = NOMAD.NomadProblem(length(prob.u0), 1, ["OBJ"], bb; bounds...)
-    else
         opt_setup = NOMAD.NomadProblem(
             length(prob.u0), 1 + length(prob.ucons),
             vcat("OBJ", fill(strcnsmethod(cons_method), length(prob.ucons))),

lib/OptimizationPRIMA/src/OptimizationPRIMA.jl

@@ -80,6 +80,8 @@ function get_solve_func(opt::PRIMASolvers)
         return PRIMA.lincoa
     elseif opt isa COBYLA
         return PRIMA.cobyla
+    else
+        error("Unknown PRIMA solver type: $(typeof(opt))")
     end
 end
 

lib/OptimizationQuadDIRECT/Project.toml

@@ -19,9 +19,10 @@ Pkg = "1"
 julia = "1.10"
 OptimizationBase = "5"
 QuadDIRECT = "0.1.2"
-SciMLBase = "2.58, 3"
+SciMLBase = "2.122.1, 3"
 SafeTestsets = "0.1"
 Reexport = "1.2"
+Test = "1.10"
 
 [targets]
 test = ["Pkg", "Test", "SafeTestsets"]

lib/OptimizationSciPy/src/OptimizationSciPy.jl

@@ -29,7 +29,7 @@ function safe_get_message(result)
     if pyisinstance(msg, pybuiltins.list) || pyisinstance(msg, pybuiltins.tuple)
         return join(pyconvert(Vector{String}, msg), ", ")
     end
-    return string(pytypeof(msg))
+    return string(pytype(msg))
 end
 
 # Squash any kind of numeric object down to a Julia Float64.

lib/SimpleOptimization/src/SimpleOptimization.jl

@@ -155,9 +155,15 @@ function instantiate_gradient(f, adtype::ADTypes.AbstractADType)
     strtind = isnothing(_strtind) ? 5 : _strtind + 5
     open_nrmlbrkt_ind = findfirst('(', adtypestr)
     open_squigllybrkt_ind = findfirst('{', adtypestr)
-    open_brkt_ind = isnothing(open_squigllybrkt_ind) ? open_nrmlbrkt_ind :
+    open_brkt_ind = if isnothing(open_squigllybrkt_ind)
+        open_nrmlbrkt_ind
+    elseif isnothing(open_nrmlbrkt_ind)
+        open_squigllybrkt_ind
+    else
         min(open_nrmlbrkt_ind, open_squigllybrkt_ind)
-    adpkg = adtypestr[strtind:(open_brkt_ind - 1)]
+    end
+    lastidx = isnothing(open_brkt_ind) ? lastindex(adtypestr) : (open_brkt_ind - 1)
+    adpkg = adtypestr[strtind:lastidx]
     throw(ArgumentError("The passed automatic differentiation backend choice is not available. Please load the corresponding AD package $adpkg."))
 end