Update

Author: odow

src/Bridges/Constraint/bridge.jl

@@ -19,7 +19,6 @@ additionally implement:
 """
 abstract type AbstractBridge <: MOI.Bridges.AbstractBridge end
 
-@nospecialize
 """
     MOI.supports_constraint(
         BT::Type{<:AbstractBridge},
@@ -37,13 +36,12 @@ Return a `Bool` indicating whether the bridges of type `BT` support bridging
    constraint types that the bridge implements.
 """
 function MOI.supports_constraint(
-    ::Type{<:AbstractBridge},
-    ::Type{<:MOI.AbstractFunction},
-    ::Type{<:MOI.AbstractSet},
+    @nospecialize(BT::Type{<:AbstractBridge}),
+    @nospecialize(F::Type{<:MOI.AbstractFunction}),
+    @nospecialize(S::Type{<:MOI.AbstractSet}),
 )
     return false
 end
-@specialize
 
 """
     concrete_bridge_type(

src/Bridges/Constraint/single_bridge_optimizer.jl

@@ -105,9 +105,9 @@ function MOI.Bridges.supports_bridging_constrained_variable(
 end
 
 function MOI.Bridges.supports_bridging_constraint(
-    ::SingleBridgeOptimizer{BT},
-    F::Type{<:MOI.AbstractFunction},
-    S::Type{<:MOI.AbstractSet},
+    @nospecialize(b::SingleBridgeOptimizer{BT}),
+    @nospecialize(F::Type{<:MOI.AbstractFunction}),
+    @nospecialize(S::Type{<:MOI.AbstractSet}),
 ) where {BT}
     return MOI.supports_constraint(BT, F, S)
 end

src/Bridges/lazy_bridge_optimizer.jl

@@ -149,54 +149,52 @@ function _reset_bridge_graph(b::LazyBridgeOptimizer)
     return
 end
 
-@nospecialize
 """
     _variable_nodes(b::LazyBridgeOptimizer, ::Type{BT}) where {BT}
 
 Return the list of `VariableNode` that would be added if `BT` is used in `b`.
 """
 function _variable_nodes(
-    b::LazyBridgeOptimizer,
-    ::Type{BT},
-) where {BT<:AbstractBridge}
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(BT::Type{<:AbstractBridge}),
+)
     return map(added_constrained_variable_types(BT)) do (S,)
         return node(b, S)::VariableNode
     end
 end
-@specialize
 
-@nospecialize
 """
     _constraint_nodes(b::LazyBridgeOptimizer, ::Type{BT}) where {BT}
 
 Return the list of `ConstraintNode` that would be added if `BT` is used in `b`.
 """
 function _constraint_nodes(
-    b::LazyBridgeOptimizer,
-    ::Type{BT},
-) where {BT<:AbstractBridge}
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(BT::Type{<:AbstractBridge}),
+)
     return ConstraintNode[
         node(b, F, S) for (F, S) in added_constraint_types(BT)
     ]
 end
-@specialize
 
-@nospecialize
 """
     _edge(b::LazyBridgeOptimizer, index::Int, BT::Type{<:AbstractBridge})
 
 Return the `Edge` or `ObjectiveEdge` in the hyper-graph associated with the
 bridge `BT`, where `index` is the index of `BT` in the list of bridges.
 """
-function _edge(b::LazyBridgeOptimizer, index::Int, BT::Type{<:AbstractBridge})
+function _edge(
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(index::Int),
+    @nospecialize(BT::Type{<:AbstractBridge}),
+)
     return Edge(
         index,
         _variable_nodes(b, BT),
         _constraint_nodes(b, BT),
         bridging_cost(BT),
     )
 end
-@specialize
 
 # Method for objective bridges because they produce ObjectiveEdge.
 function _edge(
@@ -310,9 +308,9 @@ end
 Return the `ConstraintNode` associated with constraint `F`-in-`S` in `b`.
 """
 function node(
-    b::LazyBridgeOptimizer,
-    F::Type{<:MOI.AbstractFunction},
-    S::Type{<:MOI.AbstractSet},
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(F::Type{<:MOI.AbstractFunction}),
+    @nospecialize(S::Type{<:MOI.AbstractSet}),
 )
     # If we support the constraint type, the node is 0.
     if MOI.supports_constraint(b.model, F, S)
@@ -382,14 +380,12 @@ function _bridge_types(
     return b.variable_bridge_types
 end
 
-@nospecialize
 function _bridge_types(
-    b::LazyBridgeOptimizer,
-    ::Type{<:Constraint.AbstractBridge},
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(BT::Type{<:Constraint.AbstractBridge}),
 )
     return b.constraint_bridge_types
 end
-@specialize
 
 function _bridge_types(
     b::LazyBridgeOptimizer,
@@ -398,20 +394,21 @@ function _bridge_types(
     return b.objective_bridge_types
 end
 
-@nospecialize
 """
     add_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
 
 Enable the use of the bridges of type `BT` by `b`.
 """
-function add_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
+function add_bridge(
+    @nospecialize(b::LazyBridgeOptimizer), 
+    @nospecialize(BT::Type{<:AbstractBridge}),
+)
     if !has_bridge(b, BT)
         push!(_bridge_types(b, BT), BT)
         _reset_bridge_graph(b)
     end
     return
 end
-@specialize
 
 """
     remove_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
@@ -432,16 +429,17 @@ function remove_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
     return
 end
 
-@nospecialize
 """
     has_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
 
 Return a `Bool` indicating whether the bridges of type `BT` are used by `b`.
 """
-function has_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})::Bool
+function has_bridge(
+    @nospecialize(b::LazyBridgeOptimizer),
+    @nospecialize(BT::Type{<:AbstractBridge}),
+)::Bool
     return findfirst(isequal(BT), _bridge_types(b, BT)) !== nothing
 end
-@specialize
 
 # It only bridges when the constraint is not supporting, hence the name "Lazy"
 function is_bridged(b::LazyBridgeOptimizer, S::Type{<:MOI.AbstractScalarSet})

src/Test/Test.jl

@@ -499,17 +499,15 @@ function _test_attribute_value_type(
     return
 end
 
-@nospecialize
 function _test_attribute_value_type(
-    model::MOI.ModelLike,
-    attribute::MOI.AbstractConstraintAttribute,
-    ci::MOI.ConstraintIndex,
+    @nospecialize(model::MOI.ModelLike),
+    @nospecialize(attribute::MOI.AbstractConstraintAttribute),
+    @nospecialize(ci::MOI.ConstraintIndex),
 )
     T = MOI.attribute_value_type(attribute)
     @test @inferred(T, MOI.get(model, attribute, ci)) isa T
     return
 end
-@specialize
 
 function _test_attribute_value_type(
     model::MOI.ModelLike,

src/Utilities/model.jl

@@ -302,15 +302,13 @@ function MOI.is_valid(model::AbstractModel, ci::MOI.ConstraintIndex)
     return MOI.is_valid(constraints(model, ci), ci)
 end
 
-@nospecialize
 function MOI.supports_constraint(
-    model::AbstractModel,
-    ::Type{F},
-    ::Type{S},
-) where {F<:MOI.AbstractFunction,S<:MOI.AbstractSet}
+    @nospecialize(model::AbstractModel),
+    @nospecialize(F::Type{<:MOI.AbstractFunction}),
+    @nospecialize(S::Type{<:MOI.AbstractSet}),
+)
     return MOI.supports_constraint(model.constraints, F, S)
 end
-@specialize
 
 function MOI.add_constraint(
     model::AbstractModel,

src/constraints.jl

@@ -4,7 +4,6 @@
 # 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.
 
-@nospecialize
 """
     supports_constraint(
         model::ModelLike,
@@ -19,13 +18,12 @@ supported in specific circumstances, for example, `F`-in-`S` constraints cannot
 combined with another type of constraint, it should still return `true`.
 """
 function supports_constraint(
-    ::ModelLike,
-    ::Type{<:AbstractFunction},
-    ::Type{<:AbstractSet},
+    @nospecialize(::ModelLike),
+    @nospecialize(F::Type{<:AbstractFunction}),
+    @nospecialize(S::Type{<:AbstractSet}),
 )
     return false
 end
-@specialize
 
 """
     struct UnsupportedConstraint{F<:AbstractFunction,S<:AbstractSet} <: UnsupportedError