Add the profiling stuff.

Author: ZeroIntensity

Lib/test/test_asyncgen.py

@@ -611,6 +611,25 @@ def tearDown(self):
         self.loop = None
         asyncio.set_event_loop(None)
 
+    def test_async_gen_asend_exhaustion_args(self):
+        async def gen(bare_return):
+            yield 1
+            if bare_return:
+                return
+
+        async def run():
+            for bare_return in (False, True):
+                with self.subTest(bare_return=bare_return):
+                    g = gen(bare_return)
+                    self.assertEqual(await anext(g), 1)
+                    for _ in range(2):
+                        with self.assertRaises(StopAsyncIteration) as caught:
+                            await g.asend(None)
+                        self.assertEqual(caught.exception.args, ())
+                        self.assertEqual(str(caught.exception), '')
+
+        self.loop.run_until_complete(run())
+
     def check_async_iterator_anext(self, ait_class):
         with self.subTest(anext="pure-Python"):
             self._check_async_iterator_anext(ait_class, py_anext)

Lib/test/test_external_inspection.py

@@ -3692,6 +3692,58 @@ def _sample_frames(
         client_socket.sendall(send_ack)
         return frames
 
+    @skip_if_not_supported
+    @unittest.skipIf(
+        sys.platform == "linux" and not PROCESS_VM_READV_SUPPORTED,
+        "Test only runs on Linux with process_vm_readv support",
+    )
+    def test_generator_throw_from_different_callers(self):
+        script_body = """\
+            class ReadByte(Exception):
+                def __index__(self):
+                    return 1
+
+            class Delegate:
+                def __iter__(self):
+                    return self
+                def __next__(self):
+                    return None
+                # Block in C with the generator as the top Python frame.
+                throw = sock.recv
+
+            def delegating(iterator):
+                yield from iterator
+
+            gen = delegating(delegating(Delegate()))
+            next(gen)
+
+            def first():
+                sock.sendall(b"first")
+                gen.throw(ReadByte())
+
+            def second():
+                sock.sendall(b"second")
+                gen.throw(ReadByte())
+
+            first()
+            second()
+            """
+
+        with self._target_process(script_body) as (p, sock, make_unwinder):
+            unwinder = make_unwinder(cache_frames=True)
+            frames1 = self._sample_frames(
+                sock, unwinder, b"first", b"x", {"delegating", "first"}
+            )
+            frames2 = self._sample_frames(
+                sock, unwinder, b"second", b"x", {"delegating"}
+            )
+
+        self.assertIsNotNone(frames1)
+        self.assertIsNotNone(frames2)
+        names = [frame.funcname for frame in frames2]
+        self.assertIn("second", names)
+        self.assertNotIn("first", names)
+
     @skip_if_not_supported
     @unittest.skipIf(
         sys.platform == "linux" and not PROCESS_VM_READV_SUPPORTED,

Lib/test/test_yield_from_async.py

@@ -783,7 +783,7 @@ async def g(r):
             "f sending spam to g",
             "g received 'spam'",
             "g returning None",
-            "f caught StopAsyncIteration(None)",
+            "f caught StopAsyncIteration()",
             "g starting",
             "f sending spam to g",
             "g received 'spam'",
@@ -1696,6 +1696,18 @@ class TestPEP828Extras(unittest.TestCase):
     parity-checked against ``test_yield_from``.
     """
 
+    @_async_test
+    async def test_delegation_ignores_shadowed_special_methods(self):
+        async def outer(iterator):
+            yield from iterator
+
+        for name in ("__aiter__", "__anext__"):
+            with self.subTest(name=name):
+                iterator = AsAsyncIterator([1, 2])
+                setattr(iterator, name, None)
+                self.assertEqual([item async for item in outer(iterator)],
+                                 [1, 2])
+
     @_async_test
     async def test_custom_iterator_deleted_return_value(self):
         class Iterator:

Objects/genobject.c

@@ -388,7 +388,12 @@ static PyObject *
 gen_set_stop_iteration(PyGenObject *gen, PyObject *result)
 {
     if (PyAsyncGen_CheckExact(gen)) {
-        _PyAsyncGen_SetStopIterationValue(result);
+        if (result == Py_None) {
+            PyErr_SetNone(PyExc_StopAsyncIteration);
+        }
+        else {
+            _PyAsyncGen_SetStopIterationValue(result);
+        }
     }
     else if (result == Py_None) {
         PyErr_SetNone(PyExc_StopIteration);
@@ -684,6 +689,7 @@ _gen_throw(PyGenObject *gen, int close_on_genexit,
                'yield from' or awaiting on with 'await'. */
             ret = _gen_throw((PyGenObject *)yf, close_on_genexit,
                              typ, val, tb);
+            _PyThreadState_UpdateLastProfiledFrame(tstate, frame, prev);
             tstate->current_frame = prev;
             frame->previous = NULL;
         }
@@ -704,6 +710,7 @@ _gen_throw(PyGenObject *gen, int close_on_genexit,
             frame->previous = prev;
             tstate->current_frame = frame;
             ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);
+            _PyThreadState_UpdateLastProfiledFrame(tstate, frame, prev);
             tstate->current_frame = prev;
             frame->previous = NULL;
             Py_DECREF(meth);

Python/codegen.c

@@ -527,7 +527,7 @@ codegen_yield_from_async(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);
+    NEW_JUMP_TARGET_LABEL(c, got_awaitable);
     NEW_JUMP_TARGET_LABEL(c, yield);
     NEW_JUMP_TARGET_LABEL(c, throw);
     NEW_JUMP_TARGET_LABEL(c, athrow);
@@ -538,9 +538,7 @@ codegen_yield_from_async(compiler *c, location loc, expr_ty e)
     VISIT(c, expr, e->v.YieldFrom.value);
     // Stack: [value]
 
-    ADDOP_NAME(c, loc, LOAD_ATTR, &_Py_ID(__aiter__), names);
-    ADDOP(c, loc, PUSH_NULL);
-    ADDOP_I(c, loc, CALL, 0);
+    ADDOP(c, loc, GET_AITER);
     // Stack: [aiterator]
 
     ADDOP_LOAD_CONST(c, loc, Py_None);
@@ -558,19 +556,19 @@ codegen_yield_from_async(compiler *c, location loc, expr_ty e)
     ADDOP_I(c, loc, COPY, 3);
     // Stack: [aiterator, asend_value, method, NULL, asend_value]
     ADDOP_I(c, loc, CALL, 1);
-    ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, got_coroutine);
+    ADDOP_I(c, loc, GET_AWAITABLE, 0);
+    ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, got_awaitable);
 
     USE_LABEL(c, use_anext);
     // Stack: [aiterator, asend_value]
     ADDOP_I(c, loc, COPY, 2);
-    ADDOP_NAME(c, loc, LOAD_ATTR, &_Py_ID(__anext__), names);
-    ADDOP(c, loc, PUSH_NULL);
-    // Stack: [aiterator, asend_value, method, NULL]
-    ADDOP_I(c, loc, CALL, 0);
-    USE_LABEL(c, got_coroutine);
-    // Stack: [aiterator, asend_value, awaitable]
+    ADDOP(c, loc, GET_ANEXT);
+    // Stack: [aiterator, asend_value, aiterator, await_iter]
+    ADDOP_I(c, loc, SWAP, 2);
+    ADDOP(c, loc, POP_TOP);
 
-    ADDOP_I(c, loc, GET_AWAITABLE, 0);
+    USE_LABEL(c, got_awaitable);
+    // Stack: [aiterator, asend_value, await_iter]
     ADDOP(c, loc, PUSH_NULL);
     ADDOP_LOAD_CONST(c, loc, Py_None);
     // Stack: [aiterator, asend_value, await_iter, NULL, None]