bpo-45292: [PEP 654] Update traceback display code to work with exception groups

Include/traceback.h

@@ -9,6 +9,10 @@ extern "C" {
 PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *);
 PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *);
 
+int PyTraceBack_Print_Indented(PyObject *, int, const char*, PyObject *);
+int _Py_WriteIndentedMargin(int, const char*, PyObject *);
+int _Py_WriteIndent(int, PyObject *);
+
 /* Reveal traceback type so we can typecheck traceback objects */
 PyAPI_DATA(PyTypeObject) PyTraceBack_Type;
 #define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type)

Lib/test/test_traceback.py

@@ -987,6 +987,35 @@ def __eq__(self, other):
             self.assertIn('UnhashableException: ex2', tb[4])
             self.assertIn('UnhashableException: ex1', tb[12])
 
+    def deep_eg(self):
+        e = TypeError(1)
+        for i in range(2000):
+            e = ExceptionGroup('eg', [e])
+        return e
+
+    @cpython_only
+    def test_exception_group_deep_recursion_capi(self):
+        from _testcapi import exception_print
+        LIMIT = 75
+        eg = self.deep_eg()
+        with captured_output("stderr") as stderr_f:
+            with support.infinite_recursion(max_depth=LIMIT):
+                exception_print(eg)
+        output = stderr_f.getvalue()
+        self.assertIn('ExceptionGroup', output)
+        self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
+
+    def test_exception_group_deep_recursion_traceback(self):
+        LIMIT = 75
+        eg = self.deep_eg()
+        with captured_output("stderr") as stderr_f:
+            with support.infinite_recursion(max_depth=LIMIT):
+                traceback.print_exception(type(eg), eg, eg.__traceback__)
+        output = stderr_f.getvalue()
+        self.assertIn('ExceptionGroup', output)
+        self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
+
+
 cause_message = (
     "\nThe above exception was the direct cause "
     "of the following exception:\n\n")
@@ -995,9 +1024,12 @@ def __eq__(self, other):
     "\nDuring handling of the above exception, "
     "another exception occurred:\n\n")
 
-boundaries = re.compile(
-    '(%s|%s)' % (re.escape(cause_message), re.escape(context_message)))
+nested_exception_header_re = r'[\+-]?\+[-{4} ]+[ \d\.?]+[ -{4}]+'
 
+boundaries = re.compile(
+    '(%s|%s|%s)' % (re.escape(cause_message),
+                    re.escape(context_message),
+                    nested_exception_header_re))
 
 class BaseExceptionReportingTests:
 
@@ -1234,6 +1266,158 @@ def __str__(self):
         self.assertEqual(err, f"{str_name}: {str_value}\n")
 
 
+    # #### Exception Groups ####
+
+    def check_exception_group(self, exc_func, expected):
+        report = self.get_report(exc_func)
+        blocks = boundaries.split(report)
+        self.assertEqual(len(blocks), len(expected))
+
+        for i, block in enumerate(blocks):
+            for line in expected[i]:
+                self.assertIn(f"{line}", block)
+                # check indentation
+                self.assertNotIn(f" {line}", block)
+
+        for line in report:
+            # at most one margin char per line
+            self.assertLessEqual(line.count('|'), 1)
+
+    def test_exception_group_basic(self):
+        def exc():
+            raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])
+
+        expected = [
+            ['  |     raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])',
+             '  | ExceptionGroup: eg',
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 1'],
+            ['+---------------- 2 ----------------'],
+            ['    | TypeError: 2'],
+        ]
+
+        self.check_exception_group(exc, expected)
+
+    def test_exception_group_context(self):
+        def exc():
+            try:
+                raise ExceptionGroup("eg1", [ValueError(1), TypeError(2)])
+            except:
+                raise ExceptionGroup("eg2", [ValueError(3), TypeError(4)])
+
+        expected = [
+            ['  |     raise ExceptionGroup("eg1", [ValueError(1), TypeError(2)])',
+             '  | ExceptionGroup: eg1',
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 1'],
+            ['+---------------- 2 ----------------'],
+            ['    | TypeError: 2'],
+            [ context_message ],
+            ['  |     raise ExceptionGroup("eg2", [ValueError(3), TypeError(4)])',
+             '  | ExceptionGroup: eg2',
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 3'],
+            ['+---------------- 2 ----------------'],
+            ['    | TypeError: 4'],
+        ]
+        self.check_exception_group(exc, expected)
+
+    def test_exception_group_context(self):
+        def exc():
+            EG = ExceptionGroup
+            try:
+                raise EG("eg1", [ValueError(1), TypeError(2)])
+            except:
+                raise EG("eg2", [ValueError(3), TypeError(4)])
+
+        expected = [
+            ['  |     raise EG("eg1", [ValueError(1), TypeError(2)])',
+             '  | ExceptionGroup: eg1',
+            ],
+            ['-+---------------- context.1 ----------------'],
+            ['    | ValueError: 1'],
+            ['+---------------- context.2 ----------------'],
+            ['    | TypeError: 2'],
+            [ context_message ],
+            ['  |     raise EG("eg2", [ValueError(3), TypeError(4)])',
+             '  | ExceptionGroup: eg2',
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 3'],
+            ['+---------------- 2 ----------------'],
+            ['    | TypeError: 4'],
+        ]
+        self.check_exception_group(exc, expected)
+
+    def test_exception_group_cause(self):
+        def exc():
+            EG = ExceptionGroup
+            try:
+                raise EG("eg1", [ValueError(1), TypeError(2)])
+            except Exception as e:
+                raise EG("eg2", [ValueError(3), TypeError(4)]) from e
+
+        expected = [
+            ['  |     raise EG("eg1", [ValueError(1), TypeError(2)])',
+             '  | ExceptionGroup: eg1',
+            ],
+            ['-+---------------- cause.1 ----------------'],
+            ['    | ValueError: 1'],
+            ['+---------------- cause.2 ----------------'],
+            ['    | TypeError: 2'],
+            [ cause_message ],
+            ['  |     raise EG("eg2", [ValueError(3), TypeError(4)])',
+             '  | ExceptionGroup: eg2',
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 3'],
+            ['+---------------- 2 ----------------'],
+            ['    | TypeError: 4'],
+        ]
+        self.check_exception_group(exc, expected)
+
+    def test_exception_group_nested(self):
+        def exc():
+            EG = ExceptionGroup
+            VE = ValueError
+            TE = TypeError
+            try:
+                try:
+                    raise EG("nested", [TE(2), TE(3)])
+                except Exception as e:
+                    exc = e
+                raise EG("eg", [VE(1), exc, VE(4)])
+            except:
+                raise EG("top", [VE(5)])
+
+        expected = [
+            ['  |     raise EG("eg", [VE(1), exc, VE(4)])',
+             '  | ExceptionGroup: eg',
+            ],
+            ['-+---------------- context.1 ----------------'],
+            ['    | ValueError: 1'],
+            ['+---------------- context.2 ----------------'],
+            ['    | ExceptionGroup: nested',
+            ],
+            ['-+---------------- context.2.1 ----------------'],
+            ['      | TypeError: 2'],
+            ['+---------------- context.2.2 ----------------'],
+            ['      | TypeError: 3'],
+            ['+---------------- context.3 ----------------'],
+            ['    | ValueError: 4'],
+            [ context_message ],
+            ['  |     raise EG("top", [VE(5)])',
+             '  | ExceptionGroup: top'
+            ],
+            ['-+---------------- 1 ----------------'],
+            ['    | ValueError: 5']
+        ]
+        self.check_exception_group(exc, expected)
+
+
 class PyExcReportingTests(BaseExceptionReportingTests, unittest.TestCase):
     #
     # This checks reporting through the 'traceback' module, with both
@@ -1913,6 +2097,143 @@ def f():
              ''])
 
 
+class TestTracebackException_ExceptionGroups(unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        self.eg_info = self._get_exception_group()
+
+    def _get_exception_group(self):
+        def f():
+            1/0
+
+        def g(v):
+            raise ValueError(v)
+
+        self.lno_f = f.__code__.co_firstlineno
+        self.lno_g = g.__code__.co_firstlineno
+
+        try:
+            try:
+                try:
+                    f()
+                except Exception as e:
+                    exc1 = e
+                try:
+                    g(42)
+                except Exception as e:
+                    exc2 = e
+                raise ExceptionGroup("eg1", [exc1, exc2])
+            except ExceptionGroup as e:
+                exc3 = e
+            try:
+                g(24)
+            except Exception as e:
+                exc4 = e
+            raise ExceptionGroup("eg2", [exc3, exc4])
+        except ExceptionGroup:
+            return sys.exc_info()
+        self.fail('Exception Not Raised')
+
+    def test_exception_group_construction(self):
+        eg_info = self.eg_info
+        teg1 = traceback.TracebackException(*eg_info)
+        teg2 = traceback.TracebackException.from_exception(eg_info[1])
+        self.assertIsNot(teg1, teg2)
+        self.assertEqual(teg1, teg2)
+
+    def test_exception_group_format_exception_only(self):
+        teg = traceback.TracebackException(*self.eg_info)
+        formatted = ''.join(teg.format_exception_only()).split('\n')
+        expected = "ExceptionGroup: eg2\n".split('\n')
+
+        self.assertEqual(formatted, expected)
+
+    def test_exception_group_format(self):
+        teg = traceback.TracebackException(*self.eg_info)
+
+        formatted = ''.join(teg.format()).split('\n')
+        lno_f = self.lno_f
+        lno_g = self.lno_g
+
+        expected = [
+                    f'  | Traceback (most recent call last):',
+                    f'  |   File "{__file__}", line '
+                    f'{lno_g+23}, in _get_exception_group',
+                    f'  |     raise ExceptionGroup("eg2", [exc3, exc4])',
+                    f'  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^',
+                    f'  | ExceptionGroup: eg2',
+                    f'  +-+---------------- 1 ----------------',
+                    f'    | Traceback (most recent call last):',
+                    f'    |   File "{__file__}", '
+                    f'line {lno_g+16}, in _get_exception_group',
+                    f'    |     raise ExceptionGroup("eg1", [exc1, exc2])',
+                    f'    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^',
+                    f'    | ExceptionGroup: eg1',
+                    f'    +-+---------------- 1.1 ----------------',
+                    f'      | Traceback (most recent call last):',
+                    f'      |   File '
+                    f'"{__file__}", line {lno_g+9}, in '
+                    f'_get_exception_group',
+                    f'      |     f()',
+                    f'      |     ^^^',
+                    f'      |   File '
+                    f'"{__file__}", line {lno_f+1}, in '
+                    f'f',
+                    f'      |     1/0',
+                    f'      |     ~^~',
+                    f'      | ZeroDivisionError: division by zero',
+                    f'      +---------------- 1.2 ----------------',
+                    f'      | Traceback (most recent call last):',
+                    f'      |   File '
+                    f'"{__file__}", line {lno_g+13}, in '
+                    f'_get_exception_group',
+                    f'      |     g(42)',
+                    f'      |     ^^^^^',
+                    f'      |   File '
+                    f'"{__file__}", line {lno_g+1}, in '
+                    f'g',
+                    f'      |     raise ValueError(v)',
+                    f'      |     ^^^^^^^^^^^^^^^^^^^',
+                    f'      | ValueError: 42',
+                    f'      +------------------------------------',
+                    f'    +---------------- 2 ----------------',
+                    f'    | Traceback (most recent call last):',
+                    f'    |   File "{__file__}", '
+                    f'line {lno_g+20}, in _get_exception_group',
+                    f'    |     g(24)',
+                    f'    |     ^^^^^',
+                    f'    |   File "{__file__}", '
+                    f'line {lno_g+1}, in g',
+                    f'    |     raise ValueError(v)',
+                    f'    |     ^^^^^^^^^^^^^^^^^^^',
+                    f'    | ValueError: 24',
+                    f'    +------------------------------------',
+                    f'']
+
+        self.assertEqual(formatted, expected)
+
+    def test_comparison(self):
+        try:
+            raise self.eg_info[1]
+        except ExceptionGroup:
+            exc_info = sys.exc_info()
+        for _ in range(5):
+            try:
+                raise exc_info[1]
+            except:
+                exc_info = sys.exc_info()
+        exc = traceback.TracebackException(*exc_info)
+        exc2 = traceback.TracebackException(*exc_info)
+        exc3 = traceback.TracebackException(*exc_info, limit=300)
+        ne = traceback.TracebackException(*exc_info, limit=3)
+        self.assertIsNot(exc, exc2)
+        self.assertEqual(exc, exc2)
+        self.assertEqual(exc, exc3)
+        self.assertNotEqual(exc, ne)
+        self.assertNotEqual(exc, object())
+        self.assertEqual(exc, ALWAYS_EQ)
+
+
 class MiscTest(unittest.TestCase):
 
     def test_all(self):