reduce PR scope, use recursion instead of looping for better inference

Author: nsajko

base/promotion.jl

@@ -302,52 +302,38 @@ promote_type(T) = T
 promote_type(T, S, U) = (@inline; promote_type(promote_type(T, S), U))
 promote_type(T, S, U, V...) = (@inline; afoldl(promote_type, promote_type(T, S, U), V...))
 
+function _promote_type_binary(::Type, ::Type, ::Tuple{})
+    @noinline
+    s = "`promote_type`: recursion depth limit reached, giving up; check for faulty/conflicting/missing `promote_rule` methods"
+    throw(ArgumentError(s))
+end
+function _promote_type_binary(::Type{Bottom}, ::Type{Bottom}, ::Tuple{Nothing,Vararg{Nothing}})
+    Bottom
+end
+function _promote_type_binary(::Type{T}, ::Type{T}, ::Tuple{Nothing,Vararg{Nothing}}) where {T}
+    T
+end
+function _promote_type_binary(::Type{T}, ::Type{Bottom}, ::Tuple{Nothing,Vararg{Nothing}}) where {T}
+    T
+end
+function _promote_type_binary(::Type{Bottom}, ::Type{T}, ::Tuple{Nothing,Vararg{Nothing}}) where {T}
+    T
+end
+function _promote_type_binary(::Type{T}, ::Type{S}, recursion_depth_limit::Tuple{Nothing,Vararg{Nothing}}) where {T,S}
+    # Try promote_rule in both orders.
+    promote_result(T, S, promote_rule(T,S), promote_rule(S,T), recursion_depth_limit)
+end
+
+const _promote_type_binary_recursion_depth_limit = ((nothing for _ in 1:28)...,)  # recursion depth limit to prevent stack overflow
+
 function promote_type(::Type{T}, ::Type{S}) where {T,S}
-    @_terminates_locally_meta
-    normalized_type(::Type{Typ}) where {Typ} = Typ
-    types_are_equal(::Type, ::Type) = false
-    types_are_equal(::Type{Typ}, ::Type{Typ}) where {Typ} = true
-    is_bottom(::Type) = false
-    is_bottom(::Type{Bottom}) = true
-    function throw_conflicting_promote_rules((@nospecialize i1::Type), (@nospecialize i2::Type), (@nospecialize left::Type), (@nospecialize right::Type))
-        @noinline
-        s = LazyString("`promote_type(", i1, ", ", i2, ")` failed, there are conflicting `promote_rule` definitions for types ", left, ", ", right)
-        throw(ArgumentError(s))
-    end
-    function throw_gave_up((@nospecialize i1::Type), (@nospecialize i2::Type), (@nospecialize left::Type), (@nospecialize right::Type))
-        @noinline
-        s = LazyString("`promote_type(", i1, ", ", i2, ")` failed, ended up with (", left, ", ", right, "), check for faulty `promote_rule` methods")
-        throw(ArgumentError(s))
-    end
-    left = T
-    right = S
-    for _ ∈ 1:1000  # guarantee local termination
-        if types_are_equal(left, right) || is_bottom(left) || is_bottom(right)
-            break
-        end
-        # Try `promote_rule` in both orders.
-        a = normalized_type(promote_rule(left, right))
-        b = normalized_type(promote_rule(right, left))
-        loop_is_detected_1 = types_are_equal(left, a) && types_are_equal(right, b)
-        loop_is_detected_2 = types_are_equal(left, b) && types_are_equal(right, a)
-        if loop_is_detected_1 || loop_is_detected_2
-            throw_conflicting_promote_rules(T, S, left, right)
-        end
-        if is_bottom(a) && is_bottom(b)
-            # If no `promote_rule` is defined, both directions give `Bottom`. In that
-            # case use `typejoin` on the original types.
-            return typejoin(left, right)
-        end
-        left = a
-        right = b
-    end
-    if types_are_equal(left, right) || is_bottom(left)
-        right
-    elseif is_bottom(right)
-        left
-    else
-        throw_gave_up(T, S, left, right)
-    end
+    @inline
+    # Try promote_rule in both orders. Typically only one is defined,
+    # and there is a fallback returning Bottom below, so the common case is
+    #   promote_type(T, S) =>
+    #   promote_result(T, S, result, Bottom) =>
+    #   typejoin(result, Bottom) => result
+    _promote_type_binary(T, S, _promote_type_binary_recursion_depth_limit)
 end
 
 """
@@ -367,6 +353,11 @@ promote_rule(::Type{Bottom}, ::Type{Bottom}, slurp...) = Bottom # not strictly n
 promote_rule(::Type{Bottom}, ::Type{T}, slurp...) where {T} = T
 promote_rule(::Type{T}, ::Type{Bottom}, slurp...) where {T} = T
 
+promote_result(::Type,::Type,::Type{T},::Type{S},l::Tuple{Vararg{Nothing}}) where {T,S} = (@inline; _promote_type_binary(T,S,l))
+# If no promote_rule is defined, both directions give Bottom. In that
+# case use typejoin on the original types instead.
+promote_result(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom},::Tuple{Vararg{Nothing}}) where {T,S} = (@inline; typejoin(T, S))
+
 """
     promote(xs...)
 

test/core.jl

@@ -2028,35 +2028,14 @@ g4731() = f4731()
 @test f4731() == ""
 @test g4731() == ""
 
-@testset "type promotion" begin
-    @testset "conflicting promote_rule error, PR #57507" begin
-        struct PR57507A end
-        struct PR57507B end
-        struct PR57507C end
-        @testset "error with conflicting promote_rules" begin
-            Base.promote_rule(::Type{PR57507A}, ::Type{PR57507B}) = PR57507A
-            Base.promote_rule(::Type{PR57507B}, ::Type{PR57507A}) = PR57507B
-            @test_throws ArgumentError promote_type(PR57507A, PR57507B)
-            @test_throws ArgumentError promote_type(PR57507B, PR57507A)
-        end
-        @testset "unambiguous cases" begin
-            @test PR57507A === @inferred promote_type(PR57507A, PR57507A)
-            @test PR57507B === @inferred promote_type(PR57507B, PR57507B)
-            Base.promote_rule(::Type{PR57507C}, ::Type{PR57507A}) = PR57507C
-            Base.promote_rule(::Type{PR57507B}, ::Type{PR57507C}) = PR57507C
-            @test PR57507C === @inferred promote_type(PR57507A, PR57507C)
-            @test PR57507C === @inferred promote_type(PR57507C, PR57507B)
-        end
-    end
-    @testset "issue #13193" begin
-        struct Issue13193_SIQuantity{T<:Number} <: Number end
-        Base.promote_rule(::Type{Issue13193_SIQuantity{T}}, ::Type{Issue13193_SIQuantity{S}}) where {T, S} = Issue13193_SIQuantity{promote_type(T,S)}
-        Base.promote_rule(::Type{Issue13193_SIQuantity{T}}, ::Type{S}) where {T, S<:Number} = Issue13193_SIQuantity{promote_type(T,S)}
-        struct Issue13193_Interval{T<:Number} <: Number end
-        Base.promote_rule(::Type{Issue13193_Interval{T}}, ::Type{Issue13193_Interval{S}}) where {T, S} = Issue13193_Interval{promote_type(T,S)}
-        Base.promote_rule(::Type{Issue13193_Interval{T}}, ::Type{S}) where {T, S<:Number} = Issue13193_Interval{promote_type(T,S)}
-        @test_throws ArgumentError promote_type(Issue13193_Interval{Int}, Issue13193_SIQuantity{Int})
-    end
+@testset "issue #13193" begin
+    struct Issue13193_SIQuantity{T<:Number} <: Number end
+    Base.promote_rule(::Type{Issue13193_SIQuantity{T}}, ::Type{Issue13193_SIQuantity{S}}) where {T, S} = Issue13193_SIQuantity{promote_type(T,S)}
+    Base.promote_rule(::Type{Issue13193_SIQuantity{T}}, ::Type{S}) where {T, S<:Number} = Issue13193_SIQuantity{promote_type(T,S)}
+    struct Issue13193_Interval{T<:Number} <: Number end
+    Base.promote_rule(::Type{Issue13193_Interval{T}}, ::Type{Issue13193_Interval{S}}) where {T, S} = Issue13193_Interval{promote_type(T,S)}
+    Base.promote_rule(::Type{Issue13193_Interval{T}}, ::Type{S}) where {T, S<:Number} = Issue13193_Interval{promote_type(T,S)}
+    @test_throws ArgumentError promote_type(Issue13193_Interval{Int}, Issue13193_SIQuantity{Int})
 end
 
 # issue #4675