suggestions

Author: joaquimg

src/ModelAnalyzer.jl

@@ -14,7 +14,7 @@ abstract type AbstractData end
 abstract type AbstractAnalyzer end
 
 """
-    analyze(analyzer::AbstractAnalyzer, model::JuMP.Model; kwargs...)
+    analyze(analyzer::AbstractAnalyzer, model::JuMP.GenericModel; kwargs...)
 
 Analyze a JuMP model using the specified analyzer.
 Depending on the analyzer, this keyword arguments might vary.
@@ -122,6 +122,7 @@ some numerical issues, it can be the coefficient value.
 function value(issue::AbstractIssue, ::Nothing)
     return value(issue)
 end
+
 function value(issue::AbstractIssue, ::MOI.ModelLike)
     return value(issue)
 end
@@ -134,6 +135,7 @@ Return the variable associated to a particular issue.
 function variable(issue::AbstractIssue, ::Nothing)
     return variable(issue)
 end
+
 function variable(issue::AbstractIssue, ::MOI.ModelLike)
     return variable(issue)
 end
@@ -146,6 +148,7 @@ Return the variables associated to a particular issue.
 function variables(issue::AbstractIssue, ::Nothing)
     return variables(issue)
 end
+
 function variables(issue::AbstractIssue, ::MOI.ModelLike)
     return variables(issue)
 end
@@ -158,11 +161,13 @@ Return the constraint associated to a particular issue.
 function constraint(issue::AbstractIssue, ::Nothing)
     return constraint(issue)
 end
+
 function constraint(issue::AbstractIssue, ::MOI.ModelLike)
     return constraint(issue)
 end
 
 function _verbose_summarize end
+
 function _summarize end
 
 function _name(ref::MOI.VariableIndex, model::MOI.ModelLike)

src/feasibility.jl

@@ -85,7 +85,7 @@ julia> ModelAnalyzer.summarize(ModelAnalyzer.Feasibility.DualViolation)
 ```
 """
 struct DualViolation <: AbstractFeasibilityIssue
-    ref::Union{JuMP.ConstraintRef,JuMP.VariableRef}
+    ref::Union{JuMP.ConstraintRef,JuMP.GenericVariableRef}
     violation::Float64
 end
 
@@ -651,7 +651,7 @@ function _name(ref::JuMP.ConstraintRef)
     return JuMP.name(ref)
 end
 
-function _name(ref::JuMP.VariableRef)
+function _name(ref::JuMP.GenericVariableRef)
     return JuMP.name(ref)
 end
 
@@ -1062,12 +1062,12 @@ function _dual_point_to_dual_model_ref(
         if haskey(primal_con_dual_var, moi_con)
             vec_vars = primal_con_dual_var[moi_con]
             for (i, moi_var) in enumerate(vec_vars)
-                jump_var = JuMP.VariableRef(dual_model, moi_var)
+                jump_var = JuMP.GenericVariableRef{T}(dual_model, moi_var)
                 dual_point[jump_var] = val[i]
             end
         elseif haskey(primal_con_dual_convar, moi_con)
             moi_convar = primal_con_dual_convar[moi_con]
-            jump_var = JuMP.VariableRef(
+            jump_var = JuMP.GenericVariableRef{T}(
                 dual_model,
                 MOI.VariableIndex(moi_convar.value),
             )
@@ -1105,7 +1105,10 @@ function _fix_ret(
     primal_model::JuMP.GenericModel{T},
     dual_con_primal_all,
 ) where {T}
-    ret = Dict{Union{JuMP.ConstraintRef,JuMP.VariableRef},Union{T,Vector{T}}}()
+    ret = Dict{
+        Union{JuMP.ConstraintRef,JuMP.GenericVariableRef{T}},
+        Union{T,Vector{T}},
+    }()
     for (jump_dual_con, val) in pre_ret
         # v is a variable in the dual jump model
         # we need the associated cosntraint in the primal jump model
@@ -1115,7 +1118,7 @@ function _fix_ret(
             # variable in the dual model
             # constraint in the primal model
             jump_primal_var =
-                JuMP.VariableRef(primal_model, moi_primal_something)
+                JuMP.GenericVariableRef{T}(primal_model, moi_primal_something)
             # ret[jump_primal_var] = T[val]
             ret[jump_primal_var] = val
         else
@@ -1144,7 +1147,7 @@ function _dualize2(
     if mode == JuMP.MANUAL
         error("Dualization does not support solvers in $(mode) mode")
     end
-    dual_model = JuMP.Model()
+    dual_model = JuMP.GenericModel()
     dual_problem = Dualization.DualProblem(JuMP.backend(dual_model))
     Dualization.dualize(JuMP.backend(model), dual_problem; kwargs...)
     Dualization._fill_obj_dict_with_variables!(dual_model)

src/infeasibility.jl

@@ -50,7 +50,7 @@ julia> ModelAnalyzer.summarize(ModelAnalyzer.Infeasibility.InfeasibleBounds)
 ````
 """
 struct InfeasibleBounds{T} <: AbstractInfeasibilitylIssue
-    variable::JuMP.VariableRef
+    variable::JuMP.GenericVariableRef{T}
     lb::T
     ub::T
 end
@@ -71,7 +71,7 @@ julia> ModelAnalyzer.summarize(
 ```
 """
 struct InfeasibleIntegrality{T} <: AbstractInfeasibilitylIssue
-    variable::JuMP.VariableRef
+    variable::JuMP.GenericVariableRef{T}
     lb::T
     ub::T
     set::Union{MOI.Integer,MOI.ZeroOne}#, MOI.Semicontinuous{T}, MOI.Semiinteger{T}}
@@ -147,7 +147,7 @@ function ModelAnalyzer.analyze(
 ) where {T}
     out = Data()
 
-    variables = Dict{JuMP.VariableRef,Interval{T}}()
+    variables = Dict{JuMP.GenericVariableRef{T},Interval{T}}()
 
     # first layer of infeasibility analysis is bounds consistency
     bounds_consistent = true
@@ -196,7 +196,7 @@ function ModelAnalyzer.analyze(
     # second layer of infeasibility analysis is constraint range analysis
     range_consistent = true
     for (F, S) in JuMP.list_of_constraint_types(model)
-        F != JuMP.GenericAffExpr{T,JuMP.VariableRef} && continue
+        F != JuMP.GenericAffExpr{T,JuMP.GenericVariableRef{T}} && continue
         # TODO: handle quadratics
         !(S in (MOI.EqualTo{T}, MOI.LessThan{T}, MOI.GreaterThan{T})) &&
             continue

src/jump.jl

@@ -1,18 +1,13 @@
-import JuMP
-
-# struct JuMPData{T<:AbstractData} <: ModelAnalyzer.AbstractData
-#     data::T
-#     model::JuMP.Model
-# end
+# Copyright (c) 2025: Joaquim Garcia, Oscar Dowson and contributors
+#
+# Use of this source code is governed by an MIT-style license that can be found
+# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
 
-# struct JuMPIssue{T<:AbstractIssue} <: ModelAnalyzer.AbstractIssue
-#     issue::T
-#     model::JuMP.Model
-# end
+import JuMP
 
 function ModelAnalyzer.analyze(
     analyzer::T,
-    model::JuMP.Model;
+    model::JuMP.GenericModel;
     kwargs...,
 ) where {T<:ModelAnalyzer.AbstractAnalyzer}
     moi_model = JuMP.backend(model)
@@ -21,16 +16,19 @@ function ModelAnalyzer.analyze(
     return result
 end
 
-function ModelAnalyzer._name(ref::MOI.VariableIndex, model::JuMP.Model)
-    jump_ref = JuMP.VariableRef(model, ref)
+function ModelAnalyzer._name(
+    ref::MOI.VariableIndex,
+    model::JuMP.GenericModel{T},
+) where {T}
+    jump_ref = JuMP.GenericVariableRef{T}(model, ref)
     name = JuMP.name(jump_ref)
     if !isempty(name)
         return name
     end
     return "$jump_ref"
 end
 
-function ModelAnalyzer._name(ref::MOI.ConstraintIndex, model::JuMP.Model)
+function ModelAnalyzer._name(ref::MOI.ConstraintIndex, model::JuMP.GenericModel)
     jump_ref = JuMP.constraint_ref_with_index(model, ref)
     name = JuMP.name(jump_ref)
     if !isempty(name)
@@ -40,39 +38,39 @@ function ModelAnalyzer._name(ref::MOI.ConstraintIndex, model::JuMP.Model)
 end
 
 """
-    variable(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+    variable(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
 
 Return the **JuMP** variable reference associated to a particular issue.
 """
 function ModelAnalyzer.variable(
     issue::ModelAnalyzer.AbstractIssue,
-    model::JuMP.Model,
-)
+    model::JuMP.GenericModel{T},
+) where {T}
     ref = ModelAnalyzer.variable(issue)
-    return JuMP.VariableRef(model, ref)
+    return JuMP.GenericVariableRef{T}(model, ref)
 end
 
 """
-    variables(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+    variables(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
 
 Return the **JuMP** variable references associated to a particular issue.
 """
 function ModelAnalyzer.variables(
     issue::ModelAnalyzer.AbstractIssue,
-    model::JuMP.Model,
-)
+    model::JuMP.GenericModel{T},
+) where {T}
     refs = ModelAnalyzer.variables(issue)
-    return JuMP.VariableRef.(model, refs)
+    return JuMP.GenericVariableRef{T}.(model, refs)
 end
 
 """
-    constraint(issue::ModelAnalyzer.AbstractIssue, model::JuMP.Model)
+    constraint(issue::ModelAnalyzer.AbstractIssue, model::JuMP.GenericModel)
 
 Return the **JuMP** constraint reference associated to a particular issue.
 """
 function ModelAnalyzer.constraint(
     issue::ModelAnalyzer.AbstractIssue,
-    model::JuMP.Model,
+    model::JuMP.GenericModel,
 )
     ref = ModelAnalyzer.constraint(issue)
     return JuMP.constraint_ref_with_index(model, ref)