Revert "Fix miscellaneous type instabilities"

base/bool.jl

@@ -51,16 +51,18 @@ abs2(x::Bool) = x
 ^(x::Bool, y::Bool) = x | !y
 ^(x::Integer, y::Bool) = ifelse(y, x, one(x))
 
-function +{T<:AbstractFloat}(x::Bool, y::T)::promote_type(Bool,T)
-    return ifelse(x, one(y) + y, y)
+function +{T<:AbstractFloat}(x::Bool, y::T)
+    ifelse(x, one(promote_type(Bool,T)) + convert(promote_type(Bool,T),y),
+           convert(promote_type(Bool,T),y))
 end
 +(y::AbstractFloat, x::Bool) = x + y
 
-function *{T<:Number}(x::Bool, y::T)::promote_type(Bool,T)
-    return ifelse(x, y, copysign(zero(y), y))
+function *{T<:Number}(x::Bool, y::T)
+    ifelse(x, convert(promote_type(Bool,T),y),
+           ifelse(signbit(y), -zero(promote_type(Bool,T)), zero(promote_type(Bool,T))))
 end
-function *{T<:Unsigned}(x::Bool, y::T)::promote_type(Bool,T)
-    return ifelse(x, y, zero(y))
+function *{T<:Unsigned}(x::Bool, y::T)
+    ifelse(x, convert(promote_type(Bool,T),y), zero(promote_type(Bool,T)))
 end
 *(y::Number, x::Bool) = x * y
 

base/complex.jl

@@ -456,11 +456,11 @@ function log1p{T}(z::Complex{T})
     end
 end
 
-function ^{T<:AbstractFloat}(z::Complex{T}, p::Complex{T})::Complex{T}
-    if p == 2 #square
+function ^{T<:AbstractFloat}(z::Complex{T}, p::Complex{T})
+    if p==2 #square
         zr, zi = reim(z)
         x = (zr-zi)*(zr+zi)
-        y = 2*zr*zi
+        y = T(2*zr*zi)
         if isnan(x)
             if isinf(y)
                 x = copysign(zero(T),zr)

base/irrationals.jl

@@ -94,7 +94,6 @@ hash(x::Irrational, h::UInt) = 3*object_id(x) - h
 for op in Symbol[:+, :-, :*, :/, :^]
     @eval $op(x::Irrational, y::Irrational) = $op(Float64(x),Float64(y))
 end
-*(x::Bool, y::Irrational) = ifelse(x, Float64(y), 0.0)
 
 macro irrational(sym, val, def)
     esym = esc(sym)

base/rational.jl

@@ -355,8 +355,8 @@ function ^(x::Rational, n::Integer)
 end
 
 ^(x::Number, y::Rational) = x^(y.num/y.den)
-^{T<:AbstractFloat}(x::T, y::Rational) = x^(convert(T, y.num / y.den))
-^{T<:AbstractFloat}(x::Complex{T}, y::Rational) = x^(convert(T, y.num / y.den))
+^{T<:AbstractFloat}(x::T, y::Rational) = x^(convert(T,y.num)/y.den)
+^{T<:AbstractFloat}(x::Complex{T}, y::Rational) = x^(convert(T,y.num)/y.den)
 
 ^{T<:Rational}(z::Complex{T}, n::Bool) = n ? z : one(z) # to resolve ambiguity
 function ^{T<:Rational}(z::Complex{T}, n::Integer)

base/strings/io.jl

@@ -9,7 +9,6 @@ function print(io::IO, x)
     finally
         unlock(io)
     end
-    return nothing
 end
 
 function print(io::IO, xs...)
@@ -21,7 +20,6 @@ function print(io::IO, xs...)
     finally
         unlock(io)
     end
-    return nothing
 end
 
 println(io::IO, xs...) = print(io, xs..., '\n')

test/numbers.jl

@@ -2790,7 +2790,7 @@ let types = (Base.BitInteger_types..., BigInt, Bool,
              Complex{Int}, Complex{UInt}, Complex32, Complex64, Complex128)
     for S in types
         for op in (+, -)
-            if S === Float16
+            if S === Float16 # type instability here?
                 # broken, fixme then remove this branch
                 @test_throws ErrorException @inferred(Base.promote_op(op, S))
                 T = Base.promote_op(op, S)
@@ -2810,10 +2810,27 @@ let types = (Base.BitInteger_types..., BigInt, Bool,
                 # broken, fixme then remove this branch
                 @test_throws ErrorException @inferred(Base.promote_op(op, R, S))
                 T = Base.promote_op(op, R, S)
+                if ((R === Bool || S === Bool) && op in (+, *)) ||
+                       ((S in (Rational{Int}, Complex{Float16})) && op === ^) ||
+                       (R === Complex{Float16} && op === ^)
+                    @test_throws ErrorException @inferred(op(one(R), one(S)))
+                    t = op(one(R), one(S))
+                else
+                    t = @inferred op(one(R), one(S))
+                end
+            elseif (R === Complex{Float16} || S === Complex{Float16}) &&
+                    ((R === Bool && op in (+, *, /, ^)) ||
+                    (S === Bool && op in (+, *)) ||
+                    (S in (R, Rational{Int}) && op === ^))
+                # broken, fixme then remove this branch too
+                @test_throws ErrorException @inferred(Base.promote_op(op, R, S))
+                T = Base.promote_op(op, R, S)
+                @test_throws ErrorException @inferred(op(one(R), one(S)))
+                t = op(one(R), one(S))
             else
                 T = @inferred Base.promote_op(op, R, S)
+                t = @inferred op(one(R), one(S))
             end
-            t = @inferred op(one(R), one(S))
             @test T === typeof(t)
         end
     end