Manual forward port of 64962 - use PyObject_HashNotImplemented as a tp_hash level...
authorNick Coghlan <ncoghlan@gmail.com>
Tue, 15 Jul 2008 15:46:38 +0000 (15:46 +0000)
committerNick Coghlan <ncoghlan@gmail.com>
Tue, 15 Jul 2008 15:46:38 +0000 (15:46 +0000)
12 files changed:
Include/object.h
Lib/decimal.py
Lib/test/seq_tests.py
Lib/test/test_descr.py
Lib/test/test_hash.py
Lib/test/test_richcmp.py
Modules/_collectionsmodule.c
Objects/dictobject.c
Objects/listobject.c
Objects/object.c
Objects/setobject.c
Objects/typeobject.c

index 1e929750f88b34d9cd434e03deeea4d8f3922e42..7f0e24a220622cad4ca474dfa7b6c7c7bf9fd665 100644 (file)
@@ -438,6 +438,7 @@ PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
 PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *,
                                              PyObject *, PyObject *);
 PyAPI_FUNC(long) PyObject_Hash(PyObject *);
+PyAPI_FUNC(long) PyObject_HashNotImplemented(PyObject *);
 PyAPI_FUNC(int) PyObject_IsTrue(PyObject *);
 PyAPI_FUNC(int) PyObject_Not(PyObject *);
 PyAPI_FUNC(int) PyCallable_Check(PyObject *);
index 180b17790665e5c1e3668a9abaca943e01d45921..2c02f11213463f4bfaf4ee1791e34f6a925af996 100644 (file)
@@ -3783,10 +3783,8 @@ class Context(object):
         for flag in flags:
             self._ignored_flags.remove(flag)
 
-    def __hash__(self):
-        """A Context cannot be hashed."""
-        # We inherit object.__hash__, so we must deny this explicitly
-        raise TypeError("Cannot hash a Context.")
+    # We inherit object.__hash__, so we must deny this explicitly
+    __hash__ = None
 
     def Etiny(self):
         """Returns Etiny (= Emin - prec + 1)"""
index dd12ee3a05639483f522ed45ccae7b60dc909902..962cfe12ea28a2129b04e13bba113cf681c31085 100644 (file)
@@ -212,8 +212,7 @@ class CommonTest(unittest.TestCase):
             # So instances of AllEq must be found in all non-empty sequences.
             def __eq__(self, other):
                 return True
-            def __hash__(self):
-                raise NotImplemented
+            __hash__ = None # Can't meet hash invariant requirements
         self.assert_(AllEq() not in self.type2test([]))
         self.assert_(AllEq() in self.type2test([1]))
 
index bfbb400f400cd11b16ea377759ed00b6c89e5add..3c0bae0ccc73cf529ad8e3b85e817324a67f9583 100644 (file)
@@ -3070,12 +3070,20 @@ order (MRO) for bases """
         self.assertEqual(hash(d), 144)
         D.__hash__ = lambda self: 100
         self.assertEqual(hash(d), 100)
+        D.__hash__ = None
+        self.assertRaises(TypeError, hash, d)
         del D.__hash__
         self.assertEqual(hash(d), 144)
+        B.__hash__ = None
+        self.assertRaises(TypeError, hash, d)
         del B.__hash__
         self.assertEqual(hash(d), 314)
+        C.__hash__ = None
+        self.assertRaises(TypeError, hash, d)
         del C.__hash__
         self.assertEqual(hash(d), 42)
+        A.__hash__ = None
+        self.assertRaises(TypeError, hash, d)
         del A.__hash__
         self.assertEqual(hash(d), orig_hash)
         d.foo = 42
index fb1699a13220570856f38f64bc85d6ff673d1eb1..56974b8cc3b236365edc80b051ab82a2dc701c19 100644 (file)
@@ -1,9 +1,11 @@
 # test the invariant that
 #   iff a==b then hash(a)==hash(b)
 #
+# Also test that hash implementations are inherited as expected
 
 import unittest
 from test import support
+from collections import Hashable
 
 
 class HashEqualityTestCase(unittest.TestCase):
@@ -37,8 +39,74 @@ class HashEqualityTestCase(unittest.TestCase):
         self.same_hash(float(0.5), complex(0.5, 0.0))
 
 
+_default_hash = object.__hash__
+class DefaultHash(object): pass
+
+_FIXED_HASH_VALUE = 42
+class FixedHash(object):
+    def __hash__(self):
+        return _FIXED_HASH_VALUE
+
+class OnlyEquality(object):
+    def __eq__(self, other):
+        return self is other
+
+class OnlyInequality(object):
+    def __ne__(self, other):
+        return self is not other
+
+class OnlyCmp(object):
+    def __cmp__(self, other):
+        return cmp(id(self), id(other))
+
+class InheritedHashWithEquality(FixedHash, OnlyEquality): pass
+class InheritedHashWithInequality(FixedHash, OnlyInequality): pass
+class InheritedHashWithCmp(FixedHash, OnlyCmp): pass
+
+class NoHash(object):
+    __hash__ = None
+
+class HashInheritanceTestCase(unittest.TestCase):
+    default_expected = [object(),
+                        DefaultHash(),
+                        OnlyInequality(),
+                       ]
+    fixed_expected = [FixedHash(),
+                      InheritedHashWithEquality(),
+                      InheritedHashWithInequality(),
+                      InheritedHashWithCmp(),
+                      ]
+    error_expected = [NoHash(),
+                      OnlyEquality(),
+                      OnlyCmp(),
+                      ]
+
+    def test_default_hash(self):
+        for obj in self.default_expected:
+            self.assertEqual(hash(obj), _default_hash(obj))
+
+    def test_fixed_hash(self):
+        for obj in self.fixed_expected:
+            self.assertEqual(hash(obj), _FIXED_HASH_VALUE)
+
+    def test_error_hash(self):
+        for obj in self.error_expected:
+            self.assertRaises(TypeError, hash, obj)
+
+    def test_hashable(self):
+        objects = (self.default_expected +
+                   self.fixed_expected)
+        for obj in objects:
+            self.assert_(isinstance(obj, Hashable), repr(obj))
+
+    def test_not_hashable(self):
+        for obj in self.error_expected:
+            self.assertFalse(isinstance(obj, Hashable), repr(obj))
+
+
 def test_main():
-    support.run_unittest(HashEqualityTestCase)
+    support.run_unittest(HashEqualityTestCase,
+                         HashInheritanceTestCase)
 
 
 if __name__ == "__main__":
index 30dac8f91755d0e0a1ebfbd3495c5e8d5a42932a..435de75a84887139a80b08d652411f93e00cbeb4 100644 (file)
@@ -48,8 +48,7 @@ class Vector:
     def __setitem__(self, i, v):
         self.data[i] = v
 
-    def __hash__(self):
-        raise TypeError("Vectors cannot be hashed")
+    __hash__ = None # Vectors cannot be hashed
 
     def __bool__(self):
         raise TypeError("Vectors cannot be used in Boolean contexts")
@@ -85,35 +84,6 @@ class Vector:
             raise ValueError("Cannot compare vectors of different length")
         return other
 
-
-class SimpleOrder(object):
-    """
-    A simple class that defines order but not full comparison.
-    """
-
-    def __init__(self, value):
-        self.value = value
-
-    def __lt__(self, other):
-        if not isinstance(other, SimpleOrder):
-            return True
-        return self.value < other.value
-
-    def __gt__(self, other):
-        if not isinstance(other, SimpleOrder):
-            return False
-        return self.value > other.value
-
-
-class DumbEqualityWithoutHash(object):
-    """
-    A class that define __eq__, but no __hash__: it shouldn't be hashable.
-    """
-
-    def __eq__(self, other):
-        return False
-
-
 opmap = {
     "lt": (lambda a,b: a< b, operator.lt, operator.__lt__),
     "le": (lambda a,b: a<=b, operator.le, operator.__le__),
@@ -360,38 +330,8 @@ class ListTest(unittest.TestCase):
             self.assertIs(op(x, y), True)
 
 
-class HashableTest(unittest.TestCase):
-    """
-    Test hashability of classes with rich operators defined.
-    """
-
-    def test_simpleOrderHashable(self):
-        """
-        A class that only defines __gt__ and/or __lt__ should be hashable.
-        """
-        a = SimpleOrder(1)
-        b = SimpleOrder(2)
-        self.assert_(a < b)
-        self.assert_(b > a)
-        self.assert_(a.__hash__ is not None)
-
-    def test_notHashableException(self):
-        """
-        If a class is not hashable, it should raise a TypeError with an
-        understandable message.
-        """
-        a = DumbEqualityWithoutHash()
-        try:
-            hash(a)
-        except TypeError as e:
-            self.assertEquals(str(e),
-                              "unhashable type: 'DumbEqualityWithoutHash'")
-        else:
-            raise support.TestFailed("Should not be here")
-
-
 def test_main():
-    support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest, HashableTest)
+    support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
 
 if __name__ == "__main__":
     test_main()
index db7017d4def0d9ac6dd079226699bd9e741c1f08..2327cf529c6e781b7040ea9a99eb566a0862422b 100644 (file)
@@ -608,13 +608,6 @@ deque_traverse(dequeobject *deque, visitproc visit, void *arg)
        return 0;
 }
 
-static long
-deque_nohash(PyObject *self)
-{
-       PyErr_SetString(PyExc_TypeError, "deque objects are unhashable");
-       return -1;
-}
-
 static PyObject *
 deque_copy(PyObject *deque)
 {
@@ -858,7 +851,7 @@ static PyTypeObject deque_type = {
        0,                              /* tp_as_number */
        &deque_as_sequence,             /* tp_as_sequence */
        0,                              /* tp_as_mapping */
-       deque_nohash,                   /* tp_hash */
+       (hashfunc)PyObject_HashNotImplemented,  /* tp_hash */
        0,                              /* tp_call */
        0,                              /* tp_str */
        PyObject_GenericGetAttr,        /* tp_getattro */
index eb576664c91061271c9f14986c6d8b36a81c0a59..828803c0912a678fad3ba5d03f279cfa8db977b3 100644 (file)
@@ -2031,7 +2031,7 @@ PyTypeObject PyDict_Type = {
        0,                                      /* tp_as_number */
        &dict_as_sequence,                      /* tp_as_sequence */
        &dict_as_mapping,                       /* tp_as_mapping */
-       0,                                      /* tp_hash */
+       (hashfunc)PyObject_HashNotImplemented,  /* tp_hash */
        0,                                      /* tp_call */
        0,                                      /* tp_str */
        PyObject_GenericGetAttr,                /* tp_getattro */
index 255f087f95d0ed896a440780863199d3349ceaed..af3ed2c58319b7151d79b87c61390f9dc1f14004 100644 (file)
@@ -2568,7 +2568,7 @@ PyTypeObject PyList_Type = {
        0,                                      /* tp_as_number */
        &list_as_sequence,                      /* tp_as_sequence */
        &list_as_mapping,                       /* tp_as_mapping */
-       0,                                      /* tp_hash */
+       (hashfunc)PyObject_HashNotImplemented,  /* tp_hash */
        0,                                      /* tp_call */
        0,                                      /* tp_str */
        PyObject_GenericGetAttr,                /* tp_getattro */
index 85bb850e8be6736d9bee9e94b46f31095dd07152..ff16994e651d80d8eac7fb392c40819204318192 100644 (file)
@@ -781,17 +781,22 @@ finally:
 #endif
 }
 
+long
+PyObject_HashNotImplemented(PyObject *v)
+{
+       PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
+                    Py_TYPE(v)->tp_name);
+       return -1;
+}
 
 long
 PyObject_Hash(PyObject *v)
 {
-       PyTypeObject *tp = v->ob_type;
+       PyTypeObject *tp = Py_TYPE(v);
        if (tp->tp_hash != NULL)
                return (*tp->tp_hash)(v);
        /* Otherwise, the object can't be hashed */
-       PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
-                    v->ob_type->tp_name);
-       return -1;
+       return PyObject_HashNotImplemented(v);
 }
 
 PyObject *
index 79598f272d009e93c43efd14003310f9298097e8..771f47efea0e1d1eeb1258bf578c491f31bbf10c 100644 (file)
@@ -2092,7 +2092,7 @@ PyTypeObject PySet_Type = {
        &set_as_number,                 /* tp_as_number */
        &set_as_sequence,               /* tp_as_sequence */
        0,                              /* tp_as_mapping */
-       0,                              /* tp_hash */
+       (hashfunc)PyObject_HashNotImplemented,  /* tp_hash */
        0,                              /* tp_call */
        0,                              /* tp_str */
        PyObject_GenericGetAttr,        /* tp_getattro */
index c139fbcd51c62da56bee1c93ccbeb9f183a30e19..9306552a6adee1a1ebbd11fe1fed8fd4e1f2cff2 100644 (file)
@@ -3810,13 +3810,15 @@ PyType_Ready(PyTypeObject *type)
 
        /* Hack for tp_hash and __hash__.
           If after all that, tp_hash is still NULL, and __hash__ is not in
-          tp_dict, set tp_dict['__hash__'] equal to None.
+          tp_dict, set tp_hash to PyObject_HashNotImplemented and
+          tp_dict['__hash__'] equal to None.
           This signals that __hash__ is not inherited.
         */
        if (type->tp_hash == NULL) {
                if (PyDict_GetItemString(type->tp_dict, "__hash__") == NULL) {
                        if (PyDict_SetItemString(type->tp_dict, "__hash__", Py_None) < 0)
                                goto error;
+                       type->tp_hash = PyObject_HashNotImplemented;
                }
        }
 
@@ -4943,9 +4945,7 @@ slot_tp_hash(PyObject *self)
        }
 
        if (func == NULL) {
-               PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
-                            Py_TYPE(self)->tp_name);
-               return -1;
+               return PyObject_HashNotImplemented(self);
         }
 
        res = PyEval_CallObject(func, NULL);
@@ -5676,6 +5676,13 @@ update_one_slot(PyTypeObject *type, slotdef *p)
                           sanity checks.  I'll buy the first person to
                           point out a bug in this reasoning a beer. */
                }
+               else if (descr == Py_None &&
+                        strcmp(p->name, "__hash__") == 0) {
+                       /* We specifically allow __hash__ to be set to None
+                          to prevent inheritance of the default
+                          implementation from object.__hash__ */
+                       specific = PyObject_HashNotImplemented;
+               }
                else {
                        use_generic = 1;
                        generic = p->function;
@@ -5889,12 +5896,21 @@ add_operators(PyTypeObject *type)
                        continue;
                if (PyDict_GetItem(dict, p->name_strobj))
                        continue;
-               descr = PyDescr_NewWrapper(type, p, *ptr);
-               if (descr == NULL)
-                       return -1;
-               if (PyDict_SetItem(dict, p->name_strobj, descr) < 0)
-                       return -1;
-               Py_DECREF(descr);
+               if (*ptr == PyObject_HashNotImplemented) {
+                       /* Classes may prevent the inheritance of the tp_hash
+                          slot by storing PyObject_HashNotImplemented in it. Make it
+                          visible as a None value for the __hash__ attribute. */
+                       if (PyDict_SetItem(dict, p->name_strobj, Py_None) < 0)
+                               return -1;
+               }
+               else {
+                       descr = PyDescr_NewWrapper(type, p, *ptr);
+                       if (descr == NULL)
+                               return -1;
+                       if (PyDict_SetItem(dict, p->name_strobj, descr) < 0)
+                               return -1;
+                       Py_DECREF(descr);
+               }
        }
        if (type->tp_new != NULL) {
                if (add_tp_new_wrapper(type) < 0)