Restructured tests and applied suggested changes

Author: Daraan

src/test_typing_extensions.py

@@ -1649,32 +1649,47 @@ def test_annotation_and_optional_default(self):
         annotation = Annotated[Union[int, None], "data"]
         optional_annotation = Optional[annotation]
 
-        def wanted_optional(bar: optional_annotation): ...
-        def wanted_optional_default(bar: optional_annotation = None): ...
-        def wanted_optional_ref(bar: 'Optional[Annotated[Union[int, None], "data"]]'): ...
-
-        def no_optional(bar: annotation): ...
-        def no_optional_default(bar: annotation = None): ...
-        def no_optional_defaultT(bar: Union[annotation, T] = None): ...
-        def no_optional_defaultT_ref(bar: "Union[annotation, T]" = None): ...
-
-        for func in(wanted_optional, wanted_optional_default, wanted_optional_ref):
-            self.assertEqual(
-                get_type_hints(func, include_extras=True),
-                {"bar": optional_annotation}
-            )
-
-        for func in (no_optional, no_optional_default):
-            self.assertEqual(
-                get_type_hints(func, include_extras=True),
-                {"bar": annotation}
-            )
+        cases = {
+            ((), False): {},
+            ((), True): {},
+            (int, False): {"x": int},
+            (int, True): {"x": int},
+            (Optional[int], False): {"x": Optional[int]},
+            (Optional[int], True): {"x": Optional[int]},
+            (optional_annotation, False): {"x": optional_annotation},
+            (optional_annotation, True): {"x": optional_annotation},
+            (str(optional_annotation), True): {"x": optional_annotation},
+            (annotation, False): {"x": annotation},
+            (annotation, True): {"x": annotation},
+            (Union[annotation, T], False): {"x": Union[annotation, T]},
+            (Union[annotation, T], True): {"x": Union[annotation, T]},
+            (Union[str, None, "str"], False): {"x": Optional[str]},
+            (Union[str, None, "str"], True): {"x": Optional[str]},
+            (Union[str, "str"], False): {
+                "x": str
+                if sys.version_info >= (3, 9)
+                # _eval_type does not resolve correctly to str in 3.8
+                else typing._eval_type(Union[str, "str"], None, None),
+            },
+            (Union[str, "str"], True): {"x": str},
+            (List["str"], False): {"x": List[str]},
+            (List["str"], True): {"x": List[str]},
+            (Optional[List[str]], False): {"x": Optional[List[str]]},
+            (Optional[List[str]], True): {"x": Optional[List[str]]},
+        }
 
-        for func in (no_optional_defaultT, no_optional_defaultT_ref):
-            self.assertEqual(
-                get_type_hints(func, globals(), locals(), include_extras=True),
-                {"bar": Union[annotation, T]}
-        )
+        for (annot, none_default), expected in cases.items():
+            with self.subTest(annotation=annot, none_default=none_default, expected_type_hints=expected):
+                if annot == ():
+                    if none_default:
+                        def func(x = None): pass
+                    else:
+                        def func(x): pass
+                elif none_default:
+                    def func(x: annot = None): pass
+                else:
+                    def func(x: annot): pass
+                self.assertEqual(get_type_hints(func, include_extras=True), expected)
 
 
 class GetUtilitiesTestCase(TestCase):

src/typing_extensions.py

@@ -1236,8 +1236,8 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
             )
         else:  # 3.8
             hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
-        if sys.version_info < (3, 11) and hint:
-            hint = _clean_optional(obj, hint, globalns, localns)
+        if sys.version_info < (3, 11):
+            _clean_optional(obj, hint, globalns, localns)
         if include_extras:
             return hint
         return {k: _strip_extras(t) for k, t in hint.items()}
@@ -1247,7 +1247,7 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
     def _could_be_inserted_optional(t):
         """detects Union[..., None] pattern"""
         # 3.8+ compatible checking before _UnionGenericAlias
-        if not hasattr(t, "__origin__") or t.__origin__ is not Union:
+        if get_origin(t) is not Union:
             return False
         # Assume if last argument is not None they are user defined
         if t.__args__[-1] is not _NoneType:
@@ -1259,8 +1259,12 @@ def _clean_optional(obj, hints, globalns=None, localns=None):
         # reverts injected Union[..., None] cases from typing.get_type_hints
         # when a None default value is used.
         # see https://github.com/python/typing_extensions/issues/310
-        original_hints = getattr(obj, '__annotations__', None)
+        if not hints or isinstance(obj, type):
+            return
         defaults = typing._get_defaults(obj)
+        if not defaults:
+            return
+        original_hints = obj.__annotations__
         for name, value in hints.items():
             # Not a Union[..., None] or replacement conditions not fullfilled
             if (not _could_be_inserted_optional(value)
@@ -1269,7 +1273,7 @@ def _clean_optional(obj, hints, globalns=None, localns=None):
             ):
                 continue
             original_value = original_hints[name]
-            if original_value is None:
+            if original_value is None:  # should not happen
                 original_value = _NoneType
             # Forward reference
             if isinstance(original_value, str):
@@ -1287,24 +1291,19 @@ def _clean_optional(obj, hints, globalns=None, localns=None):
                 elif localns is None:
                     localns = globalns
                 if sys.version_info < (3, 9):
-                    ref = ForwardRef(original_value)
+                    original_value = ForwardRef(original_value)
                 else:
-                    ref = ForwardRef(
+                    original_value = ForwardRef(
                         original_value,
                         is_argument=not isinstance(obj, _types.ModuleType)
                     )
-                original_value = typing._eval_type(ref, globalns, localns)
-            # Values was not modified or original is already Optional
-            if original_value == value or _could_be_inserted_optional(original_value):
-                continue
-            # NoneType was added to value
-            if len(value.__args__) == 2:
-                hints[name] = value.__args__[0]  # not a Union
-            else:
-                hints[name] = Union[value.__args__[:-1]]  # still a Union
-
-        return hints
-
+            original_evaluated = typing._eval_type(original_value, globalns, localns)
+            if sys.version_info < (3, 9) and get_origin(original_evaluated) is Union:
+                # Union[str, None, "str"] is not reduced to Union[str, None]
+                original_evaluated = Union[original_evaluated.__args__]
+            # Compare if values differ
+            if original_evaluated != value:
+                hints[name] = original_evaluated
 
 # Python 3.9+ has PEP 593 (Annotated)
 if hasattr(typing, 'Annotated'):