disable local-class hashing

Author: matthiasdiener

pytools/persistent_dict.py

@@ -251,15 +251,11 @@ def update_for_type(self, key_hash: Hash, key: type) -> None:
                 resolved = getattr(resolved, attr)  # pyright: ignore[reportAny]
             if resolved is key:
                 # Globally accessible: hash based on name
-                self.rec(key_hash,
-                    f"{key.__module__}.{key.__qualname__}".encode()
-                )
+                self.rec(key_hash, f"{key.__module__}.{key.__qualname__}")
             else:
-                # Name collision or local class; fall back
-                self.rec(key_hash, f"{key.__module__}.{key.__qualname__}_{id(key)}")
+                raise ValueError(f"Cannot hash function-local class '{key}'")
         except (KeyError, AttributeError):
-            # Can't resolve the class name, must be local
-            self.rec(key_hash, f"{key.__module__}.{key.__qualname__}_{id(key)}")
+            raise ValueError(f"Cannot hash function-local class '{key}'") from None
 
     update_for_ABCMeta = update_for_type
 

pytools/test/test_persistent_dict.py

@@ -503,8 +503,6 @@ def test_ABC_hashing() -> None:  # noqa: N802
     class MyABC(ABC):  # noqa: B024
         pass
 
-    assert keyb(MyABC) != keyb(ABC)
-
     with pytest.raises(TypeError):
         keyb(MyABC())
 
@@ -515,62 +513,29 @@ class MyABC2(MyABC):
         def update_persistent_hash(self, key_hash, key_builder):
             key_builder.rec(key_hash, 42)
 
-    assert keyb(MyABC2) != keyb(MyABC)
     assert keyb(MyABC2())
 
     class MyABC3(metaclass=ABCMeta):  # noqa: B024
         def update_persistent_hash(self, key_hash, key_builder):
             key_builder.rec(key_hash, 42)
 
-    assert keyb(MyABC3) != keyb(MyABC) != keyb(MyABC3())
+    assert keyb(MyABC3())
 
 
 class WithoutUpdateMethodGlobal:
     pass
 
 
-class CollidingNameClass:
-    pass
-
-
 def test_class_hashing() -> None:
     keyb = KeyBuilder()
 
-    class WithoutUpdateMethod:
-        pass
-
-    assert keyb(WithoutUpdateMethod) == keyb(WithoutUpdateMethod)
     assert keyb(WithoutUpdateMethodGlobal) == keyb(WithoutUpdateMethodGlobal)
-
-    # This doesn't work with the function-local class "WithoutUpdateMethod", because
-    # local classes are instantiated at each function call, and thus their hash
-    # includes the id() of the class:
-    # assert keyb(WithoutUpdateMethod) == "N/A"
     assert keyb(WithoutUpdateMethodGlobal) == "49c4673089d30507"
 
-    with pytest.raises(TypeError):
-        # does not have update_persistent_hash() = > will raise
-        keyb(WithoutUpdateMethod())
-
     with pytest.raises(TypeError):
         # does not have update_persistent_hash() = > will raise
         keyb(WithoutUpdateMethodGlobal())
 
-    # {{{ test for name collisions between top-level and function-local classes
-
-    def make_colliding_name_class():
-        class CollidingNameClass:
-            pass
-
-        return CollidingNameClass
-
-    top_level_cls = CollidingNameClass
-    shadowed_cls = make_colliding_name_class()
-
-    assert keyb(top_level_cls) != keyb(shadowed_cls)
-
-    # }}}
-
     class WithUpdateMethod:
         def update_persistent_hash(self, key_hash, key_builder):
             # Only called for instances of this class, not for the class itself
@@ -583,11 +548,8 @@ class TagClass(Tag):
     class TagClass2(Tag):
         pass
 
-    assert keyb(WithUpdateMethod) != keyb(WithUpdateMethod())
-    assert keyb(TagClass) != keyb(TagClass())
-    assert keyb(TagClass2) != keyb(TagClass2())
+    assert keyb(WithUpdateMethod()) == keyb(WithUpdateMethod())
 
-    assert keyb(TagClass) != keyb(TagClass2)
     assert keyb(TagClass()) != keyb(TagClass2())
 
     assert keyb(TagClass()) == "7b3e4e66503438f6"