Fix error with external functions and sets. (#582)

* Fix error with external functions and sets.

* Tidy model tests

* Fix and add tests for external sets in `@bridge`.

Author: odow

src/Bridges/singlebridgeoptimizer.jl

@@ -43,8 +43,8 @@ macro bridge(modelname, bridge, ss, sst, vs, vst, sf, sft, vf, vft)
 
     esc(quote
         $MOIU.@model $bridged_model_name $ss $sst $vs $vst $sf $sft $vf $vft
-        const $modelname{T, OT<:MOI.ModelLike} = $MOIB.SingleBridgeOptimizer{$bridge{T}, $bridged_model_name{T}, OT}
+        const $modelname{T, OT<:$MOI.ModelLike} = $MOIB.SingleBridgeOptimizer{$bridge{T}, $bridged_model_name{T}, OT}
         $MOIB.is_bridged(::$modelname, ::Type{<:$bridged_funs}, ::Type{<:$bridged_sets}) = true
-        supports_bridging_constraint(::$modelname, ::Type{<:$bridged_funs}, ::Type{<:$bridged_sets}) = true
+        $MOIB.supports_bridging_constraint(::$modelname, ::Type{<:$bridged_funs}, ::Type{<:$bridged_sets}) = true
     end)
 end

src/Utilities/model.jl

@@ -465,8 +465,8 @@ end
 
 # (MOI, :Zeros) -> :(MOI.Zeros)
 # (:Zeros) -> :(MOI.Zeros)
-_set(s::SymbolSet) = s.s
-_fun(s::SymbolFun) = s.s
+_set(s::SymbolSet) = esc(s.s)
+_fun(s::SymbolFun) = esc(s.s)
 function _typedset(s::SymbolSet)
     if s.typed
         :($(_set(s)){T})

test/Utilities/model.jl

@@ -1,5 +1,37 @@
 # TODO: It's hard to find where Model is defined!
 
+# We need to test this in a module at the top level because it can't be defined
+# in a testset. If it runs without error, then we're okay.
+module TestExternalModel
+    using MathOptInterface
+    struct NewSet <: MathOptInterface.AbstractScalarSet end
+    struct NewFunction <: MathOptInterface.AbstractScalarFunction end
+    Base.copy(::NewFunction) = NewFunction()
+    Base.copy(::NewSet) = NewSet()
+    MathOptInterface.Utilities.@model(ExternalModel,
+        (MathOptInterface.ZeroOne, NewSet,),
+        (),
+        (),
+        (),
+        (NewFunction,),
+        (),
+        (),
+        ()
+    )
+end
+
+@testset "External @model" begin
+    model = TestExternalModel.ExternalModel{Float64}()
+    c = MOI.add_constraint(
+        model, TestExternalModel.NewFunction(), TestExternalModel.NewSet())
+    @test typeof(c) == MOI.ConstraintIndex{TestExternalModel.NewFunction,
+        TestExternalModel.NewSet}
+    c2 = MOI.add_constraint(
+        model, TestExternalModel.NewFunction(), MOI.ZeroOne())
+    @test typeof(c2) ==
+        MOI.ConstraintIndex{TestExternalModel.NewFunction, MOI.ZeroOne}
+end
+
 @testset "Name test" begin
     MOIT.nametest(Model{Float64}())
 end

test/bridge.jl

@@ -397,3 +397,57 @@ end
                                                 (MOI.VectorAffineFunction{Float64}, MOI.PositiveSemidefiniteConeTriangle, 0)))
     end
 end
+
+# We need to test this in a module at the top level because it can't be defined
+# in a testset. If it runs without error, then we're okay.
+module TestExternalBridge
+    using MathOptInterface
+
+    struct StrictlyGreaterThan <: MathOptInterface.AbstractScalarSet end
+    struct StrictlyGreaterBridge{T} <: MathOptInterface.Bridges.AbstractBridge end
+
+    function StrictlyGreaterBridge(
+            model,
+            func::MathOptInterface.SingleVariable,
+            set::StrictlyGreaterThan)
+        return StrictlyGreaterBridge{Float64}()
+    end
+
+    function MathOptInterface.supports_constraint(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return true
+    end
+
+    function MathOptInterface.Bridges.added_constraint_types(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return [(
+            MathOptInterface.SingleVariable,
+            MathOptInterface.GreaterThan{T}
+        )]
+    end
+
+    MathOptInterface.Bridges.@bridge(StrictlyGreater, StrictlyGreaterBridge,
+        (StrictlyGreaterThan, ),
+        (),
+        (),
+        (),
+        (MathOptInterface.SingleVariable, ),
+        (),
+        (),
+        ()
+    )
+end
+
+@testset "@bridge with external components" begin
+    model = SimpleModel{Float64}();
+    @test MOI.supports_constraint(model, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test !MOI.supports_constraint(model, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+
+    bridge = TestExternalBridge.StrictlyGreater{Float64}(model);
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+end

test/hygiene.jl

@@ -3,8 +3,7 @@ module Hygiene
 using Compat, Compat.Test
 
 import MathOptInterface
-# We do not define MOI and MOIU constants as the macros
-# should not rely on the fact that theses are defined in the outer scope
+const MOI = MathOptInterface
 
 # Dict is used in the @model macro but setting Dict in the outer scope
 # should not affect it