Fix yet another bug and add many more tests

Author: AlexWaygood

Lib/test/test_typing.py

@@ -4858,7 +4858,7 @@ def f(x: X): ...
             {'x': list[list[ForwardRef('X')]]}
         )
 
-    def test_pep695_generic_with_future_annotations(self):
+    def test_pep695_generic_class_with_future_annotations(self):
         original_globals = dict(ann_module695.__dict__)
 
         hints_for_A = get_type_hints(ann_module695.A)
@@ -4867,15 +4867,21 @@ def test_pep695_generic_with_future_annotations(self):
         self.assertEqual(hints_for_A["y"].__args__[0], Unpack[A_type_params[1]])
         self.assertIs(hints_for_A["z"].__args__[0], A_type_params[2])
 
+        # should not have changed as a result of the get_type_hints() calls!
+        self.assertEqual(ann_module695.__dict__, original_globals)
+
+    def test_pep695_generic_class_with_future_annotations_and_local_shadowing(self):
         hints_for_B = get_type_hints(ann_module695.B)
         self.assertEqual(hints_for_B, {"x": int, "y": str, "z": bytes})
 
+    def test_pep695_generic_class_with_future_annotations_name_clash_with_global_vars(self):
         hints_for_C = get_type_hints(ann_module695.C)
         self.assertEqual(
             set(hints_for_C.values()),
             set(ann_module695.C.__type_params__)
         )
 
+    def test_pep_695_generic_function_with_future_annotations(self):
         hints_for_generic_function = get_type_hints(ann_module695.generic_function)
         func_t_params = ann_module695.generic_function.__type_params__
         self.assertEqual(
@@ -4886,6 +4892,13 @@ def test_pep695_generic_with_future_annotations(self):
         self.assertIs(hints_for_generic_function["z"].__origin__, func_t_params[2])
         self.assertIs(hints_for_generic_function["zz"].__origin__, func_t_params[2])
 
+    def test_pep_695_generic_function_with_future_annotations_name_clash_with_global_vars(self):
+        self.assertEqual(
+            set(get_type_hints(ann_module695.generic_function_2).values()),
+            set(ann_module695.generic_function_2.__type_params__)
+        )
+
+    def test_pep_695_generic_method_with_future_annotations(self):
         hints_for_generic_method = get_type_hints(ann_module695.D.generic_method)
         params = {
             param.__name__: param
@@ -4896,8 +4909,36 @@ def test_pep695_generic_with_future_annotations(self):
             {"x": params["Foo"], "y": params["Bar"], "return": types.NoneType}
         )
 
-        # should not have changed as a result of the get_type_hints() calls!
-        self.assertEqual(ann_module695.__dict__, original_globals)
+    def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_vars(self):
+        self.assertEqual(
+            set(get_type_hints(ann_module695.D.generic_method_2).values()),
+            set(ann_module695.D.generic_method_2.__type_params__)
+        )
+
+    def test_pep_695_generics_with_future_annotations_nested_in_function(self):
+        results = ann_module695.nested()
+
+        self.assertEqual(
+            set(results.hints_for_E.values()),
+            set(results.E.__type_params__)
+        )
+        self.assertEqual(
+            set(results.hints_for_E_meth.values()),
+            set(results.E.generic_method.__type_params__)
+        )
+        self.assertNotEqual(
+            set(results.hints_for_E_meth.values()),
+            set(results.E.__type_params__)
+        )
+        self.assertEqual(
+            set(results.hints_for_E_meth.values()).intersection(results.E.__type_params__),
+            set()
+        )
+
+        self.assertEqual(
+            set(results.hints_for_generic_func.values()),
+            set(results.generic_func.__type_params__)
+        )
 
     def test_extended_generic_rules_subclassing(self):
         class T1(Tuple[T, KT]): ...

Lib/test/typinganndata/ann_module695.py

@@ -31,10 +31,42 @@ def generic_function[T, *Ts, **P](
 ) -> None: ...
 
 
+def generic_function_2[Eggs, **Spam](x: Eggs, y: Spam): pass
+
+
 class D:
     Foo = int
     Bar = str
 
     def generic_method[Foo, **Bar](
         self, x: Foo, y: Bar
     ) -> None: ...
+
+    def generic_method_2[Eggs, **Spam](self, x: Eggs, y: Spam): pass
+
+
+def nested():
+    from types import SimpleNamespace
+    from typing import get_type_hints
+
+    Eggs = bytes
+    Spam = memoryview
+
+
+    class E[Eggs, **Spam]:
+        x: Eggs
+        y: Spam
+
+        def generic_method[Eggs, **Spam](self, x: Eggs, y: Spam): pass
+
+
+    def generic_function[Eggs, **Spam](x: Eggs, y: Spam): pass
+
+
+    return SimpleNamespace(
+        E=E,
+        hints_for_E=get_type_hints(E),
+        hints_for_E_meth=get_type_hints(E.generic_method),
+        generic_func=generic_function,
+        hints_for_generic_func=get_type_hints(generic_function)
+    )

Lib/typing.py

@@ -1069,15 +1069,12 @@ def _evaluate(self, globalns, localns, type_params=_sentinel, *, recursive_guard
             # but should in turn be overridden by names in the class scope
             # (which here are called `globalns`!)
             if type_params:
-                if self.__forward_is_class__:
-                    globalns, localns = dict(globalns), dict(localns)
-                    for param in type_params:
-                        param_name = param.__name__
-                        if param_name not in globalns:
-                            globalns[param_name] = param
-                            localns.pop(param_name, None)
-                else:
-                    localns = {param.__name__: param for param in type_params} | localns
+                globalns, localns = dict(globalns), dict(localns)
+                for param in type_params:
+                    param_name = param.__name__
+                    if not self.__forward_is_class__ or param_name not in globalns:
+                        globalns[param_name] = param
+                        localns.pop(param_name, None)
 
             type_ = _type_check(
                 eval(self.__forward_code__, globalns, localns),