fixed promote_type inference for special MethodAmbiguitiy failure

also added further tests

Author: Stephan Sahm

src/promote_type.jl

@@ -59,36 +59,51 @@ Base.promote_rule(::Type{Identity}, ::Type{Either}) = Either
 
 # As a workaround, we overload `promote_type` to deal with our symmetric case
 function Base.promote_type(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2, R2}
-    Base.@_inline_meta
     T = Either{L1, R1}
     S = Either{L2, R2}
-    # we use typeintersect, as we get an Either for the non-fitting site,
-    # thanks to Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2, R2} = Either
-    typeintersect(promote_rule(T, S), promote_rule(S, T))
+    either_promote_type_fix(T, S)
 end
 
 function Base.promote_type(::Type{Either{<:Any, R1}}, ::Type{Either{<:Any, R2}}) where {R1, R2}
-    Base.@_inline_meta
     T = Either{<:Any, R1}
     S = Either{<:Any, R2}
-    # we use typeintersect, as we get an Either for the non-fitting site,
-    # thanks to Base.promote_rule(::Type{Either{<:Any, R1}}, ::Type{Either{<:Any, R2}}) where {R1, R2} = Either
-    typeintersect(promote_rule(T, S), promote_rule(S, T))
+    either_promote_type_fix(T, S)
 end
 
 function Base.promote_type(::Type{Either{L1, <:Any}}, ::Type{Either{L2, <:Any}}) where {L1, L2}
-    Base.@_inline_meta
     T = Either{L1, <:Any}
     S = Either{L2, <:Any}
-    # we use typeintersect, as we get an Either for the non-fitting site,
-    # thanks to Base.promote_rule(::Type{Either{L1, <:Any}}, ::Type{Either{L2, <:Any}}) where {L1, L2} = Either
-    typeintersect(promote_rule(T, S), promote_rule(S, T))
+    either_promote_type_fix(T, S)
+end
+
+function either_promote_type_fix(T, S)
+    # In addition we need to check for MethodAmbiguities, as we cannot resolve them on one side, we just ignore them
+    a = @TryCatch MethodError promote_rule(T, S)
+    b = @TryCatch MethodError promote_rule(S, T)
+
+    if isexception(a) && isexception(b)
+        error("Could not `promote_type{T=$T, S=$S}`, as both `promote_rule(T, S)` and `promote_rule(S, T)` result in
+               MethodErrors: $a, $b.")
+    elseif issuccess(a) && issuccess(b)
+        # We use typeintersect, as we get an Either for the non-fitting site,
+        # thanks to
+        # * Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2, R2} = Either
+        # * Base.promote_rule(::Type{Either{<:Any, R1}}, ::Type{Either{<:Any, R2}}) where {R1, R2} = Either
+        # * Base.promote_rule(::Type{Either{L1, <:Any}}, ::Type{Either{L2, <:Any}}) where {L1, L2} = Either
+        typeintersect(a[], b[])
+    elseif issuccess(a)
+        a[]
+    else
+        b[]
+    end
 end
 
 # we need to be cautious here, as we cannot dispatch on Type{<:Either{<:Any, R}} or similar, because R might not be defined
 Base.promote_rule(::Type{Either{L, R}}, ::Type{Either{L, R}}) where {L, R} = Either{L, R}
 Base.promote_rule(::Type{Either{L1, R}}, ::Type{Either{L2, R}}) where {L1, R, L2 <: L1} = Either{L1, R}
 Base.promote_rule(::Type{Either{L, R1}}, ::Type{Either{L, R2}}) where {L, R1, R2 <: R1} = Either{L, R1}
+Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2 <: L1, R2} = Either{L1, <:Any}
+Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2, R2 <: R1} = Either{<:Any, R1}
 Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
 Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
 

test/promote_type.jl

@@ -153,18 +153,33 @@ using DataTypesBasic
 # ---------------
 
 @test promote_type(Either{String, Integer}, Either{String, Integer}) == Either{String, Integer}
-@test promote_type(Either{AbstractString, Integer}, Either{String, Number}) == Either{AbstractString, Number}
+@test promote_type(Either{Integer, AbstractString}, Either{Integer, String}) == Either{Integer, AbstractString}
 @test promote_type(Either{Integer, AbstractString}, Either{Number, String}) == Either{Number, AbstractString}
+@test promote_type(Either{AbstractString, Integer}, Either{String, Integer}) == Either{AbstractString, Integer}
+@test promote_type(Either{AbstractString, Integer}, Either{String, Number}) == Either{AbstractString, Number}
+@test promote_type(Either{Number, String}, Either{Integer, AbstractString}) == Either{Number, AbstractString}
+
+@test promote_type(Either{Integer, AbstractString}, Either{Integer, Bool}) == Either{Integer, <:Any}
+@test promote_type(Either{Integer, AbstractString}, Either{Number, Bool}) == Either{Number, <:Any}
+@test promote_type(Either{Integer, String}, Either{String, String}) == Either{<:Any, String}
+@test promote_type(Either{Integer, AbstractString}, Either{String, String}) == Either{<:Any, AbstractString}
 
+@test promote_type(Either{<:Any, Integer}, Either{<:Any, Integer}) == Either{<:Any, Integer}
 @test promote_type(Either{<:Any, Integer}, Either{<:Any, Number}) == Either{<:Any, Number}
+@test promote_type(Either{String, <:Any}, Either{String, <:Any}) == Either{String, <:Any}
 @test promote_type(Either{String, <:Any}, Either{AbstractString, <:Any}) == Either{AbstractString, <:Any}
 @test promote_type(Either, Either) == Either
 
 @test Base.promote_typejoin(Either{Int, String}, Either{Int, String}) == Either{Int, String}
+
 @test Base.promote_typejoin(Either{Int, String}, Either{Number, String}) == Either{<:Any, String}
 @test Base.promote_typejoin(Either{Number, String}, Either{Int, String}) == Either{<:Any, String}
 @test Base.promote_typejoin(Either{Number, String}, Either{Int, AbstractString}) == Either
 
+@test Base.promote_typejoin(Either{String, Int}, Either{String, Number}) == Either{String, <:Any}
+@test Base.promote_typejoin(Either{String, Number}, Either{String, Int}) == Either{String, <:Any}
+@test Base.promote_typejoin(Either{String, Number}, Either{AbstractString, Int}) == Either
+
 @test Base.promote_typejoin(Either{Int, <:Any}, Either{Int, <:Any}) == Either{Int, <:Any}
 @test Base.promote_typejoin(Either{Int, <:Any}, Either{Number, <:Any}) == Either
 @test Base.promote_typejoin(Either{Number, <:Any}, Either{Int, <:Any}) == Either