more reviews; fix some docstrings, clean up code, cast list to tuple …

…by default
python · gvanrossum · Dec 24, 2020 · Dec 8, 2020 · Dec 8, 2020 · Dec 9, 2020
commit fa06838ce83cf72aecc1db5e3fb4fe59f3925b70
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
@@ -472,8 +472,8 @@ def __getitem__(self, item):
 
 
 def _has_special_args(obj):
-    """Checks if obj matches either ``...``, 'ParamSpec' or
-    '_ConcatenateGenericAlias' from typing.py
+    """Checks if obj matches either ``...``, ``ParamSpec`` or
+    ``_ConcatenateGenericAlias`` from typing.py
     """
     if obj is Ellipsis:
         return True

diff --git a/Lib/typing.py b/Lib/typing.py
@@ -736,10 +736,10 @@ class ParamSpec(_Final, _Immutable, _TypeVarLike, _root=True):
     Parameter specification variables exist primarily for the benefit of static
     type checkers.  They are used to forward the parameter types of one
     Callable to another Callable, a pattern commonly found in higher order
-    functions and decorators.  They are only valid as the first argument to
-    Callable, or as parameters for user-defined Generics.  See class Generic
-    for more information on generic types.  An example for annotating a
-    decorator::
+    functions and decorators.  They are only valid when used in Concatenate, or
+    as the first argument to Callable, or as parameters for user-defined Generics.
+    See class Generic for more information on generic types.  An example for
+    annotating a decorator::
 
        T = TypeVar('T')
        P = ParamSpec('P')
@@ -904,7 +904,7 @@ def __getitem__(self, params):
         subst = dict(zip(self.__parameters__, params))
         new_args = []
         for arg in self.__args__:
-            if isinstance(arg, (TypeVar, ParamSpec)):
+            if isinstance(arg, _TypeVarLike):
                 arg = subst[arg]
             elif isinstance(arg, (_GenericAlias, GenericAlias)):
                 subparams = arg.__parameters__
@@ -1150,7 +1150,7 @@ def __class_getitem__(cls, 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):
+            if not all(isinstance(p, _TypeVarLike) for p in params):
                 raise TypeError(
                     f"Parameters to {cls.__name__}[...] must all be type variables "
                     f"or parameter specification variables.")
@@ -1159,7 +1159,6 @@ def __class_getitem__(cls, params):
                     f"Parameters to {cls.__name__}[...] must all be unique")
         else:
             # Subscripting a regular Generic subclass.
-
             if any(isinstance(t, ParamSpec) for t in cls.__parameters__):
                 params = _prepare_paramspec_params(cls, params)
             _check_generic(cls, params, len(cls.__parameters__))

diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c
@@ -160,17 +160,20 @@ ga_repr(PyObject *self)
 *  If any one of the names are found, return 1, else 0.
 **/
 static inline int
-is_typing_names(PyObject *obj, int num, ...)
+is_typing_name(PyObject *obj, int num, ...)
 {
     va_list names;
     va_start(names, num);
 
     PyTypeObject *type = Py_TYPE(obj);
-    int cmp = 1;
-    for (int i = 0; i < num && cmp != 0; ++i) {
-        cmp &= strcmp(type->tp_name, va_arg(names, const char *));
+    int hit = 0;
+    for (int i = 0; i < num; ++i) {
+        if (!strcmp(type->tp_name, va_arg(names, const char *))) {
+            hit = 1;
+            break;
+        }
     }
-    if (cmp != 0) {
+    if (!hit) {
         return 0;
     }
     PyObject *module = PyObject_GetAttrString((PyObject *)type, "__module__");
@@ -190,13 +193,13 @@ is_typing_names(PyObject *obj, int num, ...)
 static inline int
 is_typevarlike(PyObject *obj)
 {
-    return is_typing_names(obj, 2, "TypeVar", "ParamSpec");
+    return is_typing_name(obj, 2, "TypeVar", "ParamSpec");
 }
 
 static inline int
 is_paramspec(PyObject *obj)
 {
-    return is_typing_names(obj, 1, "ParamSpec");
+    return is_typing_name(obj, 1, "ParamSpec");
 }
 
 // Index of item in self[:len], or -1 if not found (self is a tuple)
@@ -302,17 +305,17 @@ subs_tvars(PyObject *obj, PyObject *params, PyObject **argitems)
             PyObject *subst = arg;
             Py_ssize_t iparam = tuple_index(params, nparams, arg);
             if (iparam >= 0) {
-                subst = argitems[iparam];
+                arg = argitems[iparam];
             }
             // convert all the lists inside args to tuples to help
-            // with caching in other libaries if substituting a ParamSpec
-            if (PyList_CheckExact(subst) && is_paramspec(arg)) {
-                subst = PyList_AsTuple(subst);
+            // with caching in other libaries
+            if (PyList_CheckExact(arg)) {
+                arg = PyList_AsTuple(arg);
             }
             else {
-                Py_INCREF(subst);
+                Py_INCREF(arg);
             }
-            PyTuple_SET_ITEM(subargs, i, subst);
+            PyTuple_SET_ITEM(subargs, i, arg);
         }
 
         obj = PyObject_GetItem(obj, subargs);
@@ -374,7 +377,6 @@ ga_getitem(PyObject *self, PyObject *item)
     for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
         PyObject *arg = PyTuple_GET_ITEM(alias->args, iarg);
         int typevar = is_typevarlike(arg);
-        int paramspec = is_paramspec(arg);
         if (typevar < 0) {
             Py_DECREF(newargs);
             return NULL;
@@ -383,9 +385,8 @@ ga_getitem(PyObject *self, PyObject *item)
             Py_ssize_t iparam = tuple_index(alias->parameters, nparams, arg);
             assert(iparam >= 0);
             arg = argitems[iparam];
-            // If substituting a ParamSpec, convert lists to tuples to help
-            // with caching in other libaries.
-            if (PyList_CheckExact(arg) && paramspec) {
+            // convert lists to tuples to help with caching in other libaries.
+            if (PyList_CheckExact(arg)) {
                 arg = PyList_AsTuple(arg);
             }
             else {