3 files changed, 62 insertions, 35 deletions
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
index 0ca7deb..a02b219 100644
--- a/Lib/_collections_abc.py
+++ b/Lib/_collections_abc.py
@@ -75,7 +75,7 @@ class Hashable(metaclass=ABCMeta):
         return NotImplemented
 
 
-class _CoroutineMeta(ABCMeta):
+class _AwaitableMeta(ABCMeta):
 
     def __instancecheck__(cls, instance):
         # 0x80 = CO_COROUTINE
@@ -92,7 +92,26 @@ class _CoroutineMeta(ABCMeta):
         return super().__instancecheck__(instance)
 
 
-class Coroutine(metaclass=_CoroutineMeta):
+class Awaitable(metaclass=_AwaitableMeta):
+
+    __slots__ = ()
+
+    @abstractmethod
+    def __await__(self):
+        yield
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if cls is Awaitable:
+            for B in C.__mro__:
+                if "__await__" in B.__dict__:
+                    if B.__dict__["__await__"]:
+                        return True
+                    break
+        return NotImplemented
+
+
+class Coroutine(Awaitable):
 
     __slots__ = ()
 
@@ -126,27 +145,19 @@ class Coroutine(metaclass=_CoroutineMeta):
         else:
             raise RuntimeError("coroutine ignored GeneratorExit")
 
-
-class Awaitable(metaclass=_CoroutineMeta):
-
-    __slots__ = ()
-
-    @abstractmethod
-    def __await__(self):
-        yield
-
     @classmethod
     def __subclasshook__(cls, C):
-        if cls is Awaitable:
-            for B in C.__mro__:
-                if "__await__" in B.__dict__:
-                    if B.__dict__["__await__"]:
-                        return True
-                    break
+        if cls is Coroutine:
+            mro = C.__mro__
+            for method in ('__await__', 'send', 'throw', 'close'):
+                for base in mro:
+                    if method in base.__dict__:
+                        break
+                else:
+                    return NotImplemented
+            return True
         return NotImplemented
 
-Awaitable.register(Coroutine)
-
 
 class AsyncIterable(metaclass=ABCMeta):
 
diff --git a/Lib/test/test_asyncio/test_pep492.py b/Lib/test/test_asyncio/test_pep492.py
index e25e257..8fc6cba 100644
--- a/Lib/test/test_asyncio/test_pep492.py
+++ b/Lib/test/test_asyncio/test_pep492.py
@@ -97,18 +97,14 @@ class CoroutineTests(BaseTest):
         finally:
             f.close() # silence warning
 
-        class FakeCoro(collections.abc.Coroutine):
+        # Test that asyncio.iscoroutine() uses collections.abc.Coroutine
+        class FakeCoro:
             def send(self, value): pass
             def throw(self, typ, val=None, tb=None): pass
+            def close(self): pass
+            def __await__(self): yield
 
-        fc = FakeCoro()
-        try:
-            self.assertTrue(asyncio.iscoroutine(fc))
-        finally:
-            # To make sure that ABCMeta caches are freed
-            # from FakeCoro ASAP.
-            fc = FakeCoro = None
-            support.gc_collect()
+        self.assertTrue(asyncio.iscoroutine(FakeCoro()))
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index ec86466..dc79b69 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -496,6 +496,8 @@ class TestOneTrickPonyABCs(ABCTestCase):
                 return value
             def throw(self, typ, val=None, tb=None):
                 super().throw(typ, val, tb)
+            def __await__(self):
+                yield
 
         non_samples = [None, int(), gen(), object()]
         for x in non_samples:
@@ -515,13 +517,7 @@ class TestOneTrickPonyABCs(ABCTestCase):
         self.assertIsInstance(c, Awaitable)
         c.close() # awoid RuntimeWarning that coro() was not awaited
 
-        class CoroLike:
-            def send(self, value):
-                pass
-            def throw(self, typ, val=None, tb=None):
-                pass
-            def close(self):
-                pass
+        class CoroLike: pass
         Coroutine.register(CoroLike)
         self.assertTrue(isinstance(CoroLike(), Awaitable))
         self.assertTrue(issubclass(CoroLike, Awaitable))
@@ -548,6 +544,8 @@ class TestOneTrickPonyABCs(ABCTestCase):
                 return value
             def throw(self, typ, val=None, tb=None):
                 super().throw(typ, val, tb)
+            def __await__(self):
+                yield
 
         non_samples = [None, int(), gen(), object(), Bar()]
         for x in non_samples:
@@ -567,6 +565,28 @@ class TestOneTrickPonyABCs(ABCTestCase):
         self.assertIsInstance(c, Coroutine)
         c.close() # awoid RuntimeWarning that coro() was not awaited
 
+        class CoroLike:
+            def send(self, value):
+                pass
+            def throw(self, typ, val=None, tb=None):
+                pass
+            def close(self):
+                pass
+            def __await__(self):
+                pass
+        self.assertTrue(isinstance(CoroLike(), Coroutine))
+        self.assertTrue(issubclass(CoroLike, Coroutine))
+
+        class CoroLike:
+            def send(self, value):
+                pass
+            def close(self):
+                pass
+            def __await__(self):
+                pass
+        self.assertFalse(isinstance(CoroLike(), Coroutine))
+        self.assertFalse(issubclass(CoroLike, Coroutine))
+
     def test_Hashable(self):
         # Check some non-hashables
         non_samples = [bytearray(), list(), set(), dict()]