Review fixes

base/broadcast.jl

@@ -137,7 +137,7 @@ BroadcastStyle(a::AbstractArrayStyle, ::Style{Tuple})    = a
 BroadcastStyle(::A, ::A) where A<:ArrayStyle             = A()
 BroadcastStyle(::ArrayStyle, ::ArrayStyle)               = Unknown()
 BroadcastStyle(::A, ::A) where A<:AbstractArrayStyle     = A()
-@pure function BroadcastStyle(a::A, b::B) where {A<:AbstractArrayStyle{M},B<:AbstractArrayStyle{N}} where {M,N}
+Base.@pure function BroadcastStyle(a::A, b::B) where {A<:AbstractArrayStyle{M},B<:AbstractArrayStyle{N}} where {M,N}
     if Base.typename(A) === Base.typename(B)
         return A(Val(max(M, N)))
     end
@@ -695,23 +695,22 @@ function promote_typejoin_union(::Type{T}) where T
     if T === Union{}
         return Union{}
     elseif T isa Union
-        promote_typejoin(promote_typejoin_union(T.a), promote_typejoin_union(T.b))
+        return promote_typejoin(promote_typejoin_union(T.a), promote_typejoin_union(T.b))
     elseif T <: Tuple
-        typejoin_union_tuple(T)
+        return typejoin_union_tuple(T)
     else
-        T
+        return T
     end
 end
 
 @pure function typejoin_union_tuple(::Type{T}) where {T}
-    p = T.parameters
+    p = (Core.Compiler.unwrap_unionall(T)::DataType).parameters
     lr = length(p)::Int
     if lr == 0
         return Tuple{}
     end
-    lf, fixed = Core.Compiler.full_va_len(p)
-    c = Vector{Any}(undef, lf)
-    for i = 1:lf
+    c = Vector{Any}(undef, lr)
+    for i = 1:lr
         pi = p[i]
         U = Core.Compiler.unwrapva(pi)
         if U === Union{}
@@ -721,7 +720,12 @@ end
         else
             ci = U
         end
-        c[i] = i == lf && Core.Compiler.isvarargtype(pi) ? Vararg{ci} : ci
+        if i == lr && Core.Compiler.isvarargtype(pi)
+            N = (Core.Compiler.unwrap_unionall(pi)::DataType).parameters[2]
+            c[i] = Vararg{ci, N}
+        else
+            c[i] = ci
+        end
     end
     return Tuple{c...}
 end
@@ -913,13 +917,9 @@ const NonleafHandlingStyles = Union{DefaultArrayStyle,ArrayConflict}
     dest = similar(bc′, typeof(val))
     @inbounds dest[I] = val
     # Now handle the remaining values
-    if dest isa AbstractArray
-        # Give inference a helping hand on the element type and dimensionality
-        # (work-around for #28382)
-        return copyto_nonleaf!(dest, bc′, iter, state, 1)::AbstractArray{<:ElType, ndims(dest)}
-    else
-        return copyto_nonleaf!(dest, bc′, iter, state, 1)
-    end
+    # The typeassert gives inference a helping hand on the element type and dimensionality
+    # (work-around for #28382)
+    return copyto_nonleaf!(dest, bc′, iter, state, 1)::(dest isa AbstractArray ? AbstractArray{<:ElType, ndims(dest)} : Any)
 end
 
 ## general `copyto!` methods