add a small test for hashability of bare classes

pytools/persistent_dict.py

@@ -244,8 +244,22 @@ def __call__(self, key: Any) -> str:
     # understandably don't like it.
 
     def update_for_type(self, key_hash: Hash, key: type) -> None:
-        key_hash.update(
-            f"{key.__module__}.{key.__qualname__}.{key.__name__}".encode())
+        try:
+            module = sys.modules[key.__module__]
+            resolved = module
+            for attr in key.__qualname__.split("."):
+                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()
+                )
+            else:
+                # Name collision or local class; fall back
+                self.rec(key_hash, f"{key.__module__}.{key.__qualname__}_{id(key)}")
+        except (KeyError, AttributeError):
+            # Can't resolve the class name, must be local
+            self.rec(key_hash, f"{key.__module__}.{key.__qualname__}_{id(key)}")
 
     update_for_ABCMeta = update_for_type
 

pytools/test/test_persistent_dict.py

@@ -525,9 +525,52 @@ def update_persistent_hash(self, key_hash, key_builder):
     assert keyb(MyABC3) != keyb(MyABC) != 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
@@ -548,7 +591,6 @@ class TagClass2(Tag):
     assert keyb(TagClass()) != keyb(TagClass2())
 
     assert keyb(TagClass()) == "7b3e4e66503438f6"
-    assert keyb(TagClass2) == "690b86bbf51aad83"
 
     @tag_dataclass
     class TagClass3(Tag):