Fix use of asend() instead of __anext__() for None values.

Author: ZeroIntensity

Lib/test/test_async_yield_from.py

@@ -976,23 +976,23 @@ async def two():
             self.assertEqual(res, [0, 1, 2, 3])
             raise
 
-    # @_async_test
-    # async def test_delegating_generators_claim_to_be_running_with_aclose(self):
-    #     # Check with close
-    #     class MyIt:
-    #         def __aiter__(self):
-    #             return self
-    #         async def __anext__(self):
-    #             return 42
-    #         async def aclose(self_):
-    #             self.assertTrue(g1.gi_running)
-    #             with self.assertRaises(RuntimeError):
-    #                 await anext(g1)
-    #     async def one():
-    #         async yield from MyIt()
-    #     g1 = one()
-    #     await anext(g1)
-    #     await g1.aclose()
+    @_async_test
+    async def test_delegating_generators_claim_to_be_running_with_aclose(self):
+        # Check with close
+        class MyIt:
+            def __aiter__(self):
+                return self
+            async def __anext__(self):
+                return 42
+            async def aclose(self_):
+                self.assertTrue(g1.gi_running)
+                with self.assertRaises(RuntimeError):
+                    await anext(g1)
+        async def one():
+            async yield from MyIt()
+        g1 = one()
+        await anext(g1)
+        await g1.aclose()
 
     @_async_test
     async def test_delegator_is_visible_to_debugger(self):
@@ -1016,20 +1016,20 @@ async def eggs(g):
         async for stack in spam(eggs(gen())):
             self.assertTrue('spam' in stack and 'eggs' in stack)
 
-    # @_async_test
-    # async def test_custom_iterator_return(self):
-    #     # See issue #15568
-    #     class MyIter:
-    #         def __aiter__(self):
-    #             return self
-    #         async def __anext__(self):
-    #             raise StopAsyncIteration(42)
-    #     async def gen():
-    #         nonlocal ret
-    #         ret = async yield from MyIter()
-    #     ret = None
-    #     [e async for e in gen()]
-    #     self.assertEqual(ret, 42)
+    @_async_test
+    async def test_custom_iterator_return(self):
+        # See issue #15568
+        class MyIter:
+            def __aiter__(self):
+                return self
+            async def __anext__(self):
+                raise StopAsyncIteration(42)
+        async def gen():
+            nonlocal ret
+            ret = async yield from MyIter()
+        ret = None
+        [e async for e in gen()]
+        self.assertEqual(ret, 42)
 
     @_async_test
     async def test_close_with_cleared_frame(self):

Python/codegen.c

@@ -515,27 +515,36 @@ codegen_async_yield_from(compiler *c, location loc, expr_ty e)
 {
     NEW_JUMP_TARGET_LABEL(c, send);
     NEW_JUMP_TARGET_LABEL(c, exit);
-
+    NEW_JUMP_TARGET_LABEL(c, use_anext);
+    NEW_JUMP_TARGET_LABEL(c, got_coroutine);
 
     // ADDOP_NAME(c, loc, LOAD_ATTR, &_Py_ID(__aiter__), names);
     // ADDOP(c, loc, PUSH_NULL);
     // ADDOP_I(c, loc, CALL, 0);
     VISIT(c, expr, e->v.AsyncYieldFrom.value);
     // Stack: [value]
 
-    // Call value.__aiter__()
     ADDOP_NAME(c, loc, LOAD_ATTR, &_Py_ID(__aiter__), names);
     ADDOP(c, loc, PUSH_NULL);
     ADDOP_I(c, loc, CALL, 0);
+    // Stack: [aiterator]
 
     ADDOP_LOAD_CONST(c, loc, Py_None);
     // Stack: [aiterator, None]
 
     USE_LABEL(c, send);
-    // Virtual try/except for the StopIteration; see above.
-    ADDOP_JUMP(c, loc, SETUP_FINALLY, exit);
 
     // Stack: [aiterator, asend_value]
+    ADDOP_I(c, loc, COPY, 1);
+    // Stack: [aiterator, asend_value, asend_value]
+
+    ADDOP_LOAD_CONST(c, loc, Py_None);
+    // Stack: [aiterator, asend_value, asend_value, None]
+
+    ADDOP_I(c, loc, IS_OP, 0);
+    // Stack: [aiterator, asend_value, bool]
+
+    ADDOP_JUMP(c, loc, POP_JUMP_IF_TRUE, use_anext);
 
     ADDOP_I(c, loc, COPY, 2);
     // Stack: [aiterator, asend_value, aiterator]
@@ -555,6 +564,28 @@ codegen_async_yield_from(compiler *c, location loc, expr_ty e)
     ADDOP_I(c, loc, CALL, 1);
     // Stack: [aiterator, coroutine]
 
+    ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, got_coroutine);
+
+    USE_LABEL(c, use_anext);
+    // Stack: [aiterator, asend_value]
+
+    ADDOP(c, loc, POP_TOP);
+    // Stack: [aiterator]
+
+    ADDOP_I(c, loc, COPY, 1);
+    // Stack: [aiterator, aiterator]
+
+    ADDOP_NAME(c, loc, LOAD_ATTR, &_Py_ID(__anext__), names);
+    ADDOP(c, loc, PUSH_NULL);
+    ADDOP_I(c, loc, CALL, 0);
+    // Stack: [aiterator, coroutine]
+
+    USE_LABEL(c, got_coroutine);
+    // Stack: [aiterator, coroutine]
+
+    // Virtual try/except for the StopAsyncIteration
+    ADDOP_JUMP(c, loc, SETUP_FINALLY, exit);
+
     ADDOP(c, loc, PUSH_NULL);
     ADDOP_LOAD_CONST(c, loc, Py_None);
     // Stack: [aiterator, coroutine, NULL, None]
@@ -575,14 +606,13 @@ codegen_async_yield_from(compiler *c, location loc, expr_ty e)
     ADDOP_I(c, loc, YIELD_VALUE, 1);
     // Stack: [aiterator, aiterator, resumed_value]
 
+    ADDOP(c, NO_LOCATION, POP_BLOCK);
+
     ADDOP_I(c, loc, SWAP, 2);
     // Stack: [aiterator, resumed_value, aiterator]
     ADDOP(c, loc, POP_TOP);
     // Stack: [aiterator, resumed_value]
 
-    ADDOP(c, NO_LOCATION, POP_BLOCK);
-    // Stack: [aiterator, resumed_value]
-
     ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send);
 
     USE_LABEL(c, exit);