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.

This breaks *(::Matrix{Complex}, ::Matrix{Complex}) when it contains
non-integer values, since one(Complex) === Complex(1).

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

@@ -429,6 +429,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/promotion.jl

@@ -227,6 +227,10 @@ 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, T, S, U, V...) = (@_pure_meta; promote_op(op, T, promote_op(op, S, U, V...)))
 
+promote_op{S<:Number,T}(op::Type{T}, ::Type{S}) = T # to fix ambiguities
+promote_op{S<:Number}(op, ::Type{S}) = typeof(op(one(S)))
+promote_op{R<:Number,S<:Number}(op, ::Type{R}, ::Type{S}) = typeof(op(one(R), one(S)))
+
 ## catch-alls to prevent infinite recursion when definitions are missing ##
 
 no_op_err(name, T) = error(name," not defined for ",T)

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: +, *, .*, one
 
     immutable MeterUnits{T,P} <: Number
         val::T
@@ -1418,11 +1418,11 @@ 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::Type{MeterUnits{T,pow}}) = MeterUnits{T,pow}(one(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}
+#    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}
 
     @test @inferred(m+[m,m]) == [m+m,m+m]
     @test @inferred([m,m]+m) == [m+m,m+m]

test/broadcast.jl

@@ -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

@@ -353,8 +353,8 @@ end
 # issue #4796
 let
     dim=2
-    S=zeros(Complex,dim,dim)
-    T=zeros(Complex,dim,dim)
+    S=zeros(Complex128,dim,dim)
+    T=zeros(Complex128,dim,dim)
     T[:] = 1
     z = 2.5 + 1.5im
     S[1] = z

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},
+             Real, Float16, Float32, Float64, BigFloat,
+             Complex, 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