fewer convert methods for Missing and Nothing (#31602)

And use `typesubtract` instead of subtyping
to improve usability by handling undef sparams.

Co-Authored-By: Jameson Nash <[email protected]>

Author: vtjnash

base/essentials.jl

@@ -163,6 +163,7 @@ true
 """
 function convert end
 
+convert(::Type{Union{}}, x) = throw(MethodError(convert, (Union{}, x)))
 convert(::Type{Any}, @nospecialize(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

base/missing.jl

@@ -19,35 +19,35 @@ showerror(io::IO, ex::MissingException) =
     print(io, "MissingException: ", ex.msg)
 
 nonmissingtype(::Type{T}) where {T} = Core.Compiler.typesubtract(T, Missing)
+function nonmissingtype_checked(T::Type)
+    R = nonmissingtype(T)
+    R >: T && error("could not compute non-missing type")
+    return R
+end
 
-for U in (:Nothing, :Missing)
-    @eval begin
-        promote_rule(::Type{$U}, ::Type{T}) where {T} = Union{T, $U}
-        promote_rule(::Type{Union{S,$U}}, ::Type{Any}) where {S} = Any
-        promote_rule(::Type{Union{S,$U}}, ::Type{T}) where {T,S} = Union{promote_type(T, S), $U}
-        promote_rule(::Type{Any}, ::Type{$U}) = Any
-        promote_rule(::Type{$U}, ::Type{Any}) = Any
-        # This definition is never actually used, but disambiguates the above definitions
-        promote_rule(::Type{$U}, ::Type{$U}) = $U
-    end
+promote_rule(T::Type{Missing}, S::Type) = Union{S, Missing}
+promote_rule(T::Type{Union{Nothing, Missing}}, S::Type) = Union{S, Nothing, Missing}
+function promote_rule(T::Type{>:Union{Nothing, Missing}}, S::Type)
+    R = nonnothingtype(T)
+    R >: T && return Any
+    T = R
+    R = nonmissingtype(T)
+    R >: T && return Any
+    T = R
+    R = promote_type(T, S)
+    return Union{R, Nothing, Missing}
 end
-promote_rule(::Type{Union{Nothing, Missing}}, ::Type{Any}) = Any
-promote_rule(::Type{Union{Nothing, Missing}}, ::Type{T}) where {T} =
-    Union{Nothing, Missing, T}
-promote_rule(::Type{Union{Nothing, Missing, S}}, ::Type{Any}) where {S} = Any
-promote_rule(::Type{Union{Nothing, Missing, S}}, ::Type{T}) where {T,S} =
-    Union{Nothing, Missing, promote_type(T, S)}
-
-convert(::Type{Union{T, Missing}}, x::Union{T, Missing}) where {T} = x
-convert(::Type{Union{T, Missing}}, x) where {T} = convert(T, x)
-# To fix ambiguities
-convert(::Type{Missing}, ::Missing) = missing
-convert(::Type{Union{Nothing, Missing}}, x::Union{Nothing, Missing}) = x
-convert(::Type{Union{Nothing, Missing, T}}, x::Union{Nothing, Missing, T}) where {T} = x
-convert(::Type{Union{Nothing, Missing}}, x) =
-    throw(MethodError(convert, (Union{Nothing, Missing}, x)))
-# To print more appropriate message than "T not defined"
-convert(::Type{Missing}, x) = throw(MethodError(convert, (Missing, x)))
+function promote_rule(T::Type{>:Missing}, S::Type)
+    R = nonmissingtype(T)
+    R >: T && return Any
+    T = R
+    R = promote_type(T, S)
+    return Union{R, Missing}
+end
+
+convert(T::Type{>:Union{Missing, Nothing}}, x) = convert(nonmissingtype_checked(nonnothingtype_checked(T)), x)
+convert(T::Type{>:Missing}, x) = convert(nonmissingtype_checked(T), x)
+
 
 # Comparison operators
 ==(::Missing, ::Missing) = missing
@@ -108,10 +108,10 @@ round(::Missing, ::RoundingMode=RoundNearest; sigdigits::Integer=0, digits::Inte
 round(::Type{>:Missing}, ::Missing, ::RoundingMode=RoundNearest) = missing
 round(::Type{T}, ::Missing, ::RoundingMode=RoundNearest) where {T} =
     throw(MissingException("cannot convert a missing value to type $T: use Union{$T, Missing} instead"))
-round(::Type{T}, x::Any, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype(T), x, r)
+round(::Type{T}, x::Any, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype_checked(T), x, r)
 # to fix ambiguities
-round(::Type{T}, x::Rational, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype(T), x, r)
-round(::Type{T}, x::Rational{Bool}, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype(T), x, r)
+round(::Type{T}, x::Rational, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype_checked(T), x, r)
+round(::Type{T}, x::Rational{Bool}, r::RoundingMode=RoundNearest) where {T>:Missing} = round(nonmissingtype_checked(T), x, r)
 
 # Handle ceil, floor, and trunc separately as they have no RoundingMode argument
 for f in (:(ceil), :(floor), :(trunc))
@@ -120,9 +120,9 @@ for f in (:(ceil), :(floor), :(trunc))
         ($f)(::Type{>:Missing}, ::Missing) = missing
         ($f)(::Type{T}, ::Missing) where {T} =
             throw(MissingException("cannot convert a missing value to type $T: use Union{$T, Missing} instead"))
-        ($f)(::Type{T}, x::Any) where {T>:Missing} = $f(nonmissingtype(T), x)
+        ($f)(::Type{T}, x::Any) where {T>:Missing} = $f(nonmissingtype_checked(T), x)
         # to fix ambiguities
-        ($f)(::Type{T}, x::Rational) where {T>:Missing} = $f(nonmissingtype(T), x)
+        ($f)(::Type{T}, x::Rational) where {T>:Missing} = $f(nonmissingtype_checked(T), x)
     end
 end
 

base/promotion.jl

@@ -231,10 +231,6 @@ it for new types as appropriate.
 function promote_rule end
 
 promote_rule(::Type{<:Any}, ::Type{<:Any}) = Bottom
-# To fix ambiguities
-promote_rule(::Type{Any}, ::Type{<:Any}) = Any
-promote_rule(::Type{<:Any}, ::Type{Any}) = Any
-promote_rule(::Type{Any}, ::Type{Any}) = Any
 
 promote_result(::Type{<:Any},::Type{<:Any},::Type{T},::Type{S}) where {T,S} = (@_inline_meta; promote_type(T,S))
 # If no promote_rule is defined, both directions give Bottom. In that

base/some.jl

@@ -13,16 +13,26 @@ struct Some{T}
 end
 
 promote_rule(::Type{Some{T}}, ::Type{Some{S}}) where {T, S<:T} = Some{T}
-promote_rule(::Type{Some{T}}, ::Type{Nothing}) where {T} = Union{Some{T}, Nothing}
 
-convert(::Type{Some{T}}, x::Some) where {T} = Some{T}(convert(T, x.value))
-convert(::Type{Some{T}}, x::Some{T}) where {T} = x
-convert(::Type{Union{Some{T}, Nothing}}, x::Some) where {T} = convert(Some{T}, x)
+nonnothingtype(::Type{T}) where {T} = Core.Compiler.typesubtract(T, Nothing)
+promote_rule(T::Type{Nothing}, S::Type) = Union{S, Nothing}
+function promote_rule(T::Type{>:Nothing}, S::Type)
+    R = nonnothingtype(T)
+    R >: T && return Any
+    T = R
+    R = promote_type(T, S)
+    return Union{R, Nothing}
+end
 
-convert(::Type{Union{T, Nothing}}, x::Union{T, Nothing}) where {T} = x
-convert(::Type{Union{T, Nothing}}, x::Any) where {T} = convert(T, x)
-convert(::Type{Nothing}, x::Nothing) = nothing
-convert(::Type{Nothing}, x::Any) = throw(MethodError(convert, (Nothing, x)))
+function nonnothingtype_checked(T::Type)
+    R = nonnothingtype(T)
+    R >: T && error("could not compute non-nothing type")
+    return R
+end
+
+convert(T::Type{>:Nothing}, x) = convert(nonnothingtype_checked(T), x)
+convert(::Type{Some{T}}, x::Some{T}) where {T} = x
+convert(::Type{Some{T}}, x::Some) where {T} = Some{T}(convert(T, x.value))
 
 function show(io::IO, x::Some)
     if get(io, :typeinfo, Any) == typeof(x)

test/ambiguous.jl

@@ -283,23 +283,11 @@ end
         pop!(need_to_handle_undef_sparam, which(Base.byteenv, (Union{AbstractArray{Pair{T}, 1}, Tuple{Vararg{Pair{T}}}} where T<:AbstractString,)))
         pop!(need_to_handle_undef_sparam, which(Base._cat, (Any, SparseArrays._TypedDenseConcatGroup{T} where T)))
         pop!(need_to_handle_undef_sparam, which(Base.float, Tuple{AbstractArray{Union{Missing, T},N} where {T, N}}))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Union{Missing, T}} where T, Any}))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Nothing, S}} where S, Type{T} where T}))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Missing, S}} where S, Type{T} where T}))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Missing, Nothing, S}} where S, Type{T} where T}))
         pop!(need_to_handle_undef_sparam, which(Base.zero, Tuple{Type{Union{Missing, T}} where T}))
         pop!(need_to_handle_undef_sparam, which(Base.one, Tuple{Type{Union{Missing, T}} where T}))
         pop!(need_to_handle_undef_sparam, which(Base.oneunit, Tuple{Type{Union{Missing, T}} where T}))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, (Type{Union{Some{T}, Nothing}} where T, Some)))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, (Type{Union{T, Nothing}} where T, Some)))
         pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Tuple{Vararg{Int}}}, Tuple{}}))
         pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Tuple{Vararg{Int}}}, Tuple{Int8}}))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Union{Nothing,T}},Union{Nothing,T}} where T))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Union{Missing,T}},Union{Missing,T}} where T))
-        pop!(need_to_handle_undef_sparam, which(Base.convert, Tuple{Type{Union{Missing,Nothing,T}},Union{Missing,Nothing,T}} where T))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Nothing,T}},Type{Any}} where T))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Missing,T}},Type{Any}} where T))
-        pop!(need_to_handle_undef_sparam, which(Base.promote_rule, Tuple{Type{Union{Missing,Nothing,T}},Type{Any}} where T))
         @test need_to_handle_undef_sparam == Set()
     end
 end