Do not use special names in STRING format

Author: JelleZijlstra

Lib/annotationlib.py

@@ -305,7 +305,13 @@ def __convert_to_ast(self, other):
             if isinstance(other.__ast_node__, str):
                 return ast.Name(id=other.__ast_node__), other.__extra_names__
             return other.__ast_node__, other.__extra_names__
-        elif other is None or type(other) in (str, int, float, bool, complex):
+        elif (
+            # In STRING format we don't bother with the create_unique_name() dance;
+            # it's better to emit the repr() of the object instead of an opaque name.
+            self.__stringifier_dict__.format == Format.STRING
+            or other is None
+            or type(other) in (str, int, float, bool, complex)
+        ):
             return ast.Constant(value=other), None
         elif type(other) is dict:
             extra_names = {}
@@ -519,14 +525,15 @@ def unary_op(self):
 
 
 class _StringifierDict(dict):
-    def __init__(self, namespace, globals=None, owner=None, is_class=False):
+    def __init__(self, namespace, *, globals=None, owner=None, is_class=False, format):
         super().__init__(namespace)
         self.namespace = namespace
         self.globals = globals
         self.owner = owner
         self.is_class = is_class
         self.stringifiers = []
         self.next_id = 1
+        self.format = format
 
     def __missing__(self, key):
         fwdref = _Stringifier(
@@ -587,7 +594,7 @@ def call_annotate_function(annotate, format, *, owner=None, _is_evaluate=False):
         # possibly constants if the annotate function uses them directly). We then
         # convert each of those into a string to get an approximation of the
         # original source.
-        globals = _StringifierDict({})
+        globals = _StringifierDict({}, format=format)
         if annotate.__closure__:
             freevars = annotate.__code__.co_freevars
             new_closure = []
@@ -637,9 +644,10 @@ def call_annotate_function(annotate, format, *, owner=None, _is_evaluate=False):
         is_class = isinstance(owner, type)
         globals = _StringifierDict(
             namespace,
-            annotate.__globals__,
-            owner,
-            is_class,
+            globals=annotate.__globals__,
+            owner=owner,
+            is_class=is_class,
+            format=format,
         )
         if annotate.__closure__:
             freevars = annotate.__code__.co_freevars

Lib/test/test_annotationlib.py

@@ -406,6 +406,17 @@ def f(fstring_format: f"{a:02d}"):
         with self.assertRaisesRegex(TypeError, format_msg):
             annotationlib.get_annotations(f, format=Format.STRING)
 
+    def test_shenanigans(self):
+        # In cases like this we can't reconstruct the source; test that we do something
+        # halfway reasonable.
+        def f(x: x | (1).__class__, y: (1).__class__):
+            pass
+
+        self.assertEqual(
+            annotationlib.get_annotations(f, format=Format.STRING),
+            {"x": "x | <class 'int'>", "y": "<class 'int'>"},
+        )
+
 
 class TestForwardRefClass(unittest.TestCase):
     def test_special_attrs(self):