fix replace for dicts/sets, when the eltype changes (#38267)

There were two bugs:
1. for dicts, `empty(d, elemtype)` was used instead of
   `empty(d, keytype, valtype)`
2. the lower-level `_replace!` routines were accepting only an
   old/new container pair with the exact same `eltype`, new items
   had to have the same type as old one.

Author: rfourquet

base/set.jl

@@ -433,7 +433,7 @@ end
 # TODO: use copy!, which is currently unavailable from here since it is defined in Future
 _copy_oftype(x, ::Type{T}) where {T} = copyto!(similar(x, T), x)
 # TODO: use similar() once deprecation is removed and it preserves keys
-_copy_oftype(x::AbstractDict, ::Type{T}) where {T} = merge!(empty(x, T), x)
+_copy_oftype(x::AbstractDict, ::Type{Pair{K,V}}) where {K,V} = merge!(empty(x, K, V), x)
 _copy_oftype(x::AbstractSet, ::Type{T}) where {T} = union!(empty(x, T), x)
 
 _copy_oftype(x::AbstractArray{T}, ::Type{T}) where {T} = copy(x)
@@ -617,8 +617,10 @@ replace(a::AbstractString, b::Pair, c::Pair) = throw(MethodError(replace, (a, b,
 askey(k, ::AbstractDict) = k.first
 askey(k, ::AbstractSet) = k
 
-function _replace!(new::Callable, res::T, A::T,
-                   count::Int) where T<:Union{AbstractDict,AbstractSet}
+function _replace!(new::Callable, res::Union{AbstractDict,AbstractSet},
+                   A::Union{AbstractDict,AbstractSet}, count::Int)
+    @assert res isa AbstractDict && A isa AbstractDict ||
+        res isa AbstractSet && A isa AbstractSet
     count == 0 && return res
     c = 0
     if res === A # cannot replace elements while iterating over A
@@ -686,7 +688,7 @@ end
 
 ### specialization for Dict / Set
 
-function _replace!(new::Callable, t::Dict{K,V}, A::Dict{K,V}, count::Int) where {K,V}
+function _replace!(new::Callable, t::Dict{K,V}, A::AbstractDict, count::Int) where {K,V}
     # we ignore A, which is supposed to be equal to the destination t,
     # as it can generally be faster to just replace inline
     count == 0 && return t
@@ -718,7 +720,7 @@ function _replace!(new::Callable, t::Dict{K,V}, A::Dict{K,V}, count::Int) where
     t
 end
 
-function _replace!(new::Callable, t::Set{T}, ::Set{T}, count::Int) where {T}
+function _replace!(new::Callable, t::Set{T}, ::AbstractSet, count::Int) where {T}
     _replace!(t.dict, t.dict, count) do kv
         k = first(kv)
         k2 = new(k)

test/sets.jl

@@ -646,6 +646,26 @@ end
     x = @inferred replace([1, missing], missing=>2, 1=>missing)
     @test isequal(x, [missing, 2]) && x isa Vector{Union{Int, Missing}}
 
+    # eltype promotion for dicts
+    d = Dict(1=>2, 3=>4)
+    f = replace(d, (1=>2) => (1=>nothing))
+    @test f == Dict(3=>4, 1=>nothing)
+    @test eltype(f) == Pair{Int, Union{Nothing, Int}}
+    f = replace(d, (1=>2) => (1=>missing), (3=>4)=>(3=>missing))
+    @test valtype(f) == Union{Missing,Int}
+    f = replace(d, (1=>2) => (1=>'a'), (3=>4)=>(3=>'b'))
+    @test valtype(f) == Any
+    @test f == Dict(3=>'b', 1=>'a')
+
+    # eltype promotion for sets
+    s = Set([1, 2, 3])
+    f = replace(s, 2=>missing, 3=>nothing)
+    @test f == Set([1, missing, nothing])
+    @test eltype(f) == Union{Int,Missing,Nothing}
+    f = replace(s, 2=>'a')
+    @test eltype(f) == Any
+    @test f == Set([1, 3, 'a'])
+
     # test that isequal is used
     @test replace([NaN, 1.0], NaN=>0.0) == [0.0, 1.0]
     @test replace([1, missing], missing=>0) == [1, 0]