make fallback hash a constant instead of based on object id

fixes #12198

base/Enums.jl

@@ -14,6 +14,8 @@ Base.cconvert(::Type{T}, x::Enum{T2}) where {T<:Integer,T2<:Integer} = T(x)
 Base.write(io::IO, x::Enum{T}) where {T<:Integer} = write(io, T(x))
 Base.read(io::IO, ::Type{T}) where {T<:Enum} = T(read(io, Enums.basetype(T)))
 
+Base.hash(x::Enum, h::UInt) = Base.hash_by_id(x, h)
+
 # generate code to test whether expr is in the given set of values
 function membershiptest(expr, values)
  lo, hi = extrema(values)

base/dict.jl

@@ -332,7 +332,8 @@ function ht_keyindex2!(h::Dict{K,V}, key) where V where K
  sz = length(h.keys)
  iter = 0
  maxprobe = h.maxprobe
- index = hashindex(key, sz)
+ hashval = hash(key)
+ index = (((hashval%Int) & (sz-1)) + 1)::Int
  avail = 0
  keys = h.keys
 
@@ -361,7 +362,13 @@ function ht_keyindex2!(h::Dict{K,V}, key) where V where K
 
  avail < 0 && return avail
 
- maxallowed = max(maxallowedprobe, sz>>maxprobeshift)
+ if hashval == 0
+ # assume a hash value of 0 means we're using the fallback hash function,
+ # so gracefully decay to linear lookup.
+ maxallowed = sz - 1
+ else
+ maxallowed = max(maxallowedprobe, sz>>maxprobeshift)
+ end
  # Check if key is not present, may need to keep searching to find slot
  @inbounds while iter < maxallowed
  if !isslotfilled(h,index)

base/hashing.jl

@@ -14,13 +14,28 @@ Typically, any type that implements `hash` should also implement its own `==` (h
 `isequal`) to guarantee the property mentioned above. Types supporting subtraction
 (operator `-`) should also implement [`widen`](@ref), which is required to hash
 values inside heterogeneous arrays.
+
+The default hash function simply returns `h`, in order to be compatible with any
+possible user-defined equality function. Therefore hash-based collections like `Dict`
+work correctly but very slowly for user-defined types without `hash` methods.
 """
 hash(x::Any) = hash(x, zero(UInt))
 hash(w::WeakRef, h::UInt) = hash(w.value, h)
 
 ## hashing general objects ##
 
-hash(@nospecialize(x), h::UInt) = hash_uint(3h - object_id(x))
+# do no hashing by default, to be consistent with any user-defined equality method
+hash(@nospecialize(x), h::UInt) = h
+
+hash_by_id(@nospecialize(x), h::UInt) = hash_uint(3h - object_id(x))
+
+# some types for which == and === are the same
+hash(x::Union{Symbol, Task, TypeName, Method, Module, Nothing, Missing, Core.IntrinsicFunction,
+ GlobalRef, LineNumberNode, LabelNode, GotoNode, Slot, SSAValue, NewvarNode, TypeVar},
+ h::UInt) = hash_by_id(x, h)
+
+# this is too strict, but the best we can do
+hash(x::Type, h::UInt) = hash_by_id(x, h)
 
 ## core data hashing functions ##
 

base/operators.jl

@@ -64,6 +64,9 @@ Collections should generally implement `==` by calling `==` recursively on all c
 
 New numeric types should implement this function for two arguments of the new type, and
 handle comparison to other types via promotion rules where possible.
+
+If a type that implements `==` will be used in sets or as dictionary keys, it should also
+implement [`hash`](@ref).
 """
 ==(x, y) = x === y
 

doc/src/manual/performance-tips.md

@@ -1509,3 +1509,16 @@ The following examples may help you interpret expressions marked as containing n
  field `data::Array{T}`. But `Array` needs the dimension `N`, too, to be a concrete type.
  * Suggestion: use concrete types like `Array{T,3}` or `Array{T,N}`, where `N` is now a parameter
  of `ArrayContainer`
+
+## Define `hash` for custom types used as dictionary keys
+
+The default `hash` function returns a constant `0` value, causing `Dict`s and `Set`s to perform
+linear-time (instead of near-constant-time) lookup. This allows these collections to work
+correctly by default for arbitrary new definitions of `==`, but can cause performance problems.
+If you encounter this problem, simply add an appropriate method for `Base.hash(x::MyType, h::UInt)`.
+If the built-in equality function `===` already has the desired behavior for your type, this
+definition can be used:
+
+```julia
+Base.hash(x::MyType, h::UInt) = Base.hash_by_id(x, h)
+```

test/dict.jl

@@ -332,6 +332,23 @@ Base.show(io::IO, ::Alpha) = print(io,"α")
  @test endswith(str, "α => 1")
 end
 
+mutable struct Foo12198
+ x
+end
+Base.:(==)(x::Foo12198, y::Foo12198) = x.x == y.x
+@testset "issue #12198" begin
+ a = [Foo12198(1), Foo12198(1)]
+ @test length(unique(a)) == 1
+ a = [Foo12198(1), Foo12198(2)]
+ @test length(unique(a)) == 2
+ d = Dict()
+ d[Foo12198(1)] = 1
+ @test haskey(d, Foo12198(1))
+ d[Foo12198(1)] = 2
+ @test length(d) == 1
+ @test d[Foo12198(1)] == 2
+end
+
 @testset "issue #2540" begin
  d = Dict{Any,Any}(Dict(x => 1 for x in ['a', 'b', 'c']))
  @test d == Dict('a'=>1, 'b'=>1, 'c'=> 1)