gvanrossum · Dec 13, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
@@ -426,32 +426,21 @@ class _CallableGenericAlias(GenericAlias):
     __slots__ = ()
 
     def __new__(cls, origin, args):
-        try:
-            return cls.__create_ga(origin, args)
-        except TypeError as exc:
-            if sys.version_info[:2] == (3, 9):
-                import warnings
-                warnings.warn(f'{str(exc)} '
-                              f'(This will raise TypeError in Python 3.10)',
-                              DeprecationWarning)
-                return GenericAlias(origin, args)
-            else:
-                raise exc
+        return cls.__create_ga(origin, args)
 
     @classmethod
     def __create_ga(cls, origin, 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, EllipsisType)):
-            raise TypeError(
-                f"Callable[args, result]: args must be a list or Ellipsis. "
-                f"Got {_type_repr(t_args)} instead.")
-        if t_args is Ellipsis:
-            ga_args = args
-        else:
+        if isinstance(t_args, list):
             ga_args = tuple(t_args) + (t_result,)
+        # This relaxes what t_args can be on purpose to allow things like
+        # PEP 612 ParamSpec.  Responsibility for whether a user is using
+        # Callable[...] properly is deferred to static type checkers.
+        else:
+            ga_args = args
         return super().__new__(cls, origin, ga_args)
 
     def __repr__(self):

diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
@@ -446,14 +446,17 @@ def test_cannot_instantiate(self):
             type(c)()
 
     def test_callable_wrong_forms(self):
-        with self.assertRaises(TypeError):
-            Callable[[...], int]
-        with self.assertRaises(TypeError):
-            Callable[(), int]
-        with self.assertRaises(TypeError):
-            Callable[[()], int]
-        with self.assertRaises(TypeError):
-            Callable[[int, 1], 2]
+        ## These no longer raise TypeError since Callable no longer type checks
+        ## args. That responsiblity is deferred to static type checkers
+        ## to simplify implementation of PEP 612 ParamSpec.
+        # with self.assertRaises(TypeError):
+        #     Callable[[...], int]
+        # with self.assertRaises(TypeError):
+        #     Callable[(), int]
+        # with self.assertRaises(TypeError):
+        #     Callable[[()], int]
+        # with self.assertRaises(TypeError):
+        #     Callable[[int, 1], 2]
         with self.assertRaises(TypeError):
             Callable[int]
 

diff --git a/Lib/typing.py b/Lib/typing.py
@@ -120,6 +120,16 @@
 # namespace, but excluded from __all__ because they might stomp on
 # legitimate imports of those modules.
 
+
+def _type_convert(arg):
+    """For converting None to type(None), and strings to ForwardRef."""
+    if arg is None:
+        return type(None)
+    if isinstance(arg, str):
+        return ForwardRef(arg)
+    return arg
+
+
 def _type_check(arg, msg, is_argument=True):
     """Check that the argument is a type, and return it (internal helper).
 
@@ -136,10 +146,7 @@ def _type_check(arg, msg, is_argument=True):
     if is_argument:
         invalid_generic_forms = invalid_generic_forms + (ClassVar, Final)
 
-    if arg is None:
-        return type(None)
-    if isinstance(arg, str):
-        return ForwardRef(arg)
+    arg = _type_convert(arg)
     if (isinstance(arg, _GenericAlias) and
             arg.__origin__ in invalid_generic_forms):
         raise TypeError(f"{arg} is not valid as type argument")
@@ -900,13 +907,13 @@ def __getitem__(self, params):
             raise TypeError("Callable must be used as "
                             "Callable[[arg, ...], result].")
         args, result = params
-        if args is Ellipsis:
-            params = (Ellipsis, result)
-        else:
-            if not isinstance(args, list):
-                raise TypeError(f"Callable[args, result]: args must be a list."
-                                f" Got {args}")
+        # This relaxes what args can be on purpose to allow things like
+        # PEP 612 ParamSpec.  Responsibility for whether a user is using
+        # Callable[...] properly is deferred to static type checkers.
+        if isinstance(args, list):
             params = (tuple(args), result)
+        else:
+            params = (args, result)
         return self.__getitem_inner__(params)
 
     @_tp_cache
@@ -916,8 +923,9 @@ def __getitem_inner__(self, params):
         result = _type_check(result, msg)
         if args is Ellipsis:
             return self.copy_with((_TypingEllipsis, result))
-        msg = "Callable[[arg, ...], result]: each arg must be a type."
-        args = tuple(_type_check(arg, msg) for arg in args)
+        if not isinstance(args, tuple):
+            args = (args,)
+        args = tuple(_type_convert(arg) for arg in args)
         params = args + (result,)
         return self.copy_with(params)
 

diff --git a/Misc/NEWS.d/next/Core and Builtins/2020-11-20-00-57-47.bpo-42195.HeqcpS.rst b/Misc/NEWS.d/next/Core and Builtins/2020-11-20-00-57-47.bpo-42195.HeqcpS.rst
@@ -5,5 +5,7 @@ for :class:`collections.abc.Callable` are now flattened while
 :class:`types.GenericAlias` can now be subclassed and 
 ``collections.abc.Callable``'s ``__class_getitem__`` will now return a subclass
 of ``types.GenericAlias``.  Tests for typing were also updated to not subclass 
-things like ``Callable[..., T]`` as that is not a valid base class.  Patch by Ken Jin.  
+things like ``Callable[..., T]`` as that is not a valid base class.  Finally,
+both ``Callable``s no longer validate their ``argtypes``, in 
+``Callable[[argtypes], resulttype]`` to prepare for :pep:`612`.  Patch by Ken Jin.  
 
diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c
@@ -569,9 +569,6 @@ static PyGetSetDef ga_properties[] = {
  */
 static inline int
 setup_ga(gaobject *alias, PyObject *origin, PyObject *args) {
-    if (alias == NULL) {
-        return 0;
-    }
     if (!PyTuple_Check(args)) {
         args = PyTuple_Pack(1, args);
         if (args == NULL) {
@@ -593,7 +590,6 @@ setup_ga(gaobject *alias, PyObject *origin, PyObject *args) {
 static PyObject *
 ga_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-    assert(type != NULL && type->tp_alloc != NULL);
     if (!_PyArg_NoKeywords("GenericAlias", kwds)) {
         return NULL;
     }
@@ -607,7 +603,7 @@ ga_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
     if (!setup_ga(self, origin, arguments)) {
-        type->tp_free(self);
+        type->tp_free((PyObject *)self);
         return NULL;
     }
     return (PyObject *)self;
@@ -655,7 +651,7 @@ Py_GenericAlias(PyObject *origin, PyObject *args)
         return NULL;
     }
     if (!setup_ga(alias, origin, args)) {
-        PyObject_GC_Del(alias);
+        PyObject_GC_Del((PyObject *)alias);
         return NULL;
     }
     _PyObject_GC_TRACK(alias);