Fix promotion with nonconcrete types (#166)

* Fix promotion with nonconcrete types

* Checkout deps

* Fix tests for Julia v1.0

* Revert "Checkout deps"

This reverts commit 4f569bb.

Author: blegat

src/promote.jl

@@ -28,6 +28,58 @@ function promote_rule_constant(::Type{S}, PT::Type{<:APL{T}}) where {S, T}
 end
 Base.promote_rule(::Type{PT}, ::Type{T}) where {T, PT<:APL} = promote_rule_constant(T, PT)
 Base.promote_rule(::Type{T}, ::Type{PT}) where {T, PT<:APL} = promote_rule_constant(T, PT)
+# Resolve method ambiguity with Base:
+Base.promote_rule(::Type{Any}, ::Type{<:APL}) = Any
+
+# We don't have any information on the MultivariatePolynomials implementation,
+# so we won't be able to convert the constant to `APL`.
+promote_rule_constant(::Type, PT::Type{AbstractMonomialLike}) = Any
+promote_rule_constant(::Type, PT::Type{AbstractTermLike{T}}) where {T} = Any
+promote_rule_constant(::Type, PT::Type{AbstractTermLike}) = Any
+promote_rule_constant(::Type, PT::Type{APL{T}}) where {T} = Any
+promote_rule_constant(::Type, PT::Type{APL}) = Any
+
+# AbstractMonomialLike{T}
+Base.promote_rule(::Type{AbstractMonomialLike}, ::Type{<:AbstractMonomialLike}) = AbstractMonomialLike
+Base.promote_rule(::Type{<:AbstractMonomialLike}, ::Type{AbstractMonomialLike}) = AbstractMonomialLike
+Base.promote_rule(::Type{AbstractMonomialLike}, ::Type{<:AbstractTermLike{T}}) where {T} = _atl(Int, T)
+Base.promote_rule(::Type{<:AbstractTermLike{T}}, ::Type{AbstractMonomialLike}) where {T} = _atl(Int, T)
+Base.promote_rule(::Type{AbstractMonomialLike}, ::Type{AbstractTermLike{T}}) where {T} = _atl(Int, T)
+Base.promote_rule(::Type{AbstractTermLike{T}}, ::Type{AbstractMonomialLike}) where {T} = _atl(Int, T)
+Base.promote_rule(::Type{AbstractMonomialLike}, ::Type{<:APL{T}}) where {T} = _apl(Int, T)
+Base.promote_rule(::Type{<:APL{T}}, ::Type{AbstractMonomialLike}) where {T} = _apl(Int, T)
+Base.promote_rule(::Type{AbstractMonomialLike}, ::Type{APL{T}}) where {T} = _apl(Int, T)
+Base.promote_rule(::Type{APL{T}}, ::Type{AbstractMonomialLike}) where {T} = _apl(Int, T)
+
+# AbstractTermLike{T}
+_atl(::Type{T}, ::Type{T}) where {T} = AbstractTermLike{T}
+_atl(::Type, ::Type) = AbstractTermLike
+__atl(::Type{T}, ::Type{<:AbstractTermLike{S}}) where {S,T} = _atl(T, S)
+__atl(::Type{T}, ::Type{<:APL{S}}) where {S,T} = _apl(T, S)
+Base.promote_rule(::Type{AbstractTermLike{T}}, P::Type{<:AbstractTermLike{S}}) where {S,T} = _atl(T, S)
+Base.promote_rule(P::Type{<:AbstractTermLike{S}}, ::Type{AbstractTermLike{T}}) where {S,T} = _atl(T, S)
+Base.promote_rule(::Type{AbstractTermLike{T}}, P::Type{<:APL{S}}) where {S,T} = _apl(T, S)
+Base.promote_rule(P::Type{<:APL{S}}, ::Type{AbstractTermLike{T}}) where {S,T} = _apl(T, S)
+Base.promote_rule(::Type{AbstractTermLike{T}}, P::Type{APL{S}}) where {S,T} = _apl(T, S)
+Base.promote_rule(P::Type{APL{S}}, ::Type{AbstractTermLike{T}}) where {S,T} = _apl(T, S)
+
+# AbstractTermLike
+Base.promote_rule(::Type{AbstractTermLike}, ::Type{<:AbstractTermLike}) = AbstractTermLike
+Base.promote_rule(::Type{<:AbstractTermLike}, ::Type{AbstractTermLike}) = AbstractTermLike
+Base.promote_rule(::Type{AbstractTermLike}, ::Type{<:APL}) = APL
+Base.promote_rule(::Type{<:APL}, ::Type{AbstractTermLike}) = APL
+Base.promote_rule(::Type{AbstractTermLike}, ::Type{APL}) = APL
+Base.promote_rule(::Type{APL}, ::Type{AbstractTermLike}) = APL
+
+# APL{T}
+_apl(::Type{T}, ::Type{T}) where {T} = APL{T}
+_apl(::Type, ::Type) = APL
+Base.promote_rule(::Type{APL{T}}, ::Type{<:APL{S}}) where {S,T} = _apl(S, T)
+Base.promote_rule(::Type{<:APL{S}}, ::Type{APL{T}}) where {S,T} = _apl(S, T)
+
+# APL
+Base.promote_rule(::Type{APL}, ::Type{<:APL}) = APL
+Base.promote_rule(::Type{<:APL}, ::Type{APL}) = APL
 
 # Rational
 promote_rule_constant(::Type{T}, ::Type{RationalPoly{NT, DT}}) where {T, NT, DT} = RationalPoly{promote_type(T, NT), promote_type(DT, termtype(DT))}

test/promote.jl

@@ -22,6 +22,73 @@
     @test Y[1] == x + 3y
     @test Y[2] == 2x + 4y
     @test dot(X, [1 2; 3 4] * X) == x^2 + 5x*y + 4y^2
+
+    function _t(a, b, T)
+        if VERSION < v"1.6"
+            @test typeof(@inferred vcat(a, b)) in [Vector{T}, Vector{Any}]
+            @test typeof(@inferred vcat(b, a)) in [Vector{T}, Vector{Any}]
+        else
+            @test typeof(@inferred vcat(a, b)) == Vector{T}
+            @test typeof(@inferred vcat(b, a)) == Vector{T}
+        end
+    end
+
+    function __test(a, PT, TT, MT)
+        @test typeof(a) == Vector{MT(Int)}
+        _t(a, 1, Any)
+        _t(a, x, MT(Int))
+        _t(a, x^2, MT(Int))
+        _t(a, 1x, TT(Int))
+        _t(a, 1.0x, TT())
+        _t(a, x + y, PT(Int))
+        _t(a, 1.0x + y, PT())
+    end
+
+    function _test(a, af, TT)
+        __test(a, apl, TT, TT)
+        # `x isa APL{Int}` so here we don't have `Float64`:
+        pt() = apl()
+        pt(T) = apl()
+        tt() = TT()
+        tt(T) = TT()
+        __test(af, pt, tt, tt)
+        @test typeof(af) == Vector{TT()}
+        _t(af, a, TT())
+    end
+
+    apl() = MP.APL
+    apl(T::Type) = MP.APL{T}
+    p = [i == 1 ? x + y : x for i in 1:2]
+    pf = [i == 1 ? 1.0x + y : x for i in 1:2]
+    _test(p, pf, apl)
+
+    atl() = MP.AbstractTermLike
+    atl(T::Type) = MP.AbstractTermLike{T}
+    t = [i == 1 ? 2x : x for i in 1:2]
+    tf = [i == 1 ? 2.0x : x for i in 1:2]
+    _test(t, tf, atl)
+    _t(p, t, apl(Int))
+    _t(pf, t, apl())
+    _t(p, tf, apl())
+    _t(pf, tf, apl())
+
+    __pt = Base.promote_typejoin(typeof(x + 2), typeof(x + 2.0))
+    _pt() = __pt
+    _pt(::Type) = __pt
+    __test([i == 1 ? x + 2 : x + 2.0 for i in 1:2], _pt, _pt, _pt)
+
+    __tt = Base.promote_typejoin(typeof(2x), typeof(2.0x))
+    _tt() = __tt
+    _tt(::Type) = __tt
+    __test([i == 1 ? 2x : 2.0x for i in 1:2], _pt, _tt, _tt)
+
+    aml(args...) = MP.AbstractMonomialLike
+    a = [i == 1 ? x^2 : x for i in 1:2]
+    __test(a, apl, atl, aml)
+    _t(a, t, atl(Int))
+    _t(a, tf, atl())
+    _t(a, p, apl(Int))
+    _t(a, pf, apl())
 end
 
 struct A end