change hash

Author: JelleZijlstra

Lib/test/test_types.py

@@ -723,10 +723,39 @@ class B(metaclass=UnhashableMeta): ...
 
         self.assertEqual((A | B).__args__, (A, B))
         union1 = A | B
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union1)
+
         union2 = int | B
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union2)
+
         union3 = A | int
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union3)
+
+    def test_unhashable_becomes_hashable(self):
+        is_hashable = False
+        class UnhashableMeta(type):
+            def __hash__(self):
+                if is_hashable:
+                    return 1
+                else:
+                    raise TypeError("not hashable")
+
+        class A(metaclass=UnhashableMeta): ...
+        class B(metaclass=UnhashableMeta): ...
+
+        union = A | B
+        self.assertEqual(union.__args__, (A, B))
+
+        with self.assertRaisesRegex(TypeError, "not hashable"):
+            hash(union)
+
+        is_hashable = True
 
-        self.assertEqual(len({union1, union2, union3}), 3)
+        with self.assertRaisesRegex(TypeError, "union contains 2 unhashable elements"):
+            hash(union)
 
     def test_instancecheck_and_subclasscheck(self):
         for x in (int | str, typing.Union[int, str]):

Lib/test/test_typing.py

@@ -2062,10 +2062,16 @@ class B(metaclass=UnhashableMeta): ...
 
         self.assertEqual(Union[A, B].__args__, (A, B))
         union1 = Union[A, B]
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union1)
+
         union2 = Union[int, B]
-        union3 = Union[A, int]
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union2)
 
-        self.assertEqual(len({union1, union2, union3}), 3)
+        union3 = Union[A, int]
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union3)
 
     def test_repr(self):
         u = Union[Employee, int]

Objects/unionobject.c

@@ -46,26 +46,25 @@ static Py_hash_t
 union_hash(PyObject *self)
 {
     unionobject *alias = (unionobject *)self;
-    Py_hash_t hash;
-    if (alias->hashable_args) {
-        hash = PyObject_Hash(alias->hashable_args);
-        if (hash == -1) {
-            return -1;
-        }
-    }
-    else {
-        hash = 604;
-    }
-    // Mix in the ids of all the unhashable args.
+    // If there are any unhashable args, treat this union as unhashable.
+    // Otherwise, two unions might compare equal but have different hashes.
     if (alias->unhashable_args) {
+        // Attempt to get an error from one of the values.
         assert(PyTuple_CheckExact(alias->unhashable_args));
         Py_ssize_t n = PyTuple_GET_SIZE(alias->unhashable_args);
         for (Py_ssize_t i = 0; i < n; i++) {
             PyObject *arg = PyTuple_GET_ITEM(alias->unhashable_args, i);
-            hash ^= (Py_hash_t)arg;
+            Py_hash_t hash = PyObject_Hash(arg);
+            if (hash == -1) {
+                return -1;
+            }
         }
+        // The unhashable values somehow became hashable again. Still raise
+        // an error.
+        PyErr_Format(PyExc_TypeError, "union contains %d unhashable elements", n);
+        return -1;
     }
-    return hash;
+    return PyObject_Hash(alias->hashable_args);
 }
 
 static int