Stop using Core.Compiler.return_type

src/Dictionary.jl

@@ -226,8 +226,8 @@
     tmp = iterate(iter)
     if tmp === nothing
         IT = Base.@default_eltype(iter)
-        I = IT == Union{} ? Union{} : Core.Compiler.return_type(first, Tuple{IT})
-        T = IT == Union{} ? Union{} : Core.Compiler.return_type(last, Tuple{IT})
+        I = Base.promote_op(first, IT)
+        T = Base.promote_op(last, IT)
         return Dictionary{I, T}()
     end
     (x, s) = tmp

src/broadcast.jl

@@ -18,8 +18,7 @@ _data(d::BroadcastedDictionary) = getfield(d, :data)
     dicts = _dicts(data...)
     sharetokens = _sharetokens(dicts...)
     I = keytype(dicts[1])
-    Ts = Base.Broadcast.eltypes(data)
-    T = Core.Compiler.return_type(f, Ts)
+    T = Base.Broadcast.combine_eltypes(f, data)
 
     return BroadcastedDictionary{I, T, typeof(f), typeof(data)}(f, data, sharetokens)
 end
@@ -130,4 +129,4 @@ end
 Base.Broadcast.materialize(d::BroadcastedDictionary) = copy(d)
 Base.Broadcast.materialize!(out::AbstractDictionary, d::BroadcastedDictionary) = copyto!(out, d)
 
-Base.Broadcast.materialize!(out::AbstractDictionary, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(identity)}) = fill!(out, bc.args[1][])
+Base.Broadcast.materialize!(out::AbstractDictionary, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(identity)}) = fill!(out, bc.args[1][])

src/map.jl

@@ -88,13 +88,13 @@
 end
 
 function Base.map(f, d::AbstractDictionary)
-    out = similar(d, Core.Compiler.return_type(f, Tuple{eltype(d)}))
+    out = similar(d, Base.promote_op(f, eltype(d)))
     @inbounds map!(f, out, d)
     return out
 end
 
 function Base.map(f, d::AbstractDictionary, ds::AbstractDictionary...)
-    out = similar(d, Core.Compiler.return_type(f, Tuple{eltype(d), map(eltype, ds)...}))
+    out = similar(d, Base.promote_op(f, eltype(d), map(eltype, ds)...))
     @inbounds map!(f, out, d, ds...)
     return out
 end
@@ -145,6 +145,6 @@
 
 function Iterators.map(f, d::AbstractDictionary)
     I = keytype(d)
-    T = Core.Compiler.return_type(f, Tuple{eltype(d)}) # Base normally wouldn't invoke inference for something like this...
+    T = Base.promote_op(f, eltype(d)) # Base normally wouldn't invoke inference for something like this...
     return MappedDictionary{I, T, typeof(f), Tuple{typeof(d)}}(f, (d,))
 end

test/map.jl

@@ -1,7 +1,7 @@
 @testset "map" begin
     function _mapview(f, d::AbstractDictionary)
         I = keytype(d)
-        T = Core.Compiler.return_type(f, Tuple{eltype(d)})
+        T = Base.promote_op(f, eltype(d))
 
         return MappedDictionary{I, T, typeof(f), Tuple{typeof(d)}}(f, (d,))
     end
@@ -23,4 +23,4 @@
 
     @test _mapview(iseven, d)::Dictionaries.MappedDictionary == dictionary([1=>false, 2=>false, 3=>true, 4=>true, 5=>false])
     @test _mapview(isodd, d)::Dictionaries.MappedDictionary == dictionary([1=>true, 2=>true, 3=>false, 4=>false, 5=>true])
-end
+end