complete Final, Generic cases

Author: Daraan

src/test_typing_extensions.py

@@ -8300,20 +8300,29 @@ class Y(Generic[T_in_G], _EasyStr):
                 Format.FORWARDREF: TypeError,
                 Format.STRING: "Protocol",
             },
-            Final: [  # plain usage of Final
-                {
-                    "skip_if": {"is_class": False},
-                    Format.VALUE: Final,
-                    Format.FORWARDREF: Final,
-                    Format.STRING: Final,
-                },
-                {
-                    "skip_if": {"is_class": True},
-                    Format.VALUE: TypeError,
-                    Format.FORWARDREF: TypeError,
-                    Format.STRING: Final,
-                },
-            ],
+            Final: (
+                [  # plain usage of Final
+                    {
+                        "skip_if": {"is_class": False},
+                        Format.VALUE: Final,
+                        Format.FORWARDREF: Final,
+                        Format.STRING: str(Final),
+                    },
+                    {
+                        "skip_if": {"is_class": True},
+                        Format.VALUE: TypeError,
+                        Format.FORWARDREF: TypeError,
+                        Format.STRING: str(Final),
+                    },
+                ]
+                if _FORWARD_REF_HAS_CLASS
+                else Final  # no errors here
+            ),
+            Generic: {
+                Format.VALUE: TypeError,
+                Format.FORWARDREF: TypeError,
+                Format.STRING: "Generic",
+            },
             Union[str, None, "str"]: {
                 Format.VALUE: Optional[str],
                 Format.FORWARDREF: Optional[str],
@@ -8340,6 +8349,8 @@ def _unroll_subcase(
         ):
             type_params = expected.get("type_params", None)
             skip_if = expected.get("skip_if", False)
+            if format not in expected:
+                return
             if skip_if:
                 L = locals()
                 skip = all(
@@ -8411,17 +8422,17 @@ def unroll_cases(cases, outer_locals):
                         ),
                     )
                 else:
+                    # NOTE: only for non-dict inputs
                     # Change expected to TypeError if it will fail typing._type_check
-                    if not inspect.isclass(expected):
+                    if format != Format.STRING and not inspect.isclass(expected):
                         invalid_generic_forms = (Generic, Protocol)
-                        if not is_class:
+                        if is_class is False:
                             invalid_generic_forms += (ClassVar,)
                             if is_argument:
                                 invalid_generic_forms += (Final,)
-                        if (
-                            format != Format.STRING
-                            and get_origin(expected) in invalid_generic_forms
-                        ):
+                        elif not _FORWARD_REF_HAS_CLASS and is_argument:
+                            invalid_generic_forms += (ClassVar, Final,)
+                        if get_origin(expected) in invalid_generic_forms:
                             expected = TypeError
                     type_params = None
                     yield (
@@ -8450,12 +8461,6 @@ def unroll_cases(cases, outer_locals):
                 ref = typing.ForwardRef(annot, is_argument=is_argument, is_class=is_class)
             else:
                 ref = typing.ForwardRef(annot, is_argument=is_argument)
-            expected_orig = expected
-            orig_globalns = globalns
-            orig_localns = localns
-            expected = expected_orig
-            globalns = orig_globalns
-            localns = orig_localns
             with self.subTest(
                 format=format,
                 ref=ref,

src/typing_extensions.py

@@ -4065,24 +4065,28 @@ def _lax_type_check(
                 type_ = typing._type_convert(value)
         else:
             if value is None:
-                type_ = type(None)
-            elif isinstance(value, str):
-                type_ = ForwardRef(value)
-            else:
-                type_ = value
+                return type(None)
+            if isinstance(value, str):
+                return ForwardRef(value)
+            type_ = value
+        if type(type_) is tuple:  # early versions raise with callable here
+            raise exec
         invalid_generic_forms = (Generic, Protocol)
         if not allow_special_forms:
             invalid_generic_forms += (ClassVar,)
             if is_argument:
                 invalid_generic_forms += (Final,)
-        if type(type_) is tuple:
-            raise exec
         if (
             isinstance(type_, typing._GenericAlias)
-            and type_.__origin__ in invalid_generic_forms
+            and get_origin(type_) in invalid_generic_forms
         ):
             raise TypeError(f"{type_} is not valid as type argument") from None
-        if isinstance(type_, (_SpecialForm, typing._SpecialForm)) or type_ in (Generic, Protocol):
+        if allow_special_forms is not None and type_ in (ClassVar, Final):
+            return type_
+        if (
+            isinstance(type_, (_SpecialForm, typing._SpecialForm))
+            or type_ in (Generic, Protocol)
+        ):
             raise TypeError(f"Plain {type_} is not valid as type argument") from None
         return type_
 
@@ -4160,9 +4164,21 @@ def evaluate_forward_ref(
                 msg,
                 is_argument=forward_ref.__forward_is_argument__,
                 allow_special_forms=(
-                    _FORWARD_REF_HAS_CLASS and forward_ref.__forward_is_class__
-                )
+                    (_FORWARD_REF_HAS_CLASS and forward_ref.__forward_is_class__)
+                    or
+                    ( _FORWARD_REF_HAS_CLASS and None)  # pass None in this case
+                ),
             )
+        else:
+            # ClassVar/Final could pass _type_check but should error
+            if sys.version_info < (3, 11) and (
+                _FORWARD_REF_HAS_CLASS
+                and not forward_ref.__forward_is_class__
+                and value in (ClassVar, Final)
+            ):
+                raise TypeError(f"Plain {type_} is not valid as type argument")
+
+        del value
 
         # Check if evaluation is possible
         if isinstance(type_, ForwardRef):