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