cast list to tuple done, loosened type checks for Generic

Author: Fidget-Spinner

Lib/test/test_typing.py

@@ -1131,10 +1131,6 @@ class P(PR[int, T], Protocol[T]):
             PR[int]
         with self.assertRaises(TypeError):
             P[int, str]
-        with self.assertRaises(TypeError):
-            PR[int, 1]
-        with self.assertRaises(TypeError):
-            PR[int, ClassVar]
 
         class C(PR[int, T]): pass
 
@@ -1156,8 +1152,6 @@ class P(PR[int, str], Protocol):
         self.assertIsSubclass(P, PR)
         with self.assertRaises(TypeError):
             PR[int]
-        with self.assertRaises(TypeError):
-            PR[int, 1]
 
         class P1(Protocol, Generic[T]):
             def bar(self, x: T) -> str: ...
@@ -1176,8 +1170,6 @@ def bar(self, x: str) -> str:
                 return x
 
         self.assertIsInstance(Test(), PSub)
-        with self.assertRaises(TypeError):
-            PR[int, ClassVar]
 
     def test_init_called(self):
         T = TypeVar('T')
@@ -4346,25 +4338,30 @@ class X(Generic[T, P]):
         self.assertEqual(G2.__parameters__, (P_2,))
 
         # currently raises TypeError for _type_check
-        # G3 = X[int, [int, bool]]
-        # self.assertEqual(G3.__args__, (int, [int, bool]))
-        # self.assertEqual(G3.__parameters__, ())
-
-        # G4 = X[int, ...]
-        # self.assertEqual(G4.__args__, (int, type(Ellipsis)))
-        # self.assertEqual(G4.__parameters__, ())
-        #
-        # class Z(Generic[P]):
-        #     f: Callable[P, int]
-
-        # These are valid
-        # currently raises TypeError for _type_check
-        # G5 = Z[[int, str, bool]]
+        G3 = X[int, [int, bool]]
+        self.assertEqual(G3.__args__, (int, (int, bool)))
+        self.assertEqual(G3.__parameters__, ())
+
+        G4 = X[int, ...]
+        self.assertEqual(G4.__args__, (int, Ellipsis))
+        self.assertEqual(G4.__parameters__, ())
+
+        class Z(Generic[P]):
+            f: Callable[P, int]
+
+        G5 = Z[[int, str, bool]]
+        self.assertEqual(G5.__args__, ((int, str, bool),))
+        self.assertEqual(G5.__parameters__, ())
+
+        G6 = Z[int, str, bool]
+        self.assertEqual(G6.__args__, ((int, str, bool),))
+        self.assertEqual(G6.__parameters__, ())
 
-        # currently raises TypeError for too many parameters (not enough TypeVars)
-        # G6 = Z[int, str, bool]
-        # self.assertEqual(G6.__args__, (int, str, bool))
-        # self.assertEqual(G6.__parameters__, ())
+        # G5 and G6 should be equivalent according to the PEP
+        self.assertEqual(G5.__args__, G6.__args__)
+        self.assertEqual(G5.__origin__, G6.__origin__)
+        self.assertEqual(G5.__parameters__, G6.__parameters__)
+        self.assertEqual(G5, G6)
 
 
 class ConcatenateTests(BaseTestCase):

Lib/typing.py

@@ -1127,8 +1127,7 @@ def __class_getitem__(cls, params):
         if not params and cls is not Tuple:
             raise TypeError(
                 f"Parameter list to {cls.__qualname__}[...] cannot be empty")
-        msg = "Parameters to generic types must be types."
-        params = tuple(_type_check(p, msg) for p in params)
+        params = tuple(_type_convert(p) for p in params)
         if cls in (Generic, Protocol):
             # Generic and Protocol can only be subscripted with unique type variables.
             if not all(isinstance(p, (TypeVar, ParamSpec)) for p in params):
@@ -1140,6 +1139,23 @@ def __class_getitem__(cls, params):
                     f"Parameters to {cls.__name__}[...] must all be unique")
         else:
             # Subscripting a regular Generic subclass.
+
+            # Code below handles PEP 612 ParamSpec.
+            if any(isinstance(t, ParamSpec) for t in cls.__parameters__):
+                # Special case where Z[[int, str, bool]] == Z[int, str, bool]
+                # in PEP 612.
+                if len(cls.__parameters__) == 1 and len(params) > 1:
+                    params = (params,)
+                else:
+                    _params = []
+                    # Convert lists to tuples to help other libraries cache the
+                    # results.
+                    for p, tvar in zip(params, cls.__parameters__):
+                        if isinstance(tvar, ParamSpec) and isinstance(p, list):
+                            p = tuple(p)
+                        _params.append(p)
+                    params = tuple(_params)
+
             _check_generic(cls, params, len(cls.__parameters__))
         return _GenericAlias(cls, params)