Fix promote_op() and some corner-case operators on Number

Use common promote_op() based on one() for all Number types:
this fixes promote_op(+, ::Bool), which returned Int, and
promote_op(==, ::Complex, ::Complex), which returned Complex{Bool}.
Also fix a few corner cases which did not work or were type-instable.
Add systematic tests to catch this kind of bug.

Author: nalimilan

base/bool.jl

@@ -72,7 +72,3 @@ fld(x::Bool, y::Bool) = div(x,y)
 cld(x::Bool, y::Bool) = div(x,y)
 rem(x::Bool, y::Bool) = y ? false : throw(DivideError())
 mod(x::Bool, y::Bool) = rem(x,y)
-
-promote_op(op, ::Type{Bool}, ::Type{Bool}) = typeof(op(true, true))
-promote_op(::typeof(^), ::Type{Bool}, ::Type{Bool}) = Bool
-promote_op{T<:Integer}(::typeof(^), ::Type{Bool}, ::Type{T}) = Bool

base/complex.jl

@@ -26,17 +26,6 @@ promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{S}) =
 promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{Complex{S}}) =
     Complex{promote_type(T,S)}
 
-promote_op{T<:Real,S<:Real}(op, ::Type{Complex{T}}, ::Type{Complex{S}}) =
-    Complex{promote_op(op,T,S)}
-promote_op{T<:Real,S<:Real}(op, ::Type{Complex{T}}, ::Type{S}) =
-    Complex{promote_op(op,T,S)}
-promote_op{T<:Real,S<:Real}(op, ::Type{T}, ::Type{Complex{S}}) =
-    Complex{promote_op(op,T,S)}
-promote_op{T<:Integer,S<:Integer}(::typeof(^), ::Type{T}, ::Type{Complex{S}}) =
-    Complex{Float64}
-promote_op{T<:Integer,S<:Integer}(::typeof(.^), ::Type{T}, ::Type{Complex{S}}) =
-    Complex{Float64}
-
 widen{T}(::Type{Complex{T}}) = Complex{widen(T)}
 
 real(z::Complex) = z.re
@@ -461,7 +450,7 @@ function ^{T<:AbstractFloat}(z::Complex{T}, p::Complex{T})
     if p==2 #square
         zr, zi = reim(z)
         x = (zr-zi)*(zr+zi)
-        y = 2zr*zi
+        y = T(2)*zr*zi
         if isnan(x)
             if isinf(y)
                 x = copysign(zero(T),zr)

base/gmp.jl

@@ -424,6 +424,7 @@ end
 ^(x::BigInt , y::Bool   ) = y ? x : one(x)
 ^(x::BigInt , y::Integer) = bigint_pow(x, y)
 ^(x::Integer, y::BigInt ) = bigint_pow(BigInt(x), y)
+^(x::Bool   , y::BigInt ) = Base.power_by_squaring(x, y)
 
 function powermod(x::BigInt, p::BigInt, m::BigInt)
     r = BigInt()

base/int.jl

@@ -305,8 +305,6 @@ 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
 
-promote_op{R<:Integer,S<:Integer}(op, ::Type{R}, ::Type{S}) = typeof(op(one(R), one(S)))
-
 ## traits ##
 
 typemin(::Type{Int8  }) = Int8(-128)

base/intfuncs.jl

@@ -186,7 +186,7 @@ ndigits0z(x::Integer) = ndigits0z(unsigned(abs(x)))
 
 const ndigits_max_mul = Core.sizeof(Int) == 4 ? 69000000 : 290000000000000000
 
-function ndigits0znb(n::Int, b::Int)
+function ndigits0znb(n::Integer, b::Integer)
     d = 0
     while n != 0
         n = cld(n,b)
@@ -198,7 +198,7 @@ end
 function ndigits0z(n::Unsigned, b::Int)
     d = 0
     if b < 0
-        d = ndigits0znb(signed(n), b)
+        d = ndigits0znb(n, b)
     else
         b == 2  && return (sizeof(n)<<3-leading_zeros(n))
         b == 8  && return div((sizeof(n)<<3)-leading_zeros(n)+2,3)

base/irrationals.jl

@@ -10,6 +10,9 @@ 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<:Number}(op::Any, ::Type{S}, ::Type{T}) = promote_op(op, Int, T)
+promote_op{S<:Irrational,T<:Number}(op::Any, ::Type{T}, ::Type{S}) = promote_op(op, Int, T)
+
 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,4 +63,21 @@ 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
+end
+function promote_op{S<:Number,T<:Number}(op::Any, ::Type{S}, ::Type{T})
+    R = typeof(op(one(S), one(T)))
+    # 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
+end
+
 factorial(x::Number) = gamma(x + 1) # fallback for x not Integer

test/arrayops.jl

@@ -1404,7 +1404,7 @@ b = rand(6,7)
 # return type declarations (promote_op)
 module RetTypeDecl
     using Base.Test
-    import Base: +, *, .*, zero
+    import Base: +, *, .*, zero, one
 
     immutable MeterUnits{T,P} <: Number
         val::T
@@ -1419,10 +1419,9 @@ module RetTypeDecl
     (*){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))
-
-    Base.promote_op{R,S}(::typeof(+), ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),1}
-    Base.promote_op{R,S}(::typeof(*), ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),2}
-    Base.promote_op{R,S}(::typeof(.*), ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),2}
+    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))
 
     @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{Function, Array{Float64, 3}, Array{Int, 1}})
+rt = Base.return_types(broadcast, Tuple{typeof(+), Array{Float64, 3}, Array{Int, 1}})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
-rt = Base.return_types(broadcast!, Tuple{Function, Array{Float64, 3}, Array{Float64, 3}, Array{Int, 1}})
+rt = Base.return_types(broadcast!, Tuple{typeof(+), Array{Float64, 3}, Array{Float64, 3}, Array{Int, 1}})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
 
 # f.(args...) syntax (#15032)
@@ -196,3 +196,8 @@ end
 let a = broadcast(Float32, [3, 4, 5])
     @test eltype(a) == Float32
 end
+
+# PR 16988
+@test Base.promote_op(+, Bool) === Int
+@test isa(broadcast(+, true), Array{Int,0})
+@test Base.promote_op(Float64, Bool) === Float64

test/linalg/dense.jl

@@ -361,6 +361,9 @@ let
     @test S*T == [z z; 0 0]
 end
 
+# similar issue for Array{Real}
+@test Real[1 2] * Real[1.5; 2.0] == [5.5]
+
 # Matrix exponential
 for elty in (Float32, Float64, Complex64, Complex128)
     A1  = convert(Matrix{elty}, [4 2 0; 1 4 1; 1 1 4])

test/numbers.jl

@@ -2742,3 +2742,56 @@ testmi(typemin(Int)+1:typemin(Int)+1000, -100:100)
 @test_throws ArgumentError Base.multiplicativeinverse(0)
 testmi(map(UInt32, 0:1000), map(UInt32, 1:100))
 testmi(typemax(UInt32)-UInt32(1000):typemax(UInt32), map(UInt32, 1:100))
+
+# PR #16995
+let types = (Base.BitInteger_types..., BigInt, Bool,
+             Rational{Int}, Rational{BigInt},
+             Float16, Float32, Float64, BigFloat,
+             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))
+        end
+    end
+
+    @test Base.promote_op(!, Bool) === Bool
+    @inferred Base.promote_op(!, 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))
+        end
+    end
+end
+
+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))
+        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)
+    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))
+        end
+    end
+end