`dataclass` is not `Hashable`

[KotlinIsland]

from dataclasses import dataclass
from typing import Hashable


@dataclass
class SusDataclass:
    b = "AMONGUS"


h: Hashable = SusDataclass()  # SUS ALERT!

d = {
    SusDataclass(): 1  # SUS ALERT! fails at runtime
}

[sobolevn]

This happens because unsafe_hash is not taken into an account in plugins/dataclasses.py:

mypy/mypy/plugins/dataclasses.py

Lines 123 to 128 in 2db0511

	decorator_arguments = {
	'init': _get_decorator_bool_argument(self._ctx, 'init', True),
	'eq': _get_decorator_bool_argument(self._ctx, 'eq', True),
	'order': _get_decorator_bool_argument(self._ctx, 'order', False),
	'frozen': _get_decorator_bool_argument(self._ctx, 'frozen', False),
	}

This should still be Hashable:

from dataclasses import dataclass

@dataclass(unsafe_hash=True)
class Some:
    x: int

print(hash(Some(1)))  # ok

I will send a fix today. Thanks for the report! 👍

[sobolevn]

By the way, here's a note from the docs:

If hash() is not explicitly defined, or if it is set to None, then dataclass() may add an implicit hash() method. Although not recommended, you can force dataclass() to create a hash() method with unsafe_hash=True. This might be the case if your class is logically immutable but can nonetheless be mutated. This is a specialized use case and should be considered carefully.

https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass

So, it still might be hashable even without unsafe_hash. I will research it further.

[sobolevn]

unsafe_hash: If False (the default), a hash() method is generated according to how eq and frozen are set.

# __hash__

#    +------------------- unsafe_hash= parameter
#    |       +----------- eq= parameter
#    |       |       +--- frozen= parameter
#    |       |       |
#    v       v       v    |        |        |
#                         |   no   |  yes   |  <--- class has explicitly defined __hash__
# +=======+=======+=======+========+========+
# | False | False | False |        |        | No __eq__, use the base class __hash__
# +-------+-------+-------+--------+--------+
# | False | False | True  |        |        | No __eq__, use the base class __hash__
# +-------+-------+-------+--------+--------+
# | False | True  | False | None   |        | <-- the default, not hashable
# +-------+-------+-------+--------+--------+
# | False | True  | True  | add    |        | Frozen, so hashable, allows override
# +-------+-------+-------+--------+--------+
# | True  | False | False | add    | raise  | Has no __eq__, but hashable
# +-------+-------+-------+--------+--------+
# | True  | False | True  | add    | raise  | Has no __eq__, but hashable
# +-------+-------+-------+--------+--------+
# | True  | True  | False | add    | raise  | Not frozen, but hashable
# +-------+-------+-------+--------+--------+
# | True  | True  | True  | add    | raise  | Frozen, so hashable
# +=======+=======+=======+========+========+
# For boxes that are blank, __hash__ is untouched and therefore
# inherited from the base class.  If the base is object, then
# id-based hashing is used.
#
# Note that a class may already have __hash__=None if it specified an
# __eq__ method in the class body (not one that was created by
# @dataclass).
#
# See _hash_action (below) for a coded version of this table.

https://github.com/python/cpython/blob/e9594f6747eaaaa848c26e2bf67d467aabfd62b3/Lib/dataclasses.py#L121

[sobolevn]

I will send a PR after #11483 is merged. I don't want to solve merge conflicts.

[tmke8]

Aren't the docs quite clear about this?

By default, dataclass() will not implicitly add a __hash__() method unless it is safe to do so. [...] Here are the rules governing implicit creation of a __hash__() method. [...] If eq and frozen are both true, by default dataclass() will generate a __hash__() method for you. If eq is true and frozen is false, __hash__() will be set to None, marking it unhashable (which it is, since it is mutable). If eq is false, __hash__() will be left untouched meaning the __hash__() method of the superclass will be used (if the superclass is object, this means it will fall back to id-based hashing).