Instead implement __eq__/__hash__ correctly

JelleZijlstra · JelleZijlstra · commit f59d4fb724f0 · 2025-02-21T22:14:58.000-08:00
diff --git a/Lib/annotationlib.py b/Lib/annotationlib.py
@@ -219,6 +219,34 @@ def __forward_code__(self):
             raise SyntaxError(f"Forward reference must be an expression -- got {arg!r}")
         return self.__code__
 
+    def __eq__(self, other):
+        if not isinstance(other, ForwardRef):
+            return NotImplemented
+        return (
+            self.__forward_arg__ == other.__forward_arg__
+            and self.__forward_module__ == other.__forward_module__
+            and self.__forward_is_class__ == other.__forward_is_class__
+            and self.__code__ == other.__code__
+            and self.__ast_node__ == other.__ast_node__
+            # Use "is" here because we use id() for this in __hash__
+            # because dictionaries are not hashable.
+            and self.__globals__ is other.__globals__
+            and self.__cell__ == other.__cell__
+            and self.__owner__ == other.__owner__
+        )
+
+    def __hash__(self):
+        return hash((
+            self.__forward_arg__,
+            self.__forward_module__,
+            self.__forward_is_class__,
+            self.__code__,
+            self.__ast_node__,
+            id(self.__globals__),  # dictionaries are not hashable, so hash by identity
+            self.__cell__,
+            self.__owner__,
+        ))
+
     def __or__(self, other):
         global _Union
         if _Union is None:
@@ -232,11 +260,14 @@ def __ror__(self, other):
         return _Union[other, self]
 
     def __repr__(self):
-        if self.__forward_module__ is None:
-            module_repr = ""
-        else:
-            module_repr = f", module={self.__forward_module__!r}"
-        return f"ForwardRef({self.__forward_arg__!r}{module_repr})"
+        extra = []
+        if self.__forward_module__ is not None:
+            extra.append(f", module={self.__forward_module__!r}")
+        if self.__forward_is_class__:
+            extra.append(", is_class=True")
+        if self.__owner__ is not None:
+            extra.append(f", owner={self.__owner__!r}")
+        return f"ForwardRef({self.__forward_arg__!r}{''.join(extra)})"
 
 
 class _Stringifier:
diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
@@ -3,6 +3,7 @@
 if __name__ != 'test.support':
     raise ImportError('support must be imported from the test package')
 
+import annotationlib
 import contextlib
 import functools
 import inspect
@@ -3012,3 +3013,44 @@ def is_libssl_fips_mode():
     except ImportError:
         return False  # more of a maybe, unless we add this to the _ssl module.
     return get_fips_mode() != 0
+
+
+class EqualToForwardRef:
+    """Helper to ease use of annotationlib.ForwardRef in tests.
+
+    This checks only attributes that can be set using the constructor.
+
+    """
+
+    def __init__(
+        self,
+        arg,
+        *,
+        module=None,
+        owner=None,
+        is_class=False,
+    ):
+        self.__forward_arg__ = arg
+        self.__forward_is_class__ = is_class
+        self.__forward_module__ = module
+        self.__owner__ = owner
+
+    def __eq__(self, other):
+        if not isinstance(other, (EqualToForwardRef, annotationlib.ForwardRef)):
+            return NotImplemented
+        return (
+            self.__forward_arg__ == other.__forward_arg__
+            and self.__forward_module__ == other.__forward_module__
+            and self.__forward_is_class__ == other.__forward_is_class__
+            and self.__owner__ == other.__owner__
+        )
+
+    def __repr__(self):
+        extra = []
+        if self.__forward_module__ is not None:
+            extra.append(f", module={self.__forward_module__!r}")
+        if self.__forward_is_class__:
+            extra.append(", is_class=True")
+        if self.__owner__ is not None:
+            extra.append(f", owner={self.__owner__!r}")
+        return f"EqualToForwardRef({self.__forward_arg__!r}{''.join(extra)})"
diff --git a/Lib/test/test_annotationlib.py b/Lib/test/test_annotationlib.py
@@ -32,11 +32,6 @@ def wrapper(a, b):
     return wrapper
 
 
-def assert_is_fwdref(case, obj, value):
-    case.assertIsInstance(obj, annotationlib.ForwardRef)
-    case.assertEqual(obj.__forward_arg__, value)
-
-
 class MyClass:
     def __repr__(self):
         return "my repr"
@@ -64,7 +59,8 @@ def inner(arg: x):
 
         anno = annotationlib.get_annotations(inner, format=Format.FORWARDREF)
         fwdref = anno["arg"]
-        assert_is_fwdref(self, fwdref, "x")
+        self.assertIsInstance(fwdref, annotationlib.ForwardRef)
+        self.assertEqual(fwdref.__forward_arg__, "x")
         with self.assertRaises(NameError):
             fwdref.evaluate()
 
@@ -81,7 +77,8 @@ def f(x: int, y: doesntexist):
         anno = annotationlib.get_annotations(f, format=Format.FORWARDREF)
         self.assertIs(anno["x"], int)
         fwdref = anno["y"]
-        assert_is_fwdref(self, fwdref, "doesntexist")
+        self.assertIsInstance(fwdref, annotationlib.ForwardRef)
+        self.assertEqual(fwdref.__forward_arg__, "doesntexist")
         with self.assertRaises(NameError):
             fwdref.evaluate()
         self.assertEqual(fwdref.evaluate(globals={"doesntexist": 1}), 1)
@@ -99,22 +96,28 @@ def f(
 
         anno = annotationlib.get_annotations(f, format=Format.FORWARDREF)
         x_anno = anno["x"]
-        assert_is_fwdref(self, x_anno, "some.module")
+        self.assertIsInstance(x_anno, ForwardRef)
+        self.assertEqual(x_anno, support.EqualToForwardRef("some.module", owner=f))
 
         y_anno = anno["y"]
-        assert_is_fwdref(self, y_anno, "some[module]")
+        self.assertIsInstance(y_anno, ForwardRef)
+        self.assertEqual(y_anno, support.EqualToForwardRef("some[module]", owner=f))
 
         z_anno = anno["z"]
-        assert_is_fwdref(self, z_anno, "some(module)")
+        self.assertIsInstance(z_anno, ForwardRef)
+        self.assertEqual(z_anno, support.EqualToForwardRef("some(module)", owner=f))
 
         alpha_anno = anno["alpha"]
-        assert_is_fwdref(self, alpha_anno, "some | obj")
+        self.assertIsInstance(alpha_anno, ForwardRef)
+        self.assertEqual(alpha_anno, support.EqualToForwardRef("some | obj", owner=f))
 
         beta_anno = anno["beta"]
-        assert_is_fwdref(self, beta_anno, "+some")
+        self.assertIsInstance(beta_anno, ForwardRef)
+        self.assertEqual(beta_anno, support.EqualToForwardRef("+some", owner=f))
 
         gamma_anno = anno["gamma"]
-        assert_is_fwdref(self, gamma_anno, "some < obj")
+        self.assertIsInstance(gamma_anno, ForwardRef)
+        self.assertEqual(gamma_anno, support.EqualToForwardRef("some < obj", owner=f))
 
 
 class TestSourceFormat(unittest.TestCase):
@@ -359,6 +362,14 @@ def test_fwdref_to_builtin(self):
         obj = object()
         self.assertIs(ForwardRef("int").evaluate(globals={"int": obj}), obj)
 
+    def test_fwdref_value_is_not_cached(self):
+        fr = ForwardRef("hello")
+        with self.assertRaises(NameError):
+            fr.evaluate()
+        self.assertIs(fr.evaluate(globals={"hello": str}), str)
+        with self.assertRaises(NameError):
+            fr.evaluate()
+
     def test_fwdref_with_owner(self):
         self.assertEqual(
             ForwardRef("Counter[int]", owner=collections).evaluate(),
@@ -447,10 +458,12 @@ def f2(a: undefined):
         )
         self.assertEqual(annotationlib.get_annotations(f1, format=1), {"a": int})
 
-        for fmt in (Format.FORWARDREF, 3):
-            annos = annotationlib.get_annotations(f2, format=fmt)
-            self.assertEqual(list(annos), ["a"])
-            assert_is_fwdref(self, annos["a"], "undefined")
+        fwd = support.EqualToForwardRef("undefined", owner=f2)
+        self.assertEqual(
+            annotationlib.get_annotations(f2, format=Format.FORWARDREF),
+            {"a": fwd},
+        )
+        self.assertEqual(annotationlib.get_annotations(f2, format=3), {"a": fwd})
 
         self.assertEqual(
             annotationlib.get_annotations(f1, format=Format.STRING),
@@ -1000,10 +1013,10 @@ def evaluate(format, exc=NotImplementedError):
 
         with self.assertRaises(NameError):
             annotationlib.call_evaluate_function(evaluate, Format.VALUE)
-
-        fwdref = annotationlib.call_evaluate_function(evaluate, Format.FORWARDREF)
-        assert_is_fwdref(self, fwdref, "undefined")
-
+        self.assertEqual(
+            annotationlib.call_evaluate_function(evaluate, Format.FORWARDREF),
+            support.EqualToForwardRef("undefined"),
+        )
         self.assertEqual(
             annotationlib.call_evaluate_function(evaluate, Format.STRING),
             "undefined",
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
@@ -1,4 +1,4 @@
-from annotationlib import Format, ForwardRef
+from annotationlib import Format
 import asyncio
 import builtins
 import collections
@@ -37,7 +37,7 @@
 
 from test.support import cpython_only, import_helper
 from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ
-from test.support import run_no_yield_async_fn
+from test.support import run_no_yield_async_fn, EqualToForwardRef
 from test.support.import_helper import DirsOnSysPath, ready_to_import
 from test.support.os_helper import TESTFN, temp_cwd
 from test.support.script_helper import assert_python_ok, assert_python_failure, kill_python
@@ -48,7 +48,6 @@
 from test.test_inspect import inspect_fodder2 as mod2
 from test.test_inspect import inspect_stringized_annotations
 from test.test_inspect import inspect_deferred_annotations
-from test.test_typing import EqualToForwardRef
 
 
 # Functions tested in this suite:
@@ -4932,9 +4931,12 @@ def test_signature_annotation_format(self):
                     signature_func(ida.f, annotation_format=Format.STRING),
                     sig([par("x", PORK, annotation="undefined")])
                 )
+                s1 = signature_func(ida.f, annotation_format=Format.FORWARDREF)
+                s2 = sig([par("x", PORK, annotation=EqualToForwardRef("undefined", owner=ida.f))])
+                #breakpoint()
                 self.assertEqual(
                     signature_func(ida.f, annotation_format=Format.FORWARDREF),
-                    sig([par("x", PORK, annotation=EqualToForwardRef("undefined"))])
+                    sig([par("x", PORK, annotation=EqualToForwardRef("undefined", owner=ida.f))])
                 )
                 with self.assertRaisesRegex(NameError, "undefined"):
                     signature_func(ida.f, annotation_format=Format.VALUE)
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
diff --git a/Misc/NEWS.d/next/Library/2025-01-29-21-29-46.gh-issue-129463.qePexX.rst b/Misc/NEWS.d/next/Library/2025-01-29-21-29-46.gh-issue-129463.qePexX.rst
