More promote_op fixes

Author: p-zubieta

base/float.jl

@@ -196,6 +196,12 @@ promote_rule(::Type{Float32}, ::Type{Float16}) = Float32
 promote_rule(::Type{Float64}, ::Type{Float16}) = Float64
 promote_rule(::Type{Float64}, ::Type{Float32}) = Float64
 
+promote_op{Op<:typeof(trunc),T<:Union{Float32,Float64}}(::Op, ::Type{Signed}, ::Type{T}) = Int
+promote_op{Op<:typeof(trunc),T<:Union{Float32,Float64}}(::Op, ::Type{Unsigned}, ::Type{T}) = UInt
+for f in (ceil, floor, round, trunc)
+    @eval promote_op{Op<:$(typeof(f)),T}(::Op, ::Type{T}, ::Any) = T
+end
+
 widen(::Type{Float16}) = Float32
 widen(::Type{Float32}) = Float64
 

base/irrationals.jl

@@ -10,10 +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}(::Any, ::Type{S}, ::Type{T}) = Float64
-promote_op{S<:Irrational,T<:Number}(::Any, ::Type{S}, ::Type{T}) = promote_type(S, T)
-promote_op{S<:Irrational,T<:Number}(::Any, ::Type{T}, ::Type{S}) = promote_type(T, S)
-
 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))

base/number.jl

@@ -63,21 +63,16 @@ zero{T<:Number}(::Type{T}) = convert(T,0)
 one(x::Number)  = oftype(x,1)
 one{T<:Number}(::Type{T}) = convert(T,1)
 
-promote_op{S<:Number,T}(op::Type{T}, ::Type{S}) = T # to fix ambiguities
-function promote_op{S<:Number}(op::Any, ::Type{S})
-    R = typeof(op(one(S)))
-    R <: S ? S : R # preserve the most general (abstract) type when possible
+promote_op{R,S<:Number}(::Type{R}, ::Type{S}) = (@_pure_meta; R) # to fix ambiguities
+function promote_op{T<:Number}(op, ::Type{T})
+    S = typeof(op(one(T)))
+    # preserve the most general (abstract) type when possible
+    return isleaftype(T) ? S : typejoin(S, T)
 end
-function promote_op{S<:Number,T<:Number}(op::Any, ::Type{S}, ::Type{T})
-    R = typeof(op(one(S), one(T)))
+function promote_op{R<:Number,S<:Number}(op, ::Type{R}, ::Type{S})
+    T = typeof(op(one(R), one(S)))
     # preserve the most general (abstract) type when possible
-    if T <: S && R <: S
-        return S
-    elseif S <: T && R <: T
-        return T
-    else
-        return R
-    end
+    return isleaftype(R) & isleaftype(S) ? T : typejoin(R, S, T)
 end
 
 factorial(x::Number) = gamma(x + 1) # fallback for x not Integer

base/operators.jl

@@ -43,6 +43,10 @@ end
 ==(T::TypeVar, S::Type) = false
 ==(T::Type, S::TypeVar) = false
 
+for op in (<, >, <=, >=, (==))
+    @eval promote_op{Op<:$(typeof(op))}(::Op, ::Any, ::Any) = ($(Expr(:meta, :pure)); Bool)
+end
+
 ## comparison fallbacks ##
 
 !=(x,y) = !(x==y)

base/parse.jl

@@ -194,3 +194,5 @@ function parse(str::AbstractString; raise::Bool=true)
     end
     return ex
 end
+
+promote_op{Op<:typeof(parse),T}(::Op, ::Type{T}, ::Any) = T

base/promotion.jl

@@ -222,9 +222,10 @@ minmax(x::Real, y::Real) = minmax(promote(x, y)...)
 # for the multiplication of two types,
 #   promote_op{R<:MyType,S<:MyType}(::typeof(*), ::Type{R}, ::Type{S}) = MyType{multype(R,S)}
 promote_op(::Any)    = (@_pure_meta; Bottom)
-promote_op(::Any, T) = (@_pure_meta; T)
+promote_op(::Any, ::Any) = (@_pure_meta; Any)
+promote_op(::Any, ::Any, ::Any) = (@_pure_meta; Any)
 promote_op{T}(::Type{T}, ::Any) = (@_pure_meta; T)
-promote_op{R,S}(::Any, ::Type{R}, ::Type{S}) = (@_pure_meta; promote_type(R, S))
+promote_op{Op<:typeof(convert),T}(::Op, ::Type{T}, ::Any) = (@_pure_meta, T)
 promote_op(op, T, S, U, V...) = (@_pure_meta; promote_op(op, T, promote_op(op, S, U, V...)))
 
 ## catch-alls to prevent infinite recursion when definitions are missing ##

test/arrayops.jl

@@ -1408,7 +1408,7 @@ b = rand(6,7)
 # return type declarations (promote_op)
 module RetTypeDecl
     using Base.Test
-    import Base: +, *, .*, zero, one
+    import Base: +, *, .*, convert
 
     immutable MeterUnits{T,P} <: Number
         val::T
@@ -1422,10 +1422,8 @@ module RetTypeDecl
     (*){T,pow}(x::Int, y::MeterUnits{T,pow}) = MeterUnits{typeof(x*one(T)),pow}(x*y.val)
     (*){T}(x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,2}(x.val*y.val)
     (.*){T}(x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,2}(x.val*y.val)
-    zero{T,pow}(x::MeterUnits{T,pow}) = MeterUnits{T,pow}(zero(T))
-    one{T,pow}(x::MeterUnits{T,pow}) = MeterUnits{T,pow}(one(T))
-    zero{T,pow}(x::Type{MeterUnits{T,pow}}) = MeterUnits{T,pow}(zero(T))
-    one{T,pow}(x::Type{MeterUnits{T,pow}}) = MeterUnits{T,pow}(one(T))
+    convert{T,pow}(::Type{MeterUnits{T,pow}}, y::Real) = MeterUnits{T,pow}(convert(T,y))
+    Base.promote_op{R,S}(::typeof(*), ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),2}
 
     @test @inferred(m+[m,m]) == [m+m,m+m]
     @test @inferred([m,m]+m) == [m+m,m+m]

test/broadcast.jl

@@ -165,9 +165,9 @@ m = [1:2;]'
 @test @inferred([0,1.2].+reshape([0,-2],1,1,2)) == reshape([0 -2; 1.2 -0.8],2,1,2)
 rt = Base.return_types(.+, Tuple{Array{Float64, 3}, Array{Int, 1}})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
-rt = Base.return_types(broadcast, Tuple{typeof(+), Array{Float64, 3}, Array{Int, 1}})
+rt = Base.return_types(broadcast, Tuple{Float64, Array{Int, 3}})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
-rt = Base.return_types(broadcast!, Tuple{typeof(+), Array{Float64, 3}, Array{Float64, 3}, Array{Int, 1}})
+rt = Base.return_types(broadcast!, Tuple{Function, Array{Float64, 3}, Array{Float64, 3}, Array{Int, 1}})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
 
 # f.(args...) syntax (#15032)

test/numbers.jl

@@ -2764,20 +2764,19 @@ let types = (Base.BitInteger_types..., BigInt, Bool,
              Complex{Int}, Complex{UInt}, Complex32, Complex64, Complex128)
     for S in types
         for op in (+, -)
-            @test Base.promote_op(op, S) === typeof(op(one(S)))
-            @inferred Base.promote_op(op, S)
-            @inferred op(one(S))
+            T = @inferred Base.promote_op(op, S)
+            t = @inferred op(one(S))
+            @test T === typeof(t)
         end
     end
 
-    @test Base.promote_op(!, Bool) === Bool
-    @inferred Base.promote_op(!, Bool)
+    @test @inferred(Base.promote_op(!, Bool)) === Bool
 
-    for S in types, T in types
-        for op in (+, -, *, /, ^, (==))
-            @test Base.promote_op(op, S, T) === typeof(op(one(S), one(T)))
-            @inferred Base.promote_op(op, S, T)
-            @inferred op(one(S), one(T))
+    for R in types, S in types
+        for op in (+, -, *, /, ^)
+            T = @inferred Base.promote_op(op, R, S)
+            t = @inferred op(one(R), one(S))
+            @test T === typeof(t)
         end
     end
 end
@@ -2786,26 +2785,24 @@ let types = (Base.BitInteger_types..., BigInt, Bool,
              Rational{Int}, Rational{BigInt},
              Float16, Float32, Float64, BigFloat)
     for S in types, T in types
-        for op in (<, >, <=, >=)
-            @test Base.promote_op(op, S, T) === typeof(op(one(S), one(T)))
-            @inferred Base.promote_op(op, S, T)
-            @inferred op(one(S), one(T))
+        for op in (<, >, <=, >=, (==))
+            @test @inferred(Base.promote_op(op, S, T)) === Bool
         end
     end
 end
 
 let types = (Base.BitInteger_types..., BigInt, Bool)
     for S in types
-        @test Base.promote_op(~, S) === typeof(~one(S))
-        @inferred Base.promote_op(~, S)
-        @inferred ~one(S)
+        T = @inferred Base.promote_op(~, S)
+        t = @inferred ~one(S)
+        @test T === typeof(t)
     end
 
     for S in types, T in types
         for op in (&, |, <<, >>, (>>>), %, ÷)
-            @test Base.promote_op(op, S, T) === typeof(op(one(S), one(T)))
-            @inferred Base.promote_op(op, S, T)
-            @inferred op(one(S), one(T))
+            T = @inferred Base.promote_op(op, S, T)
+            t = @inferred op(one(S), one(T))
+            @test T === typeof(t)
         end
     end
 end