gh-135736: Report suppressed sibling errors for all base errors, not just GeneratorExit

Per review feedback from kumaraditya303: the exception-handler reporting
of suppressed sibling-task errors was previously gated on
isinstance(self._base_error, GeneratorExit), but any base error
(SystemExit, KeyboardInterrupt, etc.) causes the same silent discarding
of collected task errors. Broaden the reporting to run whenever
self._base_error is set, and add a regression test covering a
non-GeneratorExit base error.

Author: sreehariannam

Lib/asyncio/taskgroups.py

@@ -140,21 +140,18 @@ async def _aexit(self, et, exc):
         assert not self._tasks
 
         if self._base_error is not None:
-            if isinstance(self._base_error, GeneratorExit):
-                # Unlike SystemExit/KeyboardInterrupt, GeneratorExit can
-                # only reach here via the "async with" body itself being
-                # closed (e.g. an enclosing async generator's aclose()),
-                # not via a child task, so any collected task errors are
-                # about to be discarded silently.  Report them instead of
-                # losing them.  See gh-135736.
-                for suppressed_exc in self._errors:
-                    self._loop.call_exception_handler({
-                        'message': 'TaskGroup task exception was not '
-                                   'propagated because the TaskGroup body '
-                                   'is being closed via GeneratorExit',
-                        'exception': suppressed_exc,
-                        'task_group': self,
-                    })
+            # self._base_error (e.g. SystemExit, KeyboardInterrupt, or
+            # GeneratorExit) is about to propagate out of this method,
+            # which discards any other collected task errors silently.
+            # Report them instead of losing them.  See gh-135736.
+            for suppressed_exc in self._errors:
+                self._loop.call_exception_handler({
+                    'message': 'TaskGroup task exception was not '
+                               'propagated because the TaskGroup body '
+                               'is being closed with a BaseException',
+                    'exception': suppressed_exc,
+                    'task_group': self,
+                })
             try:
                 raise self._base_error
             finally:

Lib/test/test_asyncio/test_taskgroups.py

@@ -689,6 +689,37 @@ async def runner():
 
         self.assertEqual(get_error_types(cm.exception), {GeneratorExit})
 
+    async def test_taskgroup_20f(self):
+        # See gh-135736: a *non*-GeneratorExit base error (here MyBaseExc,
+        # standing in for SystemExit/KeyboardInterrupt) must also report a
+        # sibling task's suppressed exception via the loop's exception
+        # handler, the same as the GeneratorExit case in
+        # test_taskgroup_20c, instead of discarding it silently.
+        async def crash_soon():
+            await asyncio.sleep(0.1)
+            1 / 0
+
+        async def nested():
+            try:
+                await asyncio.sleep(10)
+            finally:
+                raise MyBaseExc
+
+        async def runner():
+            async with taskgroups.TaskGroup() as g:
+                g.create_task(crash_soon())
+                await nested()
+
+        contexts = []
+        loop = asyncio.get_running_loop()
+        loop.set_exception_handler(lambda loop, context: contexts.append(context))
+
+        with self.assertRaises(MyBaseExc):
+            await runner()
+
+        self.assertEqual(len(contexts), 1)
+        self.assertIsInstance(contexts[0]['exception'], ZeroDivisionError)
+
     async def _test_taskgroup_21(self):
         # This test doesn't work as asyncio, currently, doesn't
         # correctly propagate KeyboardInterrupt (or SystemExit) --

Misc/NEWS.d/next/Library/2026-07-23-12-27-52.gh-issue-135736.hkuGvu.rst

@@ -1,5 +1,8 @@
 Fix :class:`asyncio.TaskGroup` raising a spurious :exc:`ExceptionGroup` instead
 of propagating :exc:`GeneratorExit` directly when the ``async with`` block is
 exited via an enclosing async generator's :meth:`~agen.aclose`. Errors from
-sibling tasks that would otherwise be silently discarded in this case are now
-reported via :meth:`loop.call_exception_handler() <asyncio.loop.call_exception_handler>`.
+sibling tasks that would otherwise be silently discarded whenever the
+``async with`` block exits with *any* :ref:`base exception <bltin-exceptions>`
+(:exc:`GeneratorExit`, :exc:`KeyboardInterrupt`, :exc:`SystemExit`, etc.), not
+just :exc:`GeneratorExit`, are now reported via
+:meth:`loop.call_exception_handler() <asyncio.loop.call_exception_handler>`.