Allow subclassing of GenericAlias, fix collections.abc.Callable's Gen…

…ericAlias
python · gvanrossum · Dec 13, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020
commit 2c4a297703423a8ffc9680cc633c86ccfaae47b1
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
@@ -8,6 +8,7 @@
 
 from abc import ABCMeta, abstractmethod
 import sys
+import types
 
 GenericAlias = type(list[int])
 
@@ -409,6 +410,65 @@ def __subclasshook__(cls, C):
         return NotImplemented
 
 
+class _CallableGenericAlias(GenericAlias):
+    """ Internal class specifically for consistency between the ``__args__`` of
+    ``collections.abc.Callable``'s and ``typing.Callable``'s ``GenericAlias``.
+
+    See :issue:`42195`.
+    """
+    def __new__(cls, *args, **kwargs):
+        if not isinstance(args, tuple) or len(args) != 2:
+            raise TypeError("Callable must be used as "
+                            "Callable[[arg, ...], result].")
+        _typ, _args = args
+        if not isinstance(_args, tuple) or len(_args) != 2:
+            raise TypeError("Callable must be used as "
+                            "Callable[[arg, ...], result].")
+        t_args, t_result = _args
+        if not isinstance(t_args, list):
+            raise TypeError("Callable must be used as "
+                            "Callable[[arg, ...], result].")
+
+        ga_args = []
+        for arg in args[1]:
+            if isinstance(arg, list):
+                ga_args.extend(arg)
+            else:
+                ga_args.append(arg)
+        return super().__new__(cls, _typ, tuple(ga_args))
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def __repr__(self):
+        t_args = self.__args__[:-1]
+        t_result = self.__args__[-1]
+        return f"{_type_repr(self.__origin__)}" \
+               f"[[{', '.join(_type_repr(a) for a in t_args)}], " \
+               f"{_type_repr(t_result)}]"
+
+
+def _type_repr(obj):
+    """Return the repr() of an object, special-casing types (internal helper).
+
+    If obj is a type, we return a shorter version than the default
+    type.__repr__, based on the module and qualified name, which is
+        typically enough to uniquely identify a type.  For everything
+    else, we fall back on repr(obj).
+
+    Borrowed from :mod:`typing`.
+    """
+    if isinstance(obj, type):
+        if obj.__module__ == 'builtins':
+            return obj.__qualname__
+        return f'{obj.__module__}.{obj.__qualname__}'
+    if obj is ...:
+        return('...')
+    if isinstance(obj, types.FunctionType):
+        return obj.__name__
+    return repr(obj)
+
+
 class Callable(metaclass=ABCMeta):
 
     __slots__ = ()
@@ -423,7 +483,7 @@ def __subclasshook__(cls, C):
             return _check_methods(C, "__call__")
         return NotImplemented
 
-    __class_getitem__ = classmethod(GenericAlias)
+    __class_getitem__ = classmethod(_CallableGenericAlias)
 
 
 ### SETS ###

diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
@@ -302,6 +302,25 @@ def test_weakref(self):
                 alias = t[int]
                 self.assertEqual(ref(alias)(), alias)
 
+    def test_abc_callable(self):
+        alias = Callable[[int, str], float]
+        with self.subTest("Testing collections.abc.Callable's subscription"):
+            self.assertIs(alias.__origin__, Callable)
+            self.assertEqual(alias.__args__, (int, str, float))
+            self.assertEqual(alias.__parameters__, ())
+
+        with self.subTest("Testing collections.abc.Callable's instance checks"):
+            self.assertIsInstance(alias, GenericAlias)
+
+        invalid_params = ('Callable[int]', 'Callable[int, str]')
+        with self.subTest("Testing collections.abc.Callable's parameter "
+                          "validation"):
+            for bad in invalid_params:
+                with self.subTest(f'Testing expression {bad}'):
+                    with self.assertRaises(TypeError):
+                        eval(bad)
+
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c
@@ -567,15 +567,38 @@ static PyGetSetDef ga_properties[] = {
 static PyObject *
 ga_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
+    gaobject *self;
+
+    assert(type != NULL && type->tp_alloc != NULL);
+    self = (gaobject *)type->tp_alloc(type, 0);
+    if (self == NULL)
+        return NULL;
+
     if (!_PyArg_NoKwnames("GenericAlias", kwds)) {
         return NULL;
     }
     if (!_PyArg_CheckPositional("GenericAlias", PyTuple_GET_SIZE(args), 2, 2)) {
         return NULL;
        }
-    PyObject *origin = PyTuple_GET_ITEM(args, 0);
+    PyObject *origin = PyTuple_GET_ITEM(args, 0); 
     PyObject *arguments = PyTuple_GET_ITEM(args, 1);
-    return Py_GenericAlias(origin, arguments);
+
+    // almost the same as Py_GenericAlias' code, but to assign to self
+    if (!PyTuple_Check(arguments)) {
+        arguments = PyTuple_Pack(1, arguments);
+        if (arguments == NULL) {
+            return NULL;
+        }
+    }
+    else {
+        Py_INCREF(arguments);
+    }
+
+    Py_INCREF(origin);
+    self->origin = origin;
+    self->args = arguments;
+    self->parameters = NULL;
+    return (PyObject *) self;
 }
 
 static PyNumberMethods ga_as_number = {
@@ -600,7 +623,7 @@ PyTypeObject Py_GenericAliasType = {
     .tp_hash = ga_hash,
     .tp_call = ga_call,
     .tp_getattro = ga_getattro,
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
     .tp_traverse = ga_traverse,
     .tp_richcompare = ga_richcompare,
     .tp_weaklistoffset = offsetof(gaobject, weakreflist),