Make promote_op rely on Core.Inference.return_type

Author: p-zubieta

base/abstractarray.jl

@@ -1407,12 +1407,12 @@ end
 
 # These are needed because map(eltype, As) is not inferrable
 promote_eltype_op(::Any) = (@_pure_meta; Bottom)
-promote_eltype_op{T}(op, ::AbstractArray{T}) = (@_pure_meta; promote_op(op, T))
-promote_eltype_op{T}(op, ::T               ) = (@_pure_meta; promote_op(op, T))
-promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::AbstractArray{S}) = (@_pure_meta; promote_op(op, R, S))
-promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::S) = (@_pure_meta; promote_op(op, R, S))
-promote_eltype_op{R,S}(op, ::R, ::AbstractArray{S}) = (@_pure_meta; promote_op(op, R, S))
-promote_eltype_op(op, A, B, C, D...) = (@_pure_meta; promote_op(op, eltype(A), promote_eltype_op(op, B, C, D...)))
+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
 map!{F}(f::F, A::AbstractArray) = map!(f, A, A)

base/arraymath.jl

@@ -35,30 +35,26 @@ function !(A::AbstractArray{Bool})
 end
 
 ## Binary arithmetic operators ##
-@pure promote_array_type{S<:Number, A<:AbstractArray}(F, ::Type{S}, ::Type{A}) =
-    promote_array_type(F, S, eltype(A), promote_op(F, S, eltype(A)))
-@pure promote_array_type{S<:Number, A<:AbstractArray}(F, ::Type{A}, ::Type{S}) =
-    promote_array_type(F, S, eltype(A), promote_op(F, eltype(A), S))
 
-@pure promote_array_type{S, A, P}(F, ::Type{S}, ::Type{A}, ::Type{P}) = P
-@pure promote_array_type{S<:Real, A<:AbstractFloat, P}(F, ::Type{S}, ::Type{A}, ::Type{P}) = A
-@pure promote_array_type{S<:Integer, A<:Integer, P}(F::typeof(./), ::Type{S}, ::Type{A}, ::Type{P}) = P
-@pure promote_array_type{S<:Integer, A<:Integer, P}(F::typeof(.\), ::Type{S}, ::Type{A}, ::Type{P}) = P
-@pure promote_array_type{S<:Integer, A<:Integer, P}(F, ::Type{S}, ::Type{A}, ::Type{P}) = A
-@pure promote_array_type{S<:Integer, P}(F::typeof(./), ::Type{S}, ::Type{Bool}, ::Type{P}) = P
-@pure promote_array_type{S<:Integer, P}(F::typeof(.\), ::Type{S}, ::Type{Bool}, ::Type{P}) = P
-@pure promote_array_type{S<:Integer, P}(F, ::Type{S}, ::Type{Bool}, ::Type{P}) = P
+promote_array_type(F, ::Type, ::Type, T::Type) = T
+promote_array_type{S<:Real, A<:AbstractFloat}(F, ::Type{S}, ::Type{A}, ::Type) = A
+promote_array_type{S<:Integer, A<:Integer}(F, ::Type{S}, ::Type{A}, ::Type) = A
+promote_array_type{S<:Integer, A<:Integer}(::typeof(./), ::Type{S}, ::Type{A}, T::Type) = T
+promote_array_type{S<:Integer, A<:Integer}(::typeof(.\), ::Type{S}, ::Type{A}, T::Type) = T
+promote_array_type{S<:Integer}(::typeof(./), ::Type{S}, ::Type{Bool}, T::Type) = T
+promote_array_type{S<:Integer}(::typeof(.\), ::Type{S}, ::Type{Bool}, T::Type) = T
+promote_array_type{S<:Integer}(F, ::Type{S}, ::Type{Bool}, T::Type) = T
 
 for f in (:+, :-, :div, :mod, :&, :|, :$)
-    @eval ($f){S,T}(A::AbstractArray{S}, B::AbstractArray{T}) =
-        _elementwise($f, A, B, promote_eltype_op($f, A, B))
+    @eval ($f)(A::AbstractArray, B::AbstractArray) =
+        _elementwise($f, promote_op($f, eltype(A), eltype(B)), A, B)
 end
-function _elementwise{S,T}(op, A::AbstractArray{S}, B::AbstractArray{T}, ::Type{Any})
-    promote_shape(A,B) # check size compatibility
+function _elementwise(op, ::Type{Any}, A::AbstractArray, B::AbstractArray)
+    promote_shape(A, B) # check size compatibility
     return broadcast(op, A, B)
 end
-function _elementwise{S,T,R}(op, A::AbstractArray{S}, B::AbstractArray{T}, ::Type{R})
-    F = similar(A, R, promote_shape(A,B))
+function _elementwise(op, T::Type, A::AbstractArray, B::AbstractArray)
+    F = similar(A, T, promote_shape(A, B))
     for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
         @inbounds F[iF] = op(A[iA], B[iB])
     end
@@ -67,15 +63,21 @@ end
 
 for f in (:.+, :.-, :.*, :./, :.\, :.^, :.÷, :.%, :.<<, :.>>, :div, :mod, :rem, :&, :|, :$)
     @eval begin
-        function ($f){T}(A::Number, B::AbstractArray{T})
-            F = similar(B, promote_array_type($f,typeof(A),typeof(B)))
+        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)
             for (iF, iB) in zip(eachindex(F), eachindex(B))
                 @inbounds F[iF] = ($f)(A, B[iB])
             end
             return F
         end
-        function ($f){T}(A::AbstractArray{T}, B::Number)
-            F = similar(A, promote_array_type($f,typeof(A),typeof(B)))
+        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)
             for (iF, iA) in zip(eachindex(F), eachindex(A))
                 @inbounds F[iF] = ($f)(A[iA], B)
             end

base/bitarray.jl

@@ -1035,18 +1035,29 @@ for f in (:+, :-)
         return r
     end
 end
+
 for (f) in (:.+, :.-)
-    for (arg1, arg2, T, fargs) in ((:(B::BitArray), :(x::Bool)    , Int                                   , :(b, x)),
-                                   (:(B::BitArray), :(x::Number)  , :(promote_array_type($f, BitArray, typeof(x))), :(b, x)),
-                                   (:(x::Bool)    , :(B::BitArray), Int                                   , :(x, b)),
-                                   (:(x::Number)  , :(B::BitArray), :(promote_array_type($f, typeof(x), BitArray)), :(x, b)))
+    for (arg1, arg2, T, t) in ((:(B::BitArray), :(x::Bool)    , Int               , (:b, :x)),
+                               (:(B::BitArray), :(x::Number)  , :(Bool, typeof(x)), (:b, :x)),
+                               (:(x::Bool)    , :(B::BitArray), Int               , (:x, :b)),
+                               (:(x::Number)  , :(B::BitArray), :(typeof(x), Bool), (:x, :b)))
         @eval function ($f)($arg1, $arg2)
-            r = Array{$T}(size(B))
+            $(if T === Int
+                quote
+                    r = Array{Int}(size(B))
+                end
+            else
+                quote
+                    T = promote_op($f, $(T.args[1]), $(T.args[2]))
+                    T === Any && return [($f)($(t[1]), $(t[2])) for b in B]
+                    r = Array{T}(size(B))
+                end
+            end)
             bi = start(B)
             ri = 1
             while !done(B, bi)
                 b, bi = next(B, bi)
-                @inbounds r[ri] = ($f)($fargs...)
+                @inbounds r[ri] = ($f)($(t[1]), $(t[2]))
                 ri += 1
             end
             return r
@@ -1078,9 +1089,8 @@ function div(x::Bool, B::BitArray)
 end
 function div(x::Number, B::BitArray)
     all(B) || throw(DivideError())
-    pt = promote_array_type(div, typeof(x), BitArray)
     y = div(x, true)
-    reshape(pt[ y for i = 1:length(B) ], size(B))
+    return fill(y, size(B))
 end
 
 function mod(A::BitArray, B::BitArray)
@@ -1099,15 +1109,16 @@ function mod(x::Bool, B::BitArray)
 end
 function mod(x::Number, B::BitArray)
     all(B) || throw(DivideError())
-    pt = promote_array_type(mod, typeof(x), BitArray)
     y = mod(x, true)
-    reshape(pt[ y for i = 1:length(B) ], size(B))
+    return fill(y, size(B))
 end
 
 for f in (:div, :mod)
     @eval begin
         function ($f)(B::BitArray, x::Number)
-            F = Array{promote_array_type($f, BitArray, typeof(x))}(size(B))
+            T = promote_op($f, Bool, typeof(x))
+            T === Any && return [($f)(b, x) for b in B]
+            F = Array{T}(size(B))
             for i = 1:length(F)
                 F[i] = ($f)(B[i], x)
             end

base/broadcast.jl

@@ -3,7 +3,7 @@
 module Broadcast
 
 using Base.Cartesian
-using Base: promote_op, promote_eltype, promote_eltype_op, @get!, _msk_end, unsafe_bitgetindex, linearindices, tail, OneTo, to_shape
+using Base: promote_eltype_op, @get!, _msk_end, unsafe_bitgetindex, linearindices, tail, OneTo, to_shape
 import Base: .+, .-, .*, ./, .\, .//, .==, .<, .!=, .<=, .÷, .%, .<<, .>>, .^
 export broadcast, broadcast!, bitbroadcast, dotview
 export broadcast_getindex, broadcast_setindex!
@@ -299,7 +299,7 @@ end
 ## elementwise operators ##
 
 for op in (:÷, :%, :<<, :>>, :-, :/, :\, ://, :^)
-    @eval $(Symbol(:., op))(A::AbstractArray, B::AbstractArray) = broadcast($(op), A, B)
+    @eval $(Symbol(:., op))(A::AbstractArray, B::AbstractArray) = broadcast($op, A, B)
 end
 .+(As::AbstractArray...) = broadcast(+, As...)
 .*(As::AbstractArray...) = broadcast(*, As...)

base/char.jl

@@ -40,10 +40,6 @@ hash(x::Char, h::UInt) = hash_uint64(((UInt64(x)+hashchar_seed)<<32) $ UInt64(h)
 +(x::Char, y::Integer) = Char(Int32(x) + Int32(y))
 +(x::Integer, y::Char) = y + x
 
-Base.promote_op{I<:Integer}(::typeof(-), ::Type{Char}, ::Type{I}) = Char
-Base.promote_op{I<:Integer}(::typeof(+), ::Type{Char}, ::Type{I}) = Char
-Base.promote_op{I<:Integer}(::typeof(+), ::Type{I}, ::Type{Char}) = Char
-
 bswap(x::Char) = Char(bswap(UInt32(x)))
 
 print(io::IO, c::Char) = (write(io, c); nothing)

base/complex.jl

@@ -804,7 +804,8 @@ big{T<:AbstractFloat,N}(A::AbstractArray{Complex{T},N}) = convert(AbstractArray{
 
 ## promotion to complex ##
 
-promote_array_type{S<:Union{Complex, Real}, AT<:AbstractFloat, P}(F, ::Type{S}, ::Type{Complex{AT}}, ::Type{P}) = Complex{AT}
+_default_type(T::Type{Complex}) = Complex{Int}
+promote_array_type{S<:Union{Complex, Real}, T<:AbstractFloat}(F, ::Type{S}, ::Type{Complex{T}}, ::Type) = Complex{T}
 
 function complex{S<:Real,T<:Real}(A::AbstractArray{S}, B::AbstractArray{T})
     if size(A) != size(B); throw(DimensionMismatch()); end

base/dates/arithmetic.jl

@@ -94,21 +94,3 @@ end
 # AbstractArray{TimeType}, AbstractArray{TimeType}
 (-){T<:TimeType}(x::OrdinalRange{T}, y::OrdinalRange{T}) = collect(x) - collect(y)
 (-){T<:TimeType}(x::Range{T}, y::Range{T}) = collect(x) - collect(y)
-
-# promotion rules
-
-for op in (:+, :-, :.+, :.-)
-    @eval begin
-        Base.promote_op{P<:Period}(::typeof($op), ::Type{P}, ::Type{P}) = P
-        Base.promote_op{P1<:Period,P2<:Period}(::typeof($op), ::Type{P1}, ::Type{P2}) = CompoundPeriod
-        Base.promote_op{D<:Date}(::typeof($op), ::Type{D}, ::Type{D}) = Day
-        Base.promote_op{D<:DateTime}(::typeof($op), ::Type{D}, ::Type{D}) = Millisecond
-    end
-end
-
-for op in (:/, :%, :div, :mod, :./, :.%)
-    @eval begin
-        Base.promote_op{P<:Period}(::typeof($op), ::Type{P}, ::Type{P}) = typeof($op(1,1))
-        Base.promote_op{P<:Period,R<:Real}(::typeof($op), ::Type{P}, ::Type{R}) = P
-    end
-end

base/float.jl

@@ -230,6 +230,8 @@ promote_rule(::Type{Float64}, ::Type{Float32}) = Float64
 widen(::Type{Float16}) = Float32
 widen(::Type{Float32}) = Float64
 
+_default_type(T::Union{Type{Real},Type{AbstractFloat}}) = Float64
+
 ## floating point arithmetic ##
 -(x::Float32) = box(Float32,neg_float(unbox(Float32,x)))
 -(x::Float64) = box(Float64,neg_float(unbox(Float64,x)))

base/int.jl

@@ -305,6 +305,9 @@ promote_rule{T<:BitSigned64}(::Type{UInt64}, ::Type{T}) = UInt64
 promote_rule{T<:Union{UInt32, UInt64}}(::Type{T}, ::Type{Int128}) = Int128
 promote_rule{T<:BitSigned}(::Type{UInt128}, ::Type{T}) = UInt128
 
+_default_type(T::Type{Unsigned}) = UInt
+_default_type(T::Union{Type{Integer},Type{Signed}}) = Int
+
 ## traits ##
 
 typemin(::Type{Int8  }) = Int8(-128)

base/irrationals.jl

@@ -10,13 +10,6 @@ promote_rule{s}(::Type{Irrational{s}}, ::Type{Float32}) = Float32
 promote_rule{s,t}(::Type{Irrational{s}}, ::Type{Irrational{t}}) = Float64
 promote_rule{s,T<:Number}(::Type{Irrational{s}}, ::Type{T}) = promote_type(Float64,T)
 
-promote_op{S<:Irrational,T<:Irrational}(op::Any, ::Type{S}, ::Type{T}) =
-    promote_op(op, Float64, Float64)
-promote_op{S<:Irrational,T<:Number}(op::Any, ::Type{S}, ::Type{T}) =
-    promote_op(op, Float64, T)
-promote_op{S<:Irrational,T<:Number}(op::Any, ::Type{T}, ::Type{S}) =
-    promote_op(op, T, Float64)
-
 convert(::Type{AbstractFloat}, x::Irrational) = Float64(x)
 convert(::Type{Float16}, x::Irrational) = Float16(Float32(x))
 convert{T<:Real}(::Type{Complex{T}}, x::Irrational) = convert(Complex{T}, convert(T,x))