Fix/slot hashes

CHANGELOG.rst

@@ -28,6 +28,7 @@ Changes:
  `#198 <https:/python-attrs/attrs/issues/198>`_
 - ``attr.Factory`` is now hashable again.
  `#204 <https:/python-attrs/attrs/issues/204>`_
+- Hashing behavior when ``hash=False`` is now consistent for slot and non-slot classes.
 
 
 ----

src/attr/_make.py

@@ -368,6 +368,8 @@ def wrap(cls):
  cls = _add_pickle(cls)
  if slots is True:
  cls_dict = dict(cls.__dict__)
+ was_unhashable = ('__hash__' in cls_dict and
+ cls_dict['__hash__'] is None)
  cls_dict["__slots__"] = tuple(ca_list)
  for ca_name in ca_list:
  # It might not actually be in there, e.g. if using 'these'.
@@ -376,6 +378,14 @@ def wrap(cls):
 
  qualname = getattr(cls, "__qualname__", None)
  cls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
+
+ if (not was_unhashable and hash is False and
+ '__hash__' in cls.__dict__ and
+ cls.__dict__['__hash__'] is None):
+
+ # Python just set __hash__ = None for us, revert this.
+ del cls.__hash__
+
  if qualname is not None:
  cls.__qualname__ = qualname
 

tests/test_hash.py

@@ -0,0 +1,105 @@
+"""
+Tests for our hashing functionality.
+"""
+import pytest
+
+import attr
+
+from hypothesis import given
+from hypothesis.strategies import booleans
+
+
+@given(slots=booleans(), frozen=booleans(), cmp=booleans())
+def test_no_subclass_no_hash(slots, frozen, cmp):
+ """
+ Classes inheriting from ``object``, and setting ``hash=False`` fall back
+ to ``object.__hash__``.
+ """
+ @attr.s(hash=False, slots=slots, frozen=frozen, cmp=cmp)
+ class A(object):
+ a = attr.ib()
+
+ assert A.__hash__ == object.__hash__
+ hash(A(1)) # Should not raise.
+
+ assert hash(A(1)) != hash(A(1)) # Identity-based hash.
+
+
+@given(slots=booleans(), frozen=booleans(), cmp=booleans())
+def test_no_subclass_has_hash(slots, frozen, cmp):
+ """
+ Classes inheriting from ``object``, and setting ``hash=True`` use the
+ ``attrs``-generated hash.
+ """
+ @attr.s(hash=True, slots=slots, frozen=frozen, cmp=cmp)
+ class A(object):
+ a = attr.ib()
+
+ assert A.__hash__ is not object.__hash__
+ hash(A(1)) # Should not raise.
+
+ assert hash(A(1)) == hash(A(1))
+
+
+@given(slots=booleans(), frozen=booleans(), cmp=booleans())
+def test_no_subclass_default_hash(slots, frozen, cmp):
+ """
+ Classes inheriting from ``object``, and setting ``hash=None`` set their
+ ``__hash__`` according to whether they're frozen and comparable.
+ """
+ @attr.s(slots=slots, frozen=frozen, cmp=cmp)
+ class A(object):
+ a = attr.ib()
+
+ if frozen and cmp:
+ assert A.__hash__ is not object.__hash__
+ hash(A(1)) # Should not raise.
+
+ assert hash(A(1)) == hash(A(1))
+ elif cmp and not frozen:
+ # We make the class unhashable.
+ assert A.__hash__ is None
+
+ with pytest.raises(TypeError):
+ hash(A(1))
+ elif not cmp:
+ # Fall back to object.__hash__.
+ assert A.__hash__ == object.__hash__
+ hash(A(1)) # Should not raise.
+
+ assert hash(A(1)) != hash(A(1)) # Identity-based hash.
+
+
+@given(super_slots=booleans(), super_frozen=booleans(), slots=booleans(),
+ frozen=booleans())
+def test_subclass_default_hash(super_slots, super_frozen, slots, frozen):
+ """
+ ``cmp=False`` and ``hash=None`` makes classes use the ``__hash__`` of their
+ superclass.
+ """
+ @attr.s(slots=super_slots, frozen=super_frozen)
+ class A(object):
+ a = attr.ib()
+
+ @attr.s(slots=slots, frozen=frozen, cmp=False)
+ class B(A):
+ b = attr.ib()
+
+ assert B.__hash__ == A.__hash__ # ``is`` doesn't work on Py2.
+
+
+@given(slots=booleans(), frozen=booleans())
+def test_make_unhashable(slots, frozen):
+ """
+ Creating classes that have a __cmp__ but are unhashable is possible.
+ """
+ @attr.s(cmp=True, hash=False, slots=slots, frozen=frozen)
+ class A(object):
+ a = attr.ib()
+
+ __hash__ = None
+
+ with pytest.raises(TypeError):
+ hash(A(1))
+
+ assert A.__hash__ is None