Fix method ambiguities in JuMP (#3092)

src/Containers/DenseAxisArray.jl

@@ -261,6 +261,7 @@ function Base.similar(
 ) where {T,N,Ax,S}
     return construct_undef_array(S, axes)
 end
+
 # Avoid conflict with method defined in Julia Base when the axes of the
 # `DenseAxisArray` are all `Base.OneTo`:
 function Base.similar(

src/aff_expr.jl

@@ -428,6 +428,14 @@ end
 
 # With two factors.
 
+function add_to_expression!(
+    expr::GenericAffExpr{C,V},
+    α::_Constant,
+    β::_Constant,
+) where {C,V}
+    return add_to_expression!(expr, *(α, β))
+end
+
 function add_to_expression!(
     aff::GenericAffExpr{C,V},
     new_coef::_Constant,
@@ -445,6 +453,15 @@ function add_to_expression!(
     return add_to_expression!(aff, new_coef, new_var)
 end
 
+function add_to_expression!(
+    aff::GenericAffExpr{C,V},
+    new_coef::V,
+    new_var::V,
+) where {C,V<:_Constant}
+    _add_or_set!(aff.terms, new_var, convert(C, _constant_to_number(new_coef)))
+    return aff
+end
+
 function add_to_expression!(
     aff::GenericAffExpr{S,V},
     coef::_Constant,

src/mutable_arithmetics.jl

@@ -258,14 +258,6 @@ function _MA.operate!(
 ) where {N}
     return _add_sub_mul_reorder!(op, expr, x, y, z, other_args...)
 end
-# This method is missing for both affine and quadratic expressions.
-function add_to_expression!(
-    expr::_GenericAffOrQuadExpr,
-    α::_Constant,
-    β::_Constant,
-)
-    return add_to_expression!(expr, *(α, β))
-end
 
 const _AffineLike = Union{AbstractVariableRef,GenericAffExpr,_Constant}
 

src/quad_expr.jl

@@ -318,6 +318,14 @@ end
 
 # With two factors.
 
+function add_to_expression!(
+    expr::GenericQuadExpr{C,V},
+    α::_Constant,
+    β::_Constant,
+) where {C,V}
+    return add_to_expression!(expr, *(α, β))
+end
+
 function add_to_expression!(
     quad::GenericQuadExpr{C,V},
     new_coef::_Constant,
@@ -335,6 +343,15 @@ function add_to_expression!(
     return add_to_expression!(quad, new_coef, new_var)
 end
 
+function add_to_expression!(
+    quad::GenericQuadExpr{C,V},
+    new_coef::V,
+    new_var::V,
+) where {C,V<:Union{Number,LinearAlgebra.UniformScaling}}
+    add_to_expression!(quad.aff, new_coef, new_var)
+    return quad
+end
+
 function add_to_expression!(
     quad::GenericQuadExpr,
     new_coef::_Constant,
@@ -391,6 +408,14 @@ function add_to_expression!(
     return add_to_expression!(quad, var, aff)
 end
 
+function add_to_expression!(
+    quad::GenericQuadExpr{C,V},
+    aff::GenericAffExpr{C,V},
+    var::V,
+) where {C,V<:Union{Number,LinearAlgebra.UniformScaling}}
+    return add_to_expression!(quad, var, aff)
+end
+
 function add_to_expression!(
     quad::GenericQuadExpr{C,V},
     lhs::GenericAffExpr{C,V},

test/expr.jl

@@ -411,3 +411,18 @@ end
     map_coefficients_inplace!(c -> 2c, y)
     @test y == 2 * x[1] + 4 * x[2] + 6 * x[1]^2 + 8 * x[2]^2
 end
+
+@testset "expression_ambiguities" begin
+    # These tests use expressions with unusual key types so that we can test
+    # the fallback methods needed to avoid method ambiguities.
+    model = Model()
+    quad = GenericQuadExpr{Int,Int}()
+    aff = GenericAffExpr{Int,Int}(0, 1 => 1)
+    @test add_to_expression!(quad, aff, 1) isa GenericQuadExpr
+    @test quad == GenericQuadExpr{Int,Int}(aff)
+    quad = GenericQuadExpr{Int,Int}()
+    @test add_to_expression!(quad, 0, 0) isa GenericQuadExpr
+    @variable(model, x)
+    @test add_to_expression!(x + 1.0, 1.0, 2) isa GenericAffExpr
+    @test add_to_expression!(x^2, 1.0, 2) isa GenericQuadExpr
+end

test/runtests.jl

@@ -11,6 +11,14 @@
 #############################################################################
 
 using Test
+import JuMP
+
+@testset "Ambiguities" begin
+    # It is important to run these first, before the tests start adding methods.
+    @test isempty(Test.detect_ambiguities(JuMP))
+    # TODO(odow): there are still some ambiguities in Containers
+    # @test isempty(Test.detect_ambiguities(JuMP.Containers))
+end
 
 t = time()
 include("Containers/Containers.jl")