Address review fully, update news and tests, remove try-except block

gvanrossum · Dec 13, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020
commit c43ebcf9cc51d62a2135934e6dca2920670aee3f
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
@@ -422,29 +422,10 @@ class _CallableGenericAlias(GenericAlias):
     Example: ``Callable[[int, str], float]`` sets ``__args__`` to
     ``(int, str, float)``.
     """
+
     __slots__ = ()
-    def __new__(cls, origin, args):
-        try:
-            return cls.__getitem_type(origin, args)
-        except TypeError:
-            # Fail-safe: most builtin generic collections don't validate the
-            # arguments passed to types.GenericAlias anyways.
-            # This is also because a subclass of the typing.Callable generic
-            # will have an __mro__ (<class 'MyCallable'>,
-            # <class 'collections.abc.Callable'>, <class 'typing.Generic'>,
-            # <class 'object'>). Subclasses wil use the __class_getitem__ of
-            # collections.abc.Callable before typing.Generic. As a result,
-            # we need to fall back on this to allow things like::
-            #
-            # T = TypeVar('T')
-            # class C1(typing.Callable[[T], T]): ...
-            # C1[int]
-            #
-            # Otherwise that will raise a TypeError.
-            return GenericAlias(origin, args)
 
-    @classmethod
-    def __getitem_type(cls, origin, args):
+    def __new__(cls, origin, args):
         if not isinstance(args, tuple) or len(args) != 2:
             raise TypeError(
                 "Callable must be used as Callable[[arg, ...], result]")

diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
@@ -302,6 +302,8 @@ def test_weakref(self):
                 self.assertEqual(ref(alias)(), alias)
 
     def test_abc_callable(self):
+        # A separate test is needed for Callable since it uses a subclass of
+        # GenericAlias.
         alias = Callable[[int, str], float]
         with self.subTest("Testing subscription"):
             self.assertIs(alias.__origin__, Callable)
@@ -323,9 +325,19 @@ def test_abc_callable(self):
 
         with self.subTest("Testing TypeVar substitution"):
             C1 = Callable[[int, T], T]
-            self.assertEqual(C1[str], Callable[[int, str], str])
             C2 = Callable[[K, T], V]
+            C3 = Callable[..., T]
+            self.assertEqual(C1[str], Callable[[int, str], str])
             self.assertEqual(C2[int, float, str], Callable[[int, float], str])
+            self.assertEqual(C3[int], Callable[..., int])
+
+        with self.subTest("Testing type erasure"):
+            class C1(Callable):
+                def __call__(self):
+                    return None
+            a = C1[[int], T]
+            self.assertIs(a().__class__, C1)
+            self.assertEqual(a().__orig_class__, C1[[int], T])
 
         # bpo-42195
         with self.subTest("Testing collections.abc.Callable's consistency "

diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
@@ -1802,10 +1802,9 @@ def barfoo2(x: CT): ...
     def test_extended_generic_rules_subclassing(self):
         class T1(Tuple[T, KT]): ...
         class T2(Tuple[T, ...]): ...
-        class C1(Callable[[T], T]): ...
-        class C2(Callable[..., int]):
-            def __call__(self):
-                return None
+        class C1(typing.Container[T]):
+            def __contains__(self, item):
+                return False
 
         self.assertEqual(T1.__parameters__, (T, KT))
         self.assertEqual(T1[int, str].__args__, (int, str))
@@ -1819,10 +1818,9 @@ def __call__(self):
         ##     T2[int, str]
 
         self.assertEqual(repr(C1[int]).split('.')[-1], 'C1[int]')
-        self.assertEqual(C2.__parameters__, ())
-        self.assertIsInstance(C2(), collections.abc.Callable)
-        self.assertIsSubclass(C2, collections.abc.Callable)
-        self.assertIsSubclass(C1, collections.abc.Callable)
+        self.assertEqual(C1.__parameters__, (T,))
+        self.assertIsInstance(C1(), collections.abc.Container)
+        self.assertIsSubclass(C1, collections.abc.Container)
         self.assertIsInstance(T1(), tuple)
         self.assertIsSubclass(T2, tuple)
         with self.assertRaises(TypeError):
@@ -1856,10 +1854,11 @@ def test_type_erasure_special(self):
         class MyTup(Tuple[T, T]): ...
         self.assertIs(MyTup[int]().__class__, MyTup)
         self.assertEqual(MyTup[int]().__orig_class__, MyTup[int])
-        class MyCall(Callable[..., T]):
-            def __call__(self): return None
-        self.assertIs(MyCall[T]().__class__, MyCall)
-        self.assertEqual(MyCall[T]().__orig_class__, MyCall[T])
+        # This isn't valid as Callable isn't a valid base class.
+        ## class MyCall(Callable[..., T]):
+        ##     def __call__(self): return None
+        ## self.assertIs(MyCall[T]().__class__, MyCall)
+        ## self.assertEqual(MyCall[T]().__orig_class__, MyCall[T])
         class MyDict(typing.Dict[T, T]): ...
         self.assertIs(MyDict[int]().__class__, MyDict)
         self.assertEqual(MyDict[int]().__orig_class__, MyDict[int])

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
@@ -2,5 +2,8 @@ The ``__args__`` of the parameterized generics for :data:`typing.Callable`
 and :class:`collections.abc.Callable` are now consistent.  The ``__args__`` 
 for :class:`collections.abc.Callable` are now flattened while 
 :data:`typing.Callable`'s have not changed.  To allow this change, 
-:class:`types.GenericAlias` can now be subclassed.  Patch by Ken Jin.  
+: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.