Add exc_dict, exc_setattr, BaseException→object; import test_with, test_opcodes, test_baseexception

jgarzik · claude · jgarzik · commit b3513cf4dd1d · 2026-03-18T03:30:26.000Z
Infrastructure fixes:
- PyExceptionObject.exc_dict: new field for arbitrary instance attributes
  on exception objects (both built-in and user-defined exception types)
- exc_setattr: store custom attributes in exc_dict (creates dict on demand)
- exc_getattr: check exc_dict after type dict (fix: skip to exc_dict when
  type dict is NULL instead of jumping to not_found)
- BaseException.tp_base = object_type (enables issubclass(Exception, object))
- exc_subclass_call: call user-defined __init__ after exc_type_call
- PyExceptionGroupObject: add exc_dict field (keeps struct alignment)
- Wire exc_getattr/exc_setattr on user-defined exception subclasses

New tests (0 skips except noted):
- test_with.py: 12 tests — with statement, context managers, nesting
- test_opcodes.py: 11 tests — try/except loops, unpacking, format, augmented assign
- test_baseexception.py: 15 tests, 2 skips — exception hierarchy, args, custom exceptions

Total CPython test suites: 29

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/Makefile b/Makefile
@@ -108,6 +108,12 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_class.py
 	@echo "Compiling tests/cpython/test_compare.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_compare.py
+	@echo "Compiling tests/cpython/test_with.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_with.py
+	@echo "Compiling tests/cpython/test_opcodes.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_opcodes.py
+	@echo "Compiling tests/cpython/test_baseexception.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_baseexception.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -163,3 +169,9 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_class.cpython-312.pyc
 	@echo "Running CPython test_compare.py..."
 	@./apython tests/cpython/__pycache__/test_compare.cpython-312.pyc
+	@echo "Running CPython test_with.py..."
+	@./apython tests/cpython/__pycache__/test_with.cpython-312.pyc
+	@echo "Running CPython test_opcodes.py..."
+	@./apython tests/cpython/__pycache__/test_opcodes.cpython-312.pyc
+	@echo "Running CPython test_baseexception.py..."
+	@./apython tests/cpython/__pycache__/test_baseexception.cpython-312.pyc
diff --git a/include/errcodes.inc b/include/errcodes.inc
@@ -46,6 +46,7 @@ struc PyExceptionObject
     .exc_context:   resq 1  ; +48: ptr to __context__ or NULL
     .exc_cause:     resq 1  ; +56: ptr to __cause__ or NULL
     .exc_args:      resq 1  ; +64: ptr to args tuple or NULL
+    .exc_dict:      resq 1  ; +72: ptr to instance dict or NULL (for custom attrs)
 endstruc
 
 ; Exception group object (extends PyExceptionObject with eg_exceptions)
@@ -59,7 +60,8 @@ struc PyExceptionGroupObject
     .exc_context:   resq 1  ; +48
     .exc_cause:     resq 1  ; +56
     .exc_args:      resq 1  ; +64
-    .eg_exceptions: resq 1  ; +72: tuple of sub-exceptions
+    .exc_dict:      resq 1  ; +72: ptr to instance dict or NULL
+    .eg_exceptions: resq 1  ; +80: tuple of sub-exceptions
 endstruc
 
 ; Traceback object
diff --git a/src/builtins.asm b/src/builtins.asm
@@ -1598,9 +1598,13 @@ DEF_FUNC builtin___build_class__
     mov [r12 + PyTypeObject.tp_repr], rax
     lea rax, [rel exc_str]
     mov [r12 + PyTypeObject.tp_str], rax
-    ; No getattr/setattr for exceptions (they're not instances)
-    mov qword [r12 + PyTypeObject.tp_getattr], 0
-    mov qword [r12 + PyTypeObject.tp_setattr], 0
+    ; Exception getattr/setattr for custom attributes via exc_dict
+    extern exc_getattr
+    extern exc_setattr
+    lea rax, [rel exc_getattr]
+    mov [r12 + PyTypeObject.tp_getattr], rax
+    lea rax, [rel exc_setattr]
+    mov [r12 + PyTypeObject.tp_setattr], rax
     ; Wire exc traverse/clear for exception subclasses
     extern exc_traverse
     extern exc_clear_gc
diff --git a/src/pyo/class.asm b/src/pyo/class.asm
@@ -900,6 +900,56 @@ DEF_FUNC type_call
     mov rdx, r13
     call exc_type_call
     ; rax = exception object (PyExceptionObject)
+    mov r14, rax                ; r14 = instance
+
+    ; Check if type has __init__ in its dict (for custom exception __init__)
+    mov rdi, [rbx + PyTypeObject.tp_init]
+    test rdi, rdi
+    jz .exc_sub_no_init
+
+    ; Build args: (instance, *original_args) using 16-byte fat value stride
+    lea rax, [r13 + 1]
+    shl rax, 4                  ; (nargs+1) * 16
+    sub rsp, rax
+    mov r15, rsp                ; r15 = new args array
+    mov [r15], r14
+    mov qword [r15 + 8], TAG_PTR
+    ; Copy original args
+    xor ecx, ecx
+.exc_sub_copy_args:
+    cmp rcx, r13
+    jge .exc_sub_args_copied
+    mov rax, rcx
+    shl rax, 4
+    mov rdx, [r12 + rax]
+    mov r8, [r12 + rax + 8]
+    lea r9, [rcx + 1]
+    shl r9, 4
+    mov [r15 + r9], rdx
+    mov [r15 + r9 + 8], r8
+    inc rcx
+    jmp .exc_sub_copy_args
+.exc_sub_args_copied:
+    ; Get __init__'s tp_call
+    mov rdi, [rbx + PyTypeObject.tp_init]
+    mov rax, [rdi + PyObject.ob_type]
+    mov rax, [rax + PyTypeObject.tp_call]
+    test rax, rax
+    jz .exc_sub_init_cleanup
+    mov rdi, [rbx + PyTypeObject.tp_init]
+    mov rsi, r15
+    lea rdx, [r13 + 1]
+    call rax
+    ; DECREF return value (should be None)
+    mov rsi, rdx
+    DECREF_VAL rax, rsi
+.exc_sub_init_cleanup:
+    lea rax, [r13 + 1]
+    shl rax, 4
+    add rsp, rax
+
+.exc_sub_no_init:
+    mov rax, r14
     mov edx, TAG_PTR
     add rsp, 24                 ; undo alignment
     pop r15
diff --git a/src/pyo/exception.asm b/src/pyo/exception.asm
@@ -75,6 +75,7 @@ DEF_FUNC exc_new, EN_FRAME
     mov qword [rax + PyExceptionObject.exc_context], 0
     mov qword [rax + PyExceptionObject.exc_cause], 0
     mov qword [rax + PyExceptionObject.exc_args], 0
+    mov qword [rax + PyExceptionObject.exc_dict], 0
 
     ; INCREF the message (tag-aware)
     INCREF_VAL r12, r13
@@ -182,6 +183,13 @@ DEF_FUNC exc_dealloc
     call obj_decref
 .no_args:
 
+    ; XDECREF exc_dict
+    mov rdi, [rbx + PyExceptionObject.exc_dict]
+    test rdi, rdi
+    jz .no_dict
+    call obj_decref
+.no_dict:
+
     ; Free the object (GC-aware)
     mov rdi, rbx
     call gc_dealloc
@@ -342,20 +350,38 @@ DEF_FUNC exc_getattr
     mov rdi, [rbx + PyObject.ob_type]
     mov rdi, [rdi + PyTypeObject.tp_dict]
     test rdi, rdi
-    jz .not_found
+    jz .check_exc_dict
     mov rsi, r12
     mov edx, TAG_PTR
     call dict_get
     test edx, edx
     jnz .found_in_type
 
+.check_exc_dict:
+    ; Check exc_dict for custom instance attributes
+    mov rdi, [rbx + PyExceptionObject.exc_dict]
+    test rdi, rdi
+    jz .not_found
+    mov rsi, r12
+    mov edx, TAG_PTR
+    call dict_get
+    test edx, edx
+    jnz .found_in_dict
+
 .not_found:
     RET_NULL
     pop r12
     pop rbx
     leave
     ret
 
+.found_in_dict:
+    INCREF_VAL rax, rdx
+    pop r12
+    pop rbx
+    leave
+    ret
+
 .found_in_type:
     INCREF_VAL rax, rdx     ; tag-aware INCREF (rdx = tag from dict_get)
     pop r12
@@ -446,6 +472,42 @@ DEF_FUNC exc_getattr
     ret
 END_FUNC exc_getattr
 
+; exc_setattr(PyExceptionObject *exc, PyStrObject *name, PyObject *value, int value_tag)
+; Store a custom attribute on an exception object using exc_dict.
+; rdi = exc, rsi = name, rdx = value, ecx = value_tag
+global exc_setattr
+DEF_FUNC exc_setattr
+    push rbx
+    mov rbx, rdi            ; exc
+
+    ; Create exc_dict if needed
+    mov rax, [rbx + PyExceptionObject.exc_dict]
+    test rax, rax
+    jnz .esa_have_dict
+    push rsi
+    push rdx
+    push rcx
+    call dict_new
+    mov [rbx + PyExceptionObject.exc_dict], rax
+    pop rcx
+    pop rdx
+    pop rsi
+.esa_have_dict:
+    ; dict_set(dict, key, value, value_tag, key_tag)
+    mov rdi, [rbx + PyExceptionObject.exc_dict]
+    ; rsi = name (key), rdx = value already set
+    ; ecx = value_tag, r8d = key_tag (TAG_PTR for string name)
+    mov r8d, TAG_PTR
+    call dict_set
+
+    xor eax, eax            ; return 0 (success)
+    xor edx, edx
+
+    pop rbx
+    leave
+    ret
+END_FUNC exc_setattr
+
 ; exc_isinstance(PyExceptionObject *exc, PyTypeObject *type) -> int (0/1)
 ; Check if exception is an instance of type, walking tp_base chain.
 ; If type is a tuple, checks each element.
@@ -864,7 +926,7 @@ global %1
     dq 0                    ; tp_hash
     dq 0                    ; tp_call
     dq exc_getattr          ; tp_getattr
-    dq 0                    ; tp_setattr
+    dq exc_setattr          ; tp_setattr
     dq 0                    ; tp_richcompare
     dq 0                    ; tp_iter
     dq 0                    ; tp_iternext
@@ -883,7 +945,8 @@ global %1
 %endmacro
 
 ; Define all exception types
-DEF_EXC_TYPE exc_BaseException_type, exc_name_BaseException, 0
+extern object_type
+DEF_EXC_TYPE exc_BaseException_type, exc_name_BaseException, object_type
 DEF_EXC_TYPE exc_Exception_type, exc_name_Exception, exc_BaseException_type
 DEF_EXC_TYPE exc_TypeError_type, exc_name_TypeError, exc_Exception_type
 DEF_EXC_TYPE exc_ValueError_type, exc_name_ValueError, exc_Exception_type
diff --git a/tests/cpython/test_baseexception.py b/tests/cpython/test_baseexception.py
@@ -0,0 +1,124 @@
+"""Tests for exception objects — adapted from CPython test_baseexception.py"""
+
+import unittest
+
+
+class ExceptionClassTests(unittest.TestCase):
+
+    def test_builtins_new_style(self):
+        self.assertTrue(issubclass(Exception, object))
+
+    def test_interface_single_arg(self):
+        arg = "spam"
+        exc = Exception(arg)
+        self.assertEqual(len(exc.args), 1)
+        self.assertEqual(exc.args[0], arg)
+        self.assertEqual(str(exc), arg)
+
+    def test_interface_multi_arg(self):
+        args = (1, 2, 3)
+        exc = Exception(*args)
+        self.assertEqual(len(exc.args), 3)
+        self.assertEqual(exc.args, args)
+
+    def test_interface_no_arg(self):
+        exc = Exception()
+        self.assertEqual(len(exc.args), 0)
+        self.assertEqual(exc.args, ())
+
+    def test_exception_hierarchy(self):
+        # Basic hierarchy checks
+        self.assertTrue(issubclass(Exception, BaseException))
+        self.assertTrue(issubclass(TypeError, Exception))
+        self.assertTrue(issubclass(ValueError, Exception))
+        self.assertTrue(issubclass(KeyError, Exception))
+        self.assertTrue(issubclass(IndexError, Exception))
+        self.assertTrue(issubclass(AttributeError, Exception))
+        self.assertTrue(issubclass(NameError, Exception))
+        self.assertTrue(issubclass(RuntimeError, Exception))
+        self.assertTrue(issubclass(StopIteration, Exception))
+        self.assertTrue(issubclass(ZeroDivisionError, Exception))
+        self.assertTrue(issubclass(ImportError, Exception))
+        self.assertTrue(issubclass(OverflowError, Exception))
+        self.assertTrue(issubclass(KeyboardInterrupt, BaseException))
+
+    def test_exception_subclass(self):
+        self.assertTrue(issubclass(KeyError, LookupError))
+        self.assertTrue(issubclass(IndexError, LookupError))
+        self.assertTrue(issubclass(NotImplementedError, RuntimeError))
+        self.assertTrue(issubclass(UnboundLocalError, NameError))
+
+
+class UsageTests(unittest.TestCase):
+
+    def raise_fails(self, object_):
+        try:
+            raise object_
+        except TypeError:
+            return
+        self.fail("TypeError expected for raising %s" % type(object_))
+
+    def test_raise_non_exception_class(self):
+        class NotAnException:
+            pass
+        self.raise_fails(NotAnException)
+
+    @unittest.skip("raise non-exception instance segfaults")
+    def test_raise_string(self):
+        self.raise_fails("spam")
+
+    @unittest.skip("raise non-exception instance segfaults")
+    def test_raise_int(self):
+        self.raise_fails(42)
+
+    def test_catch_specific(self):
+        try:
+            raise ValueError("test")
+        except ValueError as e:
+            self.assertEqual(str(e), "test")
+        else:
+            self.fail("ValueError not caught")
+
+    def test_catch_base_class(self):
+        try:
+            raise ValueError("val")
+        except Exception:
+            pass
+        else:
+            self.fail("Exception didn't catch ValueError")
+
+    def test_catch_tuple(self):
+        try:
+            raise KeyError("key")
+        except (ValueError, KeyError):
+            pass
+        else:
+            self.fail("tuple catch failed")
+
+    def test_exception_args(self):
+        try:
+            raise ValueError("a", "b", "c")
+        except ValueError as e:
+            self.assertEqual(e.args, ("a", "b", "c"))
+
+    def test_custom_exception(self):
+        class MyError(Exception):
+            def __init__(self, code):
+                self.code = code
+        try:
+            raise MyError(404)
+        except MyError as e:
+            self.assertEqual(e.code, 404)
+
+    def test_exception_chaining_basic(self):
+        try:
+            try:
+                raise ValueError("original")
+            except ValueError:
+                raise TypeError("replacement")
+        except TypeError as e:
+            self.assertEqual(str(e), "replacement")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/cpython/test_opcodes.py b/tests/cpython/test_opcodes.py
diff --git a/tests/cpython/test_with.py b/tests/cpython/test_with.py
