gh-88959: Add __parameters__ and __getitem__ in TypeVar and ParamSpec

Include/internal/pycore_global_strings.h

@@ -204,7 +204,6 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(__trunc__)
         STRUCT_FOR_ID(__typing_is_unpacked_typevartuple__)
         STRUCT_FOR_ID(__typing_prepare_subst__)
-        STRUCT_FOR_ID(__typing_subst__)
         STRUCT_FOR_ID(__typing_unpacked_tuple_args__)
         STRUCT_FOR_ID(__warningregistry__)
         STRUCT_FOR_ID(__weaklistoffset__)

Include/internal/pycore_runtime_init.h

@@ -826,7 +826,6 @@ extern "C" {
                 INIT_ID(__trunc__), \
                 INIT_ID(__typing_is_unpacked_typevartuple__), \
                 INIT_ID(__typing_prepare_subst__), \
-                INIT_ID(__typing_subst__), \
                 INIT_ID(__typing_unpacked_tuple_args__), \
                 INIT_ID(__warningregistry__), \
                 INIT_ID(__weaklistoffset__), \

Lib/test/test_typing.py

@@ -448,16 +448,18 @@ def test_no_bivariant(self):
 
     def test_var_substitution(self):
         T = TypeVar('T')
-        subst = T.__typing_subst__
-        self.assertIs(subst(int), int)
-        self.assertEqual(subst(list[int]), list[int])
-        self.assertEqual(subst(List[int]), List[int])
-        self.assertEqual(subst(List), List)
-        self.assertIs(subst(Any), Any)
-        self.assertIs(subst(None), type(None))
-        self.assertIs(subst(T), T)
-        self.assertEqual(subst(int|str), int|str)
-        self.assertEqual(subst(Union[int, str]), Union[int, str])
+        self.assertEqual(T.__parameters__, (T,))
+        self.assertIs(T.__parameters__[0], T)
+        self.assertIs(T[int,], int)
+        self.assertEqual(T[list[int],], list[int])
+        self.assertEqual(T[List[int],], List[int])
+        self.assertEqual(T[List,], List)
+        self.assertIs(T[Any,], Any)
+        self.assertIs(T[None,], type(None))
+        self.assertIs(T[T,], T)
+        self.assertIs(T[(int,)], int)
+        self.assertEqual(T[int|str,], int|str)
+        self.assertEqual(T[Union[int, str],], Union[int, str])
 
     def test_bad_var_substitution(self):
         T = TypeVar('T')
@@ -470,7 +472,7 @@ def test_bad_var_substitution(self):
         for arg in bad_args:
             with self.subTest(arg=arg):
                 with self.assertRaises(TypeError):
-                    T.__typing_subst__(arg)
+                    T[arg,]
                 with self.assertRaises(TypeError):
                     List[T][arg]
                 with self.assertRaises(TypeError):
@@ -6819,13 +6821,14 @@ class X(Generic[P, P2]):
     def test_var_substitution(self):
         T = TypeVar("T")
         P = ParamSpec("P")
-        subst = P.__typing_subst__
-        self.assertEqual(subst((int, str)), (int, str))
-        self.assertEqual(subst([int, str]), (int, str))
-        self.assertEqual(subst([None]), (type(None),))
-        self.assertIs(subst(...), ...)
-        self.assertIs(subst(P), P)
-        self.assertEqual(subst(Concatenate[int, P]), Concatenate[int, P])
+        self.assertEqual(P.__parameters__, (P,))
+        self.assertIs(P.__parameters__[0], P)
+        self.assertEqual(P[(int, str),], (int, str))
+        self.assertEqual(P[[int, str],], (int, str))
+        self.assertEqual(P[[None],], (type(None),))
+        self.assertIs(P[...,], ...)
+        self.assertIs(P[P,], P)
+        self.assertEqual(P[Concatenate[int, P],], Concatenate[int, P])
 
     def test_bad_var_substitution(self):
         T = TypeVar('T')
@@ -6834,7 +6837,7 @@ def test_bad_var_substitution(self):
         for arg in bad_args:
             with self.subTest(arg=arg):
                 with self.assertRaises(TypeError):
-                    P.__typing_subst__(arg)
+                    P[arg,]
                 with self.assertRaises(TypeError):
                     typing.Callable[P, T][arg, str]
                 with self.assertRaises(TypeError):

Lib/typing.py

@@ -250,13 +250,9 @@ def _collect_parameters(args):
     """
     parameters = []
     for t in args:
-        if hasattr(t, '__typing_subst__'):
-            if t not in parameters:
-                parameters.append(t)
-        else:
-            for x in getattr(t, '__parameters__', ()):
-                if x not in parameters:
-                    parameters.append(x)
+        for x in getattr(t, '__parameters__', ()):
+            if x not in parameters:
+                parameters.append(x)
     return tuple(parameters)
 
 
@@ -954,6 +950,9 @@ def __repr__(self):
             prefix = '~'
         return prefix + self.__name__
 
+    @property
+    def __parameters__(self):
+        return (self,)
 
 class TypeVar(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
               _root=True):
@@ -1014,7 +1013,9 @@ def __init__(self, name, *constraints, bound=None,
         if def_mod != 'typing':
             self.__module__ = def_mod
 
-    def __typing_subst__(self, arg):
+    def __getitem__(self, arg):
+        if isinstance(arg, tuple) and len(arg) == 1:
+            arg, = arg
         msg = "Parameters to generic types must be types."
         arg = _type_check(arg, msg, is_argument=True)
         if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or
@@ -1062,9 +1063,13 @@ def __iter__(self):
     def __repr__(self):
         return self.__name__
 
-    def __typing_subst__(self, arg):
+    def __getitem__(self, arg):
         raise TypeError("Substitution of bare TypeVarTuple is not supported")
 
+    @property
+    def __parameters__(self):
+        return (self,)
+
     def __typing_prepare_subst__(self, alias, args):
         params = alias.__parameters__
         typevartuple_index = params.index(self)
@@ -1212,7 +1217,9 @@ def __init__(self, name, *, bound=None, covariant=False, contravariant=False):
         if def_mod != 'typing':
             self.__module__ = def_mod
 
-    def __typing_subst__(self, arg):
+    def __getitem__(self, arg):
+        if isinstance(arg, tuple) and len(arg) == 1:
+            arg, = arg
         if isinstance(arg, (list, tuple)):
             arg = tuple(_type_check(a, "Expected a type.") for a in arg)
         elif not _is_param_expr(arg):
@@ -1420,21 +1427,17 @@ def _determine_new_args(self, args):
         new_args = []
         for old_arg in self.__args__:
 
-            substfunc = getattr(old_arg, '__typing_subst__', None)
-            if substfunc:
-                new_arg = substfunc(new_arg_by_param[old_arg])
+            subparams = getattr(old_arg, '__parameters__', ())
+            if not subparams:
+                new_arg = old_arg
             else:
-                subparams = getattr(old_arg, '__parameters__', ())
-                if not subparams:
-                    new_arg = old_arg
-                else:
-                    subargs = []
-                    for x in subparams:
-                        if isinstance(x, TypeVarTuple):
-                            subargs.extend(new_arg_by_param[x])
-                        else:
-                            subargs.append(new_arg_by_param[x])
-                    new_arg = old_arg[tuple(subargs)]
+                subargs = []
+                for x in subparams:
+                    if isinstance(x, TypeVarTuple):
+                        subargs.extend(new_arg_by_param[x])
+                    else:
+                        subargs.append(new_arg_by_param[x])
+                new_arg = old_arg[tuple(subargs)]
 
             if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple):
                 # Consider the following `Callable`.

Misc/NEWS.d/next/Library/2021-07-31-16-33-33.bpo-44796.-pyVhM.rst

@@ -0,0 +1,2 @@
+Add ``__parameters__`` and ``__getitem__`` in :class:`~typing.TypeVar` and
+:class:`~ParamSpec`.

Objects/genericaliasobject.c

@@ -218,40 +218,29 @@ _Py_make_parameters(PyObject *args)
     Py_ssize_t iparam = 0;
     for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
         PyObject *t = PyTuple_GET_ITEM(args, iarg);
-        PyObject *subst;
-        if (_PyObject_LookupAttr(t, &_Py_ID(__typing_subst__), &subst) < 0) {
+        PyObject *subparams;
+        if (_PyObject_LookupAttr(t, &_Py_ID(__parameters__),
+                                    &subparams) < 0) {
             Py_DECREF(parameters);
             return NULL;
         }
-        if (subst) {
-            iparam += tuple_add(parameters, iparam, t);
-            Py_DECREF(subst);
-        }
-        else {
-            PyObject *subparams;
-            if (_PyObject_LookupAttr(t, &_Py_ID(__parameters__),
-                                     &subparams) < 0) {
-                Py_DECREF(parameters);
-                return NULL;
-            }
-            if (subparams && PyTuple_Check(subparams)) {
-                Py_ssize_t len2 = PyTuple_GET_SIZE(subparams);
-                Py_ssize_t needed = len2 - 1 - (iarg - iparam);
-                if (needed > 0) {
-                    len += needed;
-                    if (_PyTuple_Resize(&parameters, len) < 0) {
-                        Py_DECREF(subparams);
-                        Py_DECREF(parameters);
-                        return NULL;
-                    }
-                }
-                for (Py_ssize_t j = 0; j < len2; j++) {
-                    PyObject *t2 = PyTuple_GET_ITEM(subparams, j);
-                    iparam += tuple_add(parameters, iparam, t2);
+        if (subparams && PyTuple_Check(subparams)) {
+            Py_ssize_t len2 = PyTuple_GET_SIZE(subparams);
+            Py_ssize_t needed = len2 - 1 - (iarg - iparam);
+            if (needed > 0) {
+                len += needed;
+                if (_PyTuple_Resize(&parameters, len) < 0) {
+                    Py_DECREF(subparams);
+                    Py_DECREF(parameters);
+                    return NULL;
                 }
             }
-            Py_XDECREF(subparams);
+            for (Py_ssize_t j = 0; j < len2; j++) {
+                PyObject *t2 = PyTuple_GET_ITEM(subparams, j);
+                iparam += tuple_add(parameters, iparam, t2);
+            }
         }
+        Py_XDECREF(subparams);
     }
     if (iparam < len) {
         if (_PyTuple_Resize(&parameters, iparam) < 0) {
@@ -460,21 +449,7 @@ _Py_subs_parameters(PyObject *self, PyObject *args, PyObject *parameters, PyObje
             Py_DECREF(item);
             return NULL;
         }
-        PyObject *subst;
-        if (_PyObject_LookupAttr(arg, &_Py_ID(__typing_subst__), &subst) < 0) {
-            Py_DECREF(newargs);
-            Py_DECREF(item);
-            return NULL;
-        }
-        if (subst) {
-            Py_ssize_t iparam = tuple_index(parameters, nparams, arg);
-            assert(iparam >= 0);
-            arg = PyObject_CallOneArg(subst, argitems[iparam]);
-            Py_DECREF(subst);
-        }
-        else {
-            arg = subs_tvars(arg, parameters, argitems, nitems);
-        }
+        arg = subs_tvars(arg, parameters, argitems, nitems);
         if (arg == NULL) {
             Py_DECREF(newargs);
             Py_DECREF(item);