[Bridges] throw MOI error subtypes instead of Base.error()

Author: odow

src/Bridges/Constraint/bridges/ComplexNormInfinityToSecondOrderConeBridge.jl

@@ -42,10 +42,8 @@ function bridge_constraint(
 ) where {T}
     fi_s = MOI.Utilities.scalarize(f)
     if !iszero(imag(fi_s[1]))
-        error(
-            "The epigraph variable `t` in `[t; x] in NormInfinityCone()` " *
-            "must be real. It is: $(fi_s[1])",
-        )
+        msg = "The epigraph variable `t` in `[t; x] in NormInfinityCone()` must be real. It is: $(fi_s[1])"
+        throw(MOI.AddConstraintNotAllowed{typeof(f),typeof(s)}(msg))
     end
     t = real(fi_s[1])
     cis = MOI.ConstraintIndex{MOI.VectorAffineFunction{T},MOI.SecondOrderCone}[]

src/Bridges/Constraint/bridges/IndicatorToMILPBridge.jl

@@ -201,19 +201,18 @@ function _is_binary(model::MOI.ModelLike, x::MOI.VariableIndex)
 end
 
 function MOI.Bridges.final_touch(
-    bridge::IndicatorToMILPBridge{T,F},
+    bridge::IndicatorToMILPBridge{T,F,A,S},
     model::MOI.ModelLike,
-) where {T,F}
+) where {T,F,A,S}
     bounds = Dict{MOI.VariableIndex,NTuple{2,T}}()
     scalars = collect(MOI.Utilities.eachscalar(bridge.f))
     fi = scalars[2]
     ret = MOI.Utilities.get_bounds(model, bounds, fi)
     if ret === nothing
         throw(MOI.Bridges.BridgeRequiresFiniteDomainError(bridge, fi))
     elseif !_is_binary(model, scalars[1])
-        error(
-            "Unable to reformulate indicator constraint to a MILP. The indicator variable must be binary.",
-        )
+        msg = "Unable to reformulate indicator constraint to a MILP. The indicator variable must be binary."
+        throw(MOI.AddConstraintNotAllowed{F,MOI.Indicator{A,S}}(msg))
     end
     if bridge.slack === nothing
         # This is the first time calling final_touch

src/Bridges/Constraint/bridges/IntegerToZeroOneBridge.jl

@@ -156,10 +156,7 @@ function MOI.Bridges.final_touch(
     if ret === bridge.last_bounds
         return nothing  # final_touch already called
     elseif ret[1] == typemin(T) || ret[2] == typemax(T)
-        error(
-            "Unable to use IntegerToZeroOneBridge because the variable " *
-            "$(bridge.x) has a non-finite domain",
-        )
+        throw(MOI.Bridges.BridgeRequiresFiniteDomainError(bridge, bridge.x))
     end
     f = MOI.ScalarAffineFunction([MOI.ScalarAffineTerm(T(1), bridge.x)], T(0))
     lb, ub = ceil(Int, ret[1]), floor(Int, ret[2])

src/Bridges/Constraint/bridges/SplitIntervalBridge.jl

@@ -230,9 +230,8 @@ function MOI.get(
     if bridge.upper !== nothing
         return MOI.get(model, attr, bridge.upper)
     end
-    return error(
-        "Cannot get `$attr` for a constraint in the interval `[-Inf, Inf]`.",
-    )
+    msg = "Cannot get `$attr` for a constraint in the interval `[-Inf, Inf]`."
+    return throw(MOI.GetAttributeNotAllowed(attr, msg))
 end
 
 function MOI.set(
@@ -333,10 +332,8 @@ function MOI.get(
             # The only case where the interval `[-∞, ∞]` is allowed is for
             # `VariableIndex` constraints but `ConstraintBasisStatus` is not
             # defined for `VariableIndex` constraints.
-            error(
-                "Cannot get `$attr` for a constraint in the interval " *
-                "`[-Inf, Inf]`.",
-            )
+            msg = "Cannot get `$attr` for a constraint in the interval `[-Inf, Inf]`."
+            throw(MOI.GetAttributeNotAllowed(attr, msg))
         end
         return upper_stat
     end

src/Bridges/Objective/bridges/SlackBridge.jl

@@ -58,15 +58,16 @@ function bridge_objective(
 ) where {T,F,G<:MOI.AbstractScalarFunction}
     slack = MOI.add_variable(model)
     f = MOI.Utilities.operate(-, T, func, slack)
-    if MOI.get(model, MOI.ObjectiveSense()) == MOI.MIN_SENSE
-        set = MOI.LessThan(zero(T))
-    elseif MOI.get(model, MOI.ObjectiveSense()) == MOI.MAX_SENSE
-        set = MOI.GreaterThan(zero(T))
+    sense = MOI.get(model, MOI.ObjectiveSense())
+    if sense == MOI.FEASIBILITY_SENSE
+        msg = "Set `MOI.ObjectiveSense` before `MOI.ObjectiveFunction` when using `MOI.Bridges.Objective.SlackBridge`."
+        throw(MOI.SetAttributeNotAllowed(MOI.ObjectiveFunction{G}(), msg))
+    end
+    set = if sense == MOI.MIN_SENSE
+        MOI.LessThan(zero(T))
     else
-        error(
-            "Set `MOI.ObjectiveSense` before `MOI.ObjectiveFunction` when",
-            " using `MOI.Bridges.Objective.SlackBridge`.",
-        )
+        @assert sense == MOI.MAX_SENSE
+        MOI.GreaterThan(zero(T))
     end
     constraint = MOI.Utilities.normalize_and_add_constraint(model, f, set)
     MOI.set(model, MOI.ObjectiveFunction{MOI.VariableIndex}(), slack)

src/Bridges/Objective/bridges/VectorSlackBridge.jl

@@ -69,15 +69,14 @@ function bridge_objective(
     )
     sense = MOI.get(model, MOI.ObjectiveSense())
     if sense == MOI.FEASIBILITY_SENSE
-        error(
-            "Set `MOI.ObjectiveSense` before `MOI.ObjectiveFunction` when",
-            " using `MOI.Bridges.Objective.VectorSlackBridge`.",
-        )
+        msg = "Set `MOI.ObjectiveSense` before `MOI.ObjectiveFunction` when using `MOI.Bridges.Objective.VectorSlackBridge`."
+        throw(MOI.SetAttributeNotAllowed(MOI.ObjectiveFunction{G}(), msg))
     end
     slacks = MOI.VectorOfVariables(variables[slacked_objectives])
     f = if sense == MOI.MIN_SENSE
         MOI.Utilities.operate(-, T, slacks, funcs[slacked_objectives])
-    elseif sense == MOI.MAX_SENSE
+    else
+        @assert sense == MOI.MAX_SENSE
         MOI.Utilities.operate(-, T, funcs[slacked_objectives], slacks)
     end
     set = MOI.Nonnegatives(length(slacked_objectives))

src/Bridges/bridge_optimizer.jl

@@ -2032,49 +2032,45 @@ _check_double_single_variable(::AbstractBridgeOptimizer, ::Any, ::Any) = nothing
 
 function MOI.add_constraint(
     b::AbstractBridgeOptimizer,
-    f::MOI.AbstractFunction,
-    s::MOI.AbstractSet,
-)
+    f::F,
+    s::S,
+) where {F<:MOI.AbstractFunction,S<:MOI.AbstractSet}
     if Variable.has_bridges(Variable.bridges(b))
-        if f isa MOI.VariableIndex
+        if F <: MOI.VariableIndex
             if is_bridged(b, f)
-                if MOI.is_valid(
-                    b,
-                    MOI.ConstraintIndex{MOI.VariableIndex,typeof(s)}(f.value),
-                )
+                ci = MOI.ConstraintIndex{MOI.VariableIndex,S}(f.value)
+                if MOI.is_valid(b, ci)
                     # The other constraint could have been through a variable bridge.
-                    error(
-                        "Cannot add two `VariableIndex`-in-`$(typeof(s))`",
-                        " on the same variable $(f).",
-                    )
+                    msg = "Cannot add two `VariableIndex`-in-`$S` on the same variable $f."
+                    throw(MOI.AddConstraintNotAllowed{F,S}(msg))
                 end
                 BridgeType = Constraint.concrete_bridge_type(
                     constraint_scalar_functionize_bridge(b),
-                    typeof(f),
-                    typeof(s),
+                    F,
+                    S,
                 )
                 MOI.add_constraint(Variable.bridges(b), f, s)
                 return add_bridged_constraint(b, BridgeType, f, s)
             end
-        elseif f isa MOI.VectorOfVariables
+        elseif F <: MOI.VectorOfVariables
             if any(vi -> is_bridged(b, vi), f.variables)
                 BridgeType = Constraint.concrete_bridge_type(
                     constraint_vector_functionize_bridge(b),
-                    typeof(f),
-                    typeof(s),
+                    F,
+                    S,
                 )
                 return add_bridged_constraint(b, BridgeType, f, s)
             end
         else
             f, s = bridged_constraint_function(b, f, s)
         end
     end
-    if is_bridged(b, typeof(f), typeof(s))
+    if is_bridged(b, F, S)
         _check_double_single_variable(b, f, s)
         # We compute `BridgeType` first as `concrete_bridge_type` calls
         # `bridge_type` which might throw an `UnsupportedConstraint` error in
         # which case, we do not want any modification to have been done
-        BridgeType = Constraint.concrete_bridge_type(b, typeof(f), typeof(s))
+        BridgeType = Constraint.concrete_bridge_type(b, F, S)
         # `add_constraint` might throw an `UnsupportedConstraint` but no
         # modification has been done in the previous line
         return add_bridged_constraint(b, BridgeType, f, s)

test/Bridges/Constraint/ComplexNormInfinityToSecondOrderConeBridge.jl

@@ -58,7 +58,7 @@ function test_imag_t()
     f_x = (1.0 + 2.0im) * x[2] + (3.0 + 4.0im)
     f = MOI.Utilities.operate(vcat, Complex{Float64}, f_t, f_x)
     @test_throws(
-        ErrorException(
+        MOI.AddConstraintNotAllowed{typeof(f),MOI.NormInfinityCone}(
             "The epigraph variable `t` in `[t; x] in NormInfinityCone()` " *
             "must be real. It is: $f_t",
         ),

test/Bridges/Constraint/IndicatorToMILPBridge.jl

@@ -306,13 +306,10 @@ function test_runtests_error_not_binary()
     model = MOI.Bridges.Constraint.IndicatorToMILP{Int}(inner)
     x = MOI.add_variables(model, 2)
     MOI.add_constraint(model, x[2], MOI.Interval(0, 4))
-    c = MOI.add_constraint(
-        model,
-        MOI.VectorOfVariables(x),
-        MOI.Indicator{MOI.ACTIVATE_ON_ZERO}(MOI.GreaterThan(2)),
-    )
+    set = MOI.Indicator{MOI.ACTIVATE_ON_ZERO}(MOI.GreaterThan(2))
+    c = MOI.add_constraint(model, MOI.VectorOfVariables(x), set)
     @test_throws(
-        ErrorException(
+        MOI.AddConstraintNotAllowed{MOI.VectorOfVariables,typeof(set)}(
             "Unable to reformulate indicator constraint to a MILP. The indicator variable must be binary.",
         ),
         MOI.Bridges.final_touch(model),

test/Bridges/Constraint/IntegerToZeroOneBridge.jl

@@ -78,10 +78,7 @@ function test_finite_domain_error()
     model = MOI.Bridges.Constraint.IntegerToZeroOne{Int}(inner)
     x, _ = MOI.add_constrained_variable(model, MOI.Integer())
     @test_throws(
-        ErrorException(
-            "Unable to use IntegerToZeroOneBridge because the variable " *
-            "$(x) has a non-finite domain",
-        ),
+        MOI.Bridges.BridgeRequiresFiniteDomainError,
         MOI.Bridges.final_touch(model),
     )
     return