Merge pull request #17929 from pabloferz/pz/promop

Improve promote_op

base/abstractarray.jl

@@ -1653,11 +1653,11 @@ end
 
 # These are needed because map(eltype, As) is not inferrable
 promote_eltype_op(::Any) = (@_pure_meta; Bottom)
-promote_eltype_op(op, A) = (@_pure_meta; _promote_op(op, eltype(A)))
-promote_eltype_op{T}(op, ::AbstractArray{T}) = (@_pure_meta; _promote_op(op, T))
-promote_eltype_op{T}(op, ::AbstractArray{T}, A) = (@_pure_meta; _promote_op(op, T, eltype(A)))
-promote_eltype_op{T}(op, A, ::AbstractArray{T}) = (@_pure_meta; _promote_op(op, eltype(A), T))
-promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::AbstractArray{S}) = (@_pure_meta; _promote_op(op, R, S))
+promote_eltype_op(op, A) = (@_pure_meta; promote_op(op, eltype(A)))
+promote_eltype_op{T}(op, ::AbstractArray{T}) = (@_pure_meta; promote_op(op, T))
+promote_eltype_op{T}(op, ::AbstractArray{T}, A) = (@_pure_meta; promote_op(op, T, eltype(A)))
+promote_eltype_op{T}(op, A, ::AbstractArray{T}) = (@_pure_meta; promote_op(op, eltype(A), T))
+promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::AbstractArray{S}) = (@_pure_meta; promote_op(op, R, S))
 promote_eltype_op(op, A, B, C, D...) = (@_pure_meta; promote_eltype_op(op, promote_eltype_op(op, A, B), C, D...))
 
 ## 1 argument

base/arraymath.jl

@@ -46,8 +46,8 @@ promote_array_type{S<:Integer}(::typeof(.\), ::Type{S}, ::Type{Bool}, T::Type) =
 promote_array_type{S<:Integer}(F, ::Type{S}, ::Type{Bool}, T::Type) = T
 
 for f in (:+, :-, :div, :mod, :&, :|, :$)
-    @eval ($f)(A::AbstractArray, B::AbstractArray) =
-        _elementwise($f, promote_op($f, eltype(A), eltype(B)), A, B)
+    @eval ($f){R,S}(A::AbstractArray{R}, B::AbstractArray{S}) =
+        _elementwise($f, promote_op($f, R, S), A, B)
 end
 function _elementwise(op, ::Type{Any}, A::AbstractArray, B::AbstractArray)
     promote_shape(A, B) # check size compatibility
@@ -63,21 +63,21 @@ end
 
 for f in (:.+, :.-, :.*, :./, :.\, :.^, :.÷, :.%, :.<<, :.>>, :div, :mod, :rem, :&, :|, :$)
     @eval begin
-        function ($f)(A::Number, B::AbstractArray)
-            P = promote_op($f, typeof(A), eltype(B))
-            T = promote_array_type($f, typeof(A), eltype(B), P)
-            T === Any && return [($f)(A, b) for b in B]
-            F = similar(B, T)
+        function ($f){T}(A::Number, B::AbstractArray{T})
+            R = promote_op($f, typeof(A), T)
+            S = promote_array_type($f, typeof(A), T, R)
+            S === Any && return [($f)(A, b) for b in B]
+            F = similar(B, S)
             for (iF, iB) in zip(eachindex(F), eachindex(B))
                 @inbounds F[iF] = ($f)(A, B[iB])
             end
             return F
         end
-        function ($f)(A::AbstractArray, B::Number)
-            P = promote_op($f, eltype(A), typeof(B))
-            T = promote_array_type($f, typeof(B), eltype(A), P)
-            T === Any && return [($f)(a, B) for a in A]
-            F = similar(A, T)
+        function ($f){T}(A::AbstractArray{T}, B::Number)
+            R = promote_op($f, T, typeof(B))
+            S = promote_array_type($f, typeof(B), T, R)
+            S === Any && return [($f)(a, B) for a in A]
+            F = similar(A, S)
             for (iF, iA) in zip(eachindex(F), eachindex(A))
                 @inbounds F[iF] = ($f)(A[iA], B)
             end

base/promotion.jl

@@ -220,34 +220,33 @@ minmax(x::Real, y::Real) = minmax(promote(x, y)...)
 # "Promotion" that takes a function into account. These are meant to be
 # used mainly by broadcast methods, so it is advised against overriding them
 if isdefined(Core, :Inference)
-    function _promote_op(op, T::Type)
+    function _promote_op(op, T::ANY)
         G = Tuple{Generator{Tuple{T},typeof(op)}}
-        R = Core.Inference.return_type(first, G)
-        return isleaftype(R) ? R : Any
+        return Core.Inference.return_type(first, G)
     end
-    function _promote_op(op, R::Type, S::Type)
+    function _promote_op(op, R::ANY, S::ANY)
         F = typeof(a -> op(a...))
         G = Tuple{Generator{Zip2{Tuple{R},Tuple{S}},F}}
-        T = Core.Inference.return_type(first, G)
-        return isleaftype(T) ? T : Any
+        return Core.Inference.return_type(first, G)
     end
 else
-    _promote_op(::Any...) = (@_pure_meta; Any)
+    _promote_op(::ANY...) = (@_pure_meta; Any)
 end
 _default_type(T::Type) = (@_pure_meta; T)
 
 promote_op(::Any...) = (@_pure_meta; Any)
 promote_op(T::Type, ::Any) = (@_pure_meta; T)
 promote_op(T::Type, ::Type) = (@_pure_meta; T) # To handle ambiguities
 # Promotion that tries to preserve non-concrete types
-function promote_op(f, S::Type)
+function promote_op{S}(f, ::Type{S})
     T = _promote_op(f, _default_type(S))
-    return isleaftype(S) ? T : typejoin(S, T)
+    isleaftype(S) && return isleaftype(T) ? T : Any
+    return typejoin(S, T)
 end
-function promote_op(f, R::Type, S::Type)
+function promote_op{R,S}(f, ::Type{R}, ::Type{S})
     T = _promote_op(f, _default_type(R), _default_type(S))
-    isleaftype(R) && return isleaftype(S) ? T : typejoin(S, T)
-    return isleaftype(S) ? typejoin(R, T) : typejoin(R, S, T)
+    isleaftype(R) && isleaftype(S) && return isleaftype(T) ? T : Any
+    return typejoin(R, S, T)
 end
 
 ## catch-alls to prevent infinite recursion when definitions are missing ##