ensure more iterators stay type-stable

This is a frequent performance trap. Perhaps because Tuple/NamedTuple/Pair/default-constructor usage is so much easier than `@nospecialize`. Dunno what else to do but fix them manually.

Author: vtjnash

base/abstractdict.jl

@@ -672,11 +672,11 @@ _oidd_nextind(a, i) = reinterpret(Int, ccall(:jl_eqtable_nextind, Csize_t, (Any,
 
 start(d::IdDict) = _oidd_nextind(d.ht, 0)
 done(d::IdDict, i) = (i == -1)
-next(d::IdDict{K,V}, i) where {K, V} = (Pair{K,V}(d.ht[i+1], d.ht[i+2]), _oidd_nextind(d.ht, i+2))
+next(d::IdDict{K, V}, i) where {K, V} = (Pair{K, V}(d.ht[i + 1]::K, d.ht[i + 2]::V), _oidd_nextind(d.ht, i + 2))
 
 length(d::IdDict) = d.count
 
-copy(d::IdDict) = IdDict(d)
+copy(d::IdDict) = typeof(d)(d)
 
 get!(d::IdDict{K,V}, @nospecialize(key), @nospecialize(default)) where {K, V} = (d[key] = get(d, key, default))::V
 
@@ -689,14 +689,14 @@ mutable struct IdSet{T} <: AbstractSet{T}
     dict::IdDict{T,Nothing}
 
     IdSet{T}() where {T} = new(IdDict{T,Nothing}())
-    IdSet{T}(s::IdSet{T}) where {T} = new(IdDict{T,Nothing}(s.dict))
+    IdSet{T}(s::IdSet{T}) where {T} = new(copy(s.dict))
 end
 
 IdSet{T}(itr) where {T} = union!(IdSet{T}(), itr)
 IdSet() = IdSet{Any}()
 
-copy(s::IdSet{T}) where {T} = IdSet{T}(s)
-copymutable(s::IdSet{T}) where {T} = IdSet{T}(s)
+copymutable(s::IdSet) = typeof(s)(s)
+copy(s::IdSet) = typeof(s)(s)
 
 isempty(s::IdSet) = isempty(s.dict)
 length(s::IdSet)  = length(s.dict)

base/expr.jl

@@ -32,23 +32,33 @@ end
 
 ## expressions ##
 
-copy(e::Expr) = (n = Expr(e.head);
-                 n.args = copy_exprargs(e.args);
-                 n.typ = e.typ;
-                 n)
+function copy(e::Expr)
+    n = Expr(e.head)
+    n.args = copy_exprargs(e.args)
+    n.typ = e.typ
+    return n
+end
 
 # copy parts of an AST that the compiler mutates
-copy_exprs(x::Expr) = copy(x)
 copy_exprs(@nospecialize(x)) = x
+copy_exprs(x::Expr) = copy(x)
 function copy_exprs(x::PhiNode)
     new_values = Vector{Any}(undef, length(x.values))
-    for i = 1:length(x.edges)
+    for i = 1:length(x.values)
+        isassigned(x.values, i) || continue
+        new_values[i] = copy_exprs(x.values[i])
+    end
+    return PhiNode(copy(x.edges), new_values)
+end
+function copy_exprs(x::PhiCNode)
+    new_values = Vector{Any}(undef, length(x.values))
+    for i = 1:length(x.values)
         isassigned(x.values, i) || continue
         new_values[i] = copy_exprs(x.values[i])
     end
-    PhiNode(copy(x.edges), new_values)
+    return PhiCNode(new_values)
 end
-copy_exprargs(x::Array{Any,1}) = Any[copy_exprs(a) for a in x]
+copy_exprargs(x::Array{Any,1}) = Any[copy_exprs(x[i]) for i in 1:length(x)]
 
 ==(x::Expr, y::Expr) = x.head === y.head && isequal(x.args, y.args)
 ==(x::QuoteNode, y::QuoteNode) = isequal(x.value, y.value)

base/iterators.jl

@@ -226,10 +226,10 @@ length(v::Pairs)  = length(v.itr)
 axes(v::Pairs) = axes(v.itr)
 size(v::Pairs)    = size(v.itr)
 @inline start(v::Pairs) = start(v.itr)
-@propagate_inbounds function next(v::Pairs, state)
+@propagate_inbounds function next(v::Pairs{K, V}, state) where {K, V}
     indx, n = next(v.itr, state)
     item = v.data[indx]
-    return (Pair(indx, item), n)
+    return (Pair{K, V}(indx, item), n)
 end
 @inline done(v::Pairs, state) = done(v.itr, state)
 

base/pair.jl

@@ -28,18 +28,27 @@ foo
 7
 ```
 """
-struct Pair{A,B}
+struct Pair{A, B}
     first::A
     second::B
+    function Pair{A, B}(@nospecialize(a), @nospecialize(b)) where {A, B}
+        @_inline_meta
+        # if we didn't inline this, it's probably because the callsite was actually dynamic
+        # to avoid potentially compiling many copies of this, we mark the arguments with `@nospecialize`
+        # but also mark the whole function with `@inline` to ensure we will inline it whenever possible
+        # (even if `convert(::Type{A}, a::A)` for some reason was expensive)
+        return new(a, b)
+    end
 end
+Pair(a::A, b::B) where {A, B} = Pair{A, B}(a, b)
 const => = Pair
 
 start(p::Pair) = 1
 done(p::Pair, i) = i>2
-next(p::Pair, i) = (getfield(p,i), i+1)
-eltype(p::Type{Pair{A,B}}) where {A,B} = Union{A,B}
+next(p::Pair, i) = (getfield(p, i), i+1)
+eltype(p::Type{Pair{A, B}}) where {A, B} = Union{A, B}
 
-indexed_next(p::Pair, i::Int, state) = (getfield(p,i), i+1)
+indexed_next(p::Pair, i::Int, state) = (getfield(p, i), i+1)
 
 hash(p::Pair, h::UInt) = hash(p.second, hash(p.first, h))