Require n::Integer for sizehint!(a, n) (#59168)

Currently we're a bit hit-and-miss about any type-restriction on the
second argument to `sizehint!`: of 11 methods, 4 require `n::Integer`
and the remainder are unrestricted. Arguably, our dispatch is "prettier"
if methods differ only in their first argument and are consistent about
type-restrictions on `n`.

This imposes `::Integer` restrictions on all methods that specify a
non-abstract type for the first argument. Only the fallback methods for
`AbstractDict`, `AbstractSet`, and `AbstractArray` are left
unrestricted. It also makes similar changes to a `rehash!` and
`hashindex` method.

On 1.12-rc1, JET shows 40 runtime dispatches for `report_opt(merge!,
(AbstractDict, AbstractDict))`, most of which are triggered from a
branch on `sizehint!(::WeakKeyDict, ::Any)`. This seems likely to
silence most of those, but it's not possible to check due to JET
currently throwing errors on master.

Because of these unrestricted fallbacks, there is one funny thing which
applies to both this PR and master:
```julia
julia> v = [1, 2, 3];

julia> sizehint!(v, 7.0);   # no-op
```
This is mitigated by the fact that `sizehint!` is just a hint. To me it
still seems like it might be better to throw an error in such cases, but
that is not implemented by this PR.

---------

Co-authored-by: Shuhei Kadowaki <[email protected]>

Author: timholy

base/dict.jl

@@ -124,9 +124,10 @@ _shorthash7(hsh::UInt) = (hsh >> (8sizeof(UInt)-7))%UInt8 | 0x80
 # hashindex (key, sz) - computes optimal position and shorthash7
 #     idx - optimal position in the hash table
 #     sh::UInt8 - short hash (7 highest hash bits)
-function hashindex(key, sz)
+function hashindex(key, sz::Integer)
+    sz = Int(sz)::Int
     hsh = hash(key)::UInt
-    idx = (((hsh % Int) & (sz-1)) + 1)::Int
+    idx = ((hsh % Int) & (sz-1)) + 1
     return idx, _shorthash7(hsh)
 end
 

base/iddict.jl

@@ -58,12 +58,12 @@ IdDict(kv) = dict_with_eltype((K, V) -> IdDict{K, V}, kv, eltype(kv))
 
 empty(d::IdDict, ::Type{K}, ::Type{V}) where {K, V} = IdDict{K,V}()
 
-function rehash!(d::IdDict, newsz = length(d.ht)%UInt)
+function rehash!(d::IdDict, newsz::Integer = length(d.ht)%UInt)
     d.ht = ccall(:jl_idtable_rehash, Memory{Any}, (Any, Csize_t), d.ht, newsz)
     d
 end
 
-function sizehint!(d::IdDict, newsz)
+function sizehint!(d::IdDict, newsz::Integer)
     newsz = _tablesz(newsz*2)  # *2 for keys and values in same array
     oldsz = length(d.ht)
     # grow at least 25%

base/idset.jl

@@ -78,7 +78,7 @@ pop!(s::IdSet, @nospecialize(x)) = _pop!(s, x) == -1 ? throw(KeyError(x)) : x
 pop!(s::IdSet, @nospecialize(x), @nospecialize(default)) = _pop!(s, x) == -1 ? default : x
 delete!(s::IdSet, @nospecialize(x)) = (_pop!(s, x); s)
 
-function sizehint!(s::IdSet, newsz)
+function sizehint!(s::IdSet, newsz::Integer)
     # TODO: grow/compact list and perform rehash, if profitable?
     # TODO: shrink?
     # s.list = resize(s.list, newsz)

base/set.jl

@@ -169,7 +169,7 @@ copymutable(s::Set{T}) where {T} = Set{T}(s)
 # Set is the default mutable fall-back
 copymutable(s::AbstractSet{T}) where {T} = Set{T}(s)
 
-sizehint!(s::Set, newsz; shrink::Bool=true) = (sizehint!(s.dict, newsz; shrink); s)
+sizehint!(s::Set, newsz::Integer; shrink::Bool=true) = (sizehint!(s.dict, newsz; shrink); s)
 empty!(s::Set) = (empty!(s.dict); s)
 rehash!(s::Set) = (rehash!(s.dict); s)
 

base/weakkeydict.jl

@@ -76,7 +76,7 @@ function _cleanup_locked(h::WeakKeyDict)
     return h
 end
 
-sizehint!(d::WeakKeyDict, newsz; shrink::Bool = true) = @lock d sizehint!(d.ht, newsz; shrink = shrink)
+sizehint!(d::WeakKeyDict, newsz::Integer; shrink::Bool = true) = @lock d sizehint!(d.ht, newsz; shrink = shrink)
 empty(d::WeakKeyDict, ::Type{K}, ::Type{V}) where {K, V} = WeakKeyDict{K, V}()
 
 IteratorSize(::Type{<:WeakKeyDict}) = SizeUnknown()