Fix length calculation of broadcast over tuples

Author: pabloferz

base/broadcast.jl

@@ -11,6 +11,9 @@ export broadcast_getindex, broadcast_setindex!, dotview, @__dot__
 
 const ScalarType = Union{Type{Any}, Type{Nullable}}
 
+const OnePlusTuple{T} = Tuple{T,Vararg{T}}
+const TwoPlusTuple{T} = Tuple{T,T,Vararg{T}}
+
 ## Broadcasting utilities ##
 # fallbacks for some special cases
 @inline broadcast(f, x::Number...) = f(x...)
@@ -127,6 +130,8 @@ end
 end
 
 Base.@propagate_inbounds _broadcast_getindex(A, I) = _broadcast_getindex(containertype(A), A, I)
+# `(x,)`, where `x` is a scalar, broadcasts the same way as `[x]` or `x`
+Base.@propagate_inbounds _broadcast_getindex(::Type{Tuple}, A::Tuple{Any}, I) = A[1]
 Base.@propagate_inbounds _broadcast_getindex(::Type{Array}, A::Ref, I) = A[]
 Base.@propagate_inbounds _broadcast_getindex(::ScalarType, A, I) = A
 Base.@propagate_inbounds _broadcast_getindex(::Any, A, I) = A[I]
@@ -333,13 +338,32 @@ end
 end
 @inline broadcast_c(f, ::Type{Any}, a...) = f(a...)
 @inline broadcast_c(f, ::Type{Tuple}, A, Bs...) =
-    tuplebroadcast(f, first_tuple(A, Bs...), A, Bs...)
+    tuplebroadcast(f, tuplebroadcast_maxtuple(A, Bs...), A, Bs...)
 @inline tuplebroadcast(f, ::NTuple{N,Any}, As...) where {N} =
     ntuple(k -> f(tuplebroadcast_getargs(As, k)...), Val(N))
 @inline tuplebroadcast(f, ::NTuple{N,Any}, ::Type{T}, As...) where {N,T} =
     ntuple(k -> f(T, tuplebroadcast_getargs(As, k)...), Val(N))
-first_tuple(A::Tuple, Bs...) = A
-@inline first_tuple(A, Bs...) = first_tuple(Bs...)
+# When the result of broadcast is a tuple it can only come from mixing n-tuples
+# of the same length with scalars, empty tuples and 1-tuples. So, in order to
+# have a type-stable broadcast we need to find a tuple of maximum length
+# (except when there's an empty tuple in which case we return an empty tuple as
+# well).
+# The following methods compare broadcast arguments pairwise to determine the
+# length of the final tuple.
+tuplebroadcast_maxtuple(A, B) = (nothing,)
+tuplebroadcast_maxtuple(::Tuple{}, A) = ()
+tuplebroadcast_maxtuple(A, ::Tuple{}) = ()
+tuplebroadcast_maxtuple(A::OnePlusTuple{Any}, B) = A
+tuplebroadcast_maxtuple(A, B::OnePlusTuple{Any}) = B
+tuplebroadcast_maxtuple(A::OnePlusTuple{Any}, ::Tuple{Any}) = A
+tuplebroadcast_maxtuple(::Tuple{Any}, A::OnePlusTuple{Any}) = A
+tuplebroadcast_maxtuple(::OnePlusTuple{Any}, ::Tuple{}) = ()
+tuplebroadcast_maxtuple(::Tuple{}, ::OnePlusTuple{Any}) = ()
+tuplebroadcast_maxtuple(A::NTuple{N,Any}, ::NTuple{N,Any}...) where {N} = A
+tuplebroadcast_maxtuple(::TwoPlusTuple{Any}, ::TwoPlusTuple{Any}) =
+    throw(DimensionMismatch("tuples could not be broadcast to a common size"))
+@inline tuplebroadcast_maxtuple(A, Bs...) =
+    tuplebroadcast_maxtuple(A, tuplebroadcast_maxtuple(Bs...))
 tuplebroadcast_getargs(::Tuple{}, k) = ()
 @inline tuplebroadcast_getargs(As, k) =
     (_broadcast_getindex(first(As), k), tuplebroadcast_getargs(tail(As), k)...)

test/broadcast.jl

@@ -519,8 +519,16 @@ end
                   Nullable("hello"))
 end
 
-# Issue #21291
-let t = (0, 1, 2)
-    o = 1
-    @test @inferred(broadcast(+, t, o)) == (1, 2, 3)
+@testset "broadcast resulting in tuples" begin
+    # Issue #21291
+    let t = (0, 1, 2)
+        o = 1
+        @test @inferred(broadcast(+, t, o)) == (1, 2, 3)
+    end
+
+    # Issue #23647
+    @test (1, 2, 3) .+ (1,) == (1,) .+ (1, 2, 3) == (2, 3, 4)
+    @test (1,) .+ () == () .+ (1,) == () .+ () == ()
+    @test (1, 2) .+ (1, 2) == (2, 4)
+    @test_throws DimensionMismatch (1, 2) .+ (1, 2, 3)
 end