Rollback non-bugfix parts

Author: tkf

base/bool.jl

@@ -3,8 +3,6 @@
 # promote Bool to any other numeric type
 promote_rule(::Type{Bool}, ::Type{T}) where {T<:Number} = T
 
-convert(::Type{Bool}, x::Bool) = x   # prevent invalidation
-
 typemin(::Type{Bool}) = false
 typemax(::Type{Bool}) = true
 

base/char.jl

@@ -49,7 +49,6 @@ Char
 (::Type{AbstractChar})(x::Number) = Char(x)
 (::Type{T})(x::AbstractChar) where {T<:Union{Number,AbstractChar}} = T(codepoint(x))
 (::Type{T})(x::T) where {T<:AbstractChar} = x
-AbstractChar(x::AbstractChar) = x
 
 """
     ncodeunits(c::Char) -> Int
@@ -180,7 +179,6 @@ convert(::Type{AbstractChar}, x::Number) = Char(x) # default to Char
 convert(::Type{T}, x::Number) where {T<:AbstractChar} = T(x)
 convert(::Type{T}, x::AbstractChar) where {T<:Number} = T(x)
 convert(::Type{T}, c::AbstractChar) where {T<:AbstractChar} = T(c)
-convert(::Type{AbstractChar}, c::AbstractChar) = c
 convert(::Type{T}, c::T) where {T<:AbstractChar} = c
 
 rem(x::AbstractChar, ::Type{T}) where {T<:Number} = rem(codepoint(x), T)

base/essentials.jl

@@ -166,16 +166,13 @@ true
 """
 function convert end
 
-convert(::Type{Union{}}, x::Union{}) = throw(MethodError(convert, (Union{}, x)))
 convert(::Type{Union{}}, x) = throw(MethodError(convert, (Union{}, x)))
 convert(::Type{Any}, x) = x
 convert(::Type{T}, x::T) where {T} = x
 convert(::Type{Type}, x::Type) = x # the ssair optimizer is strongly dependent on this method existing to avoid over-specialization
                                    # in the absence of inlining-enabled
                                    # (due to fields typed as `Type`, which is generally a bad idea)
 
-Union{}(x::Union{}) = throw(MethodError(convert, (Union{}, x)))
-
 """
     @eval [mod,] ex
 
@@ -450,9 +447,6 @@ Stacktrace:
 ```
 """
 sizeof(x) = Core.sizeof(x)
-# The next two methods prevent invalidation
-sizeof(::Type{Union{}}) = Core.sizeof(Union{})
-sizeof(::Type{T}) where T = Core.sizeof(T)
 
 # simple Array{Any} operations needed for bootstrap
 @eval setindex!(A::Array{Any}, @nospecialize(x), i::Int) = arrayset($(Expr(:boundscheck)), A, x, i)

base/number.jl

@@ -2,10 +2,6 @@
 
 ## generic operations on numbers ##
 
-# prevent invalidation
-Union{}(x::Number)                  = throw(MethodError(convert, (Union{}, x)))
-convert(::Type{Union{}}, x::Number) = throw(MethodError(convert, (Union{}, x)))
-
 # Numbers are convertible
 convert(::Type{T}, x::T)      where {T<:Number} = x
 convert(::Type{T}, x::Number) where {T<:Number} = T(x)
@@ -244,9 +240,6 @@ julia> zero(rand(2,2))
 """
 zero(x::Number) = oftype(x,0)
 zero(::Type{T}) where {T<:Number} = convert(T,0)
-# prevent invalidation
-zero(x::Union{})      = throw(MethodError(zero, (x,)))
-zero(::Type{Union{}}) = throw(MethodError(zero, (Union{},)))
 
 """
     one(x)
@@ -282,9 +275,6 @@ julia> import Dates; one(Dates.Day(1))
 """
 one(::Type{T}) where {T<:Number} = convert(T,1)
 one(x::T) where {T<:Number} = one(T)
-# prevent invalidation
-one(x::Union{})      = throw(MethodError(one, (x,)))
-one(::Type{Union{}}) = throw(MethodError(one, (Union{},)))
 # note that convert(T, 1) should throw an error if T is dimensionful,
 # so this fallback definition should be okay.
 
@@ -308,9 +298,6 @@ julia> import Dates; oneunit(Dates.Day)
 """
 oneunit(x::T) where {T} = T(one(x))
 oneunit(::Type{T}) where {T} = T(one(T))
-# prevent invalidation
-oneunit(x::Union{})      = throw(MethodError(oneunit, (x,)))
-oneunit(::Type{Union{}}) = throw(MethodError(oneunit, (Union{},)))
 
 """
     big(T::Type)

base/reduce.jl

@@ -307,7 +307,7 @@ with reduction `op` over an empty array with element type of `T`.
 If not defined, this will throw an `ArgumentError`.
 """
 reduce_empty(op, ::Type{T}) where T = _empty_reduce_error()
-reduce_empty(::typeof(+), ::Type{Union{}}) = _empty_reduce_error()   # avoid invalidation
+reduce_empty(::typeof(+), ::Type{Union{}}) = _empty_reduce_error()
 reduce_empty(::typeof(+), ::Type{T}) where T = zero(T)
 reduce_empty(::typeof(+), ::Type{Bool}) = zero(Int)
 reduce_empty(::typeof(*), ::Type{Union{}}) = _empty_reduce_error()
@@ -325,10 +325,10 @@ reduce_empty(::typeof(mul_prod), ::Type{T}) where T = reduce_empty(*, T)
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallSigned}  = one(Int)
 reduce_empty(::typeof(mul_prod), ::Type{T}) where {T<:SmallUnsigned} = one(UInt)
 
-reduce_empty(op::BottomRF, ::Type{T}) where T = reduce_empty(op.rf, T)
-reduce_empty(op::MappingRF, ::Type{T}) where T = mapreduce_empty(op.f, op.rf, T)
-reduce_empty(op::FilteringRF, ::Type{T}) where T = reduce_empty(op.rf, T)
-reduce_empty(op::FlipArgs, ::Type{T}) where T = reduce_empty(op.f, T)
+reduce_empty(op::BottomRF, T) = reduce_empty(op.rf, T)
+reduce_empty(op::MappingRF, T) = mapreduce_empty(op.f, op.rf, T)
+reduce_empty(op::FilteringRF, T) = reduce_empty(op.rf, T)
+reduce_empty(op::FlipArgs, T) = reduce_empty(op.f, T)
 
 """
     Base.mapreduce_empty(f, op, T)
@@ -340,12 +340,12 @@ of `T`.
 If not defined, this will throw an `ArgumentError`.
 """
 mapreduce_empty(f, op, T) = _empty_reduce_error()
-mapreduce_empty(::typeof(identity), op, ::Type{T}) where T = reduce_empty(op, T)
-mapreduce_empty(::typeof(abs), op, ::Type{T}) where T      = abs(reduce_empty(op, T))
-mapreduce_empty(::typeof(abs2), op, ::Type{T}) where T     = abs2(reduce_empty(op, T))
+mapreduce_empty(::typeof(identity), op, T) = reduce_empty(op, T)
+mapreduce_empty(::typeof(abs), op, T)      = abs(reduce_empty(op, T))
+mapreduce_empty(::typeof(abs2), op, T)     = abs2(reduce_empty(op, T))
 
-mapreduce_empty(::typeof(abs),  ::typeof(max), ::Type{T}) where T = abs(zero(T))
-mapreduce_empty(::typeof(abs2), ::typeof(max), ::Type{T}) where T = abs2(zero(T))
+mapreduce_empty(f::typeof(abs),  ::typeof(max), T) = abs(zero(T))
+mapreduce_empty(f::typeof(abs2), ::typeof(max), T) = abs2(zero(T))
 
 # For backward compatibility:
 mapreduce_empty_iter(f, op, itr, ItrEltype) =