GH-105162: Account for `INSTRUMENTED_RESUME` in gen.close/throw. (GH-105187)

Lib/test/test_monitoring.py

@@ -1425,3 +1425,38 @@ class TestUninitialized(unittest.TestCase, MonitoringTestBase):
 
     def test_get_local_events_uninitialized(self):
         self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, self.f.__code__), 0)
+
+class TestRegressions(MonitoringTestBase, unittest.TestCase):
+
+    def test_105162(self):
+        caught = None
+
+        def inner():
+            nonlocal caught
+            try:
+                yield
+            except Exception:
+                caught = "inner"
+                yield
+
+        def outer():
+            nonlocal caught
+            try:
+                yield from inner()
+            except Exception:
+                caught = "outer"
+                yield
+
+        def run():
+            gen = outer()
+            gen.send(None)
+            gen.throw(Exception)
+        run()
+        self.assertEqual(caught, "inner")
+        caught = None
+        try:
+            sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
+            run()
+            self.assertEqual(caught, "inner")
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)

Misc/NEWS.d/next/Core and Builtins/2023-06-01-11-37-03.gh-issue-105162.r8VCXk.rst

@@ -0,0 +1,2 @@
+Fixed bug in generator.close()/throw() where an inner iterator would be
+ignored when the outer iterator was instrumented.

Objects/genobject.c

@@ -331,6 +331,18 @@ gen_close_iter(PyObject *yf)
     return 0;
 }
 
+static inline bool
+is_resume(_Py_CODEUNIT *instr)
+{
+    return instr->op.code == RESUME || instr->op.code == INSTRUMENTED_RESUME;
+}
+
+static inline bool
+is_yield(_Py_CODEUNIT *instr)
+{
+    return instr->op.code == YIELD_VALUE || instr->op.code == INSTRUMENTED_YIELD_VALUE;
+}
+
 PyObject *
 _PyGen_yf(PyGenObject *gen)
 {
@@ -347,7 +359,7 @@ _PyGen_yf(PyGenObject *gen)
             return NULL;
         }
         _Py_CODEUNIT next = frame->prev_instr[1];
-        if (next.op.code != RESUME || next.op.arg < 2)
+        if (!is_resume(&next) || next.op.arg < 2)
         {
             /* Not in a yield from */
             return NULL;
@@ -382,8 +394,8 @@ gen_close(PyGenObject *gen, PyObject *args)
     _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
     /* It is possible for the previous instruction to not be a
      * YIELD_VALUE if the debugger has changed the lineno. */
-    if (err == 0 && frame->prev_instr[0].op.code == YIELD_VALUE) {
+    if (err == 0 && is_yield(frame->prev_instr)) {
-        assert(frame->prev_instr[1].op.code == RESUME);
+        assert(is_resume(frame->prev_instr + 1));
         int exception_handler_depth = frame->prev_instr[0].op.code;
         assert(exception_handler_depth > 0);
         /* We can safely ignore the outermost try block