Fix SEND exhausted path for non-generator iterators; import 5 test suites

Bug fix:
- op_send exhausted: guard gi_return_value read with tp_basicsize > 56.
  Plain iterators (str_iter, list_iter) have smaller objects without
  gi_return_value field. Was crashing on yield-from-string and silently
  returning garbage for some iterator types.
- Export async_gen_asend_type for use by SEND type checks.

New tests (0 skips unless noted):
- test_del.py: 7 tests — del local/list/dict/attribute/multiple
- test_assert.py: 8 tests — assert true/false/message/expression
- test_assignment.py: 28 tests — simple/augmented/subscript/attribute assign
- test_exceptions_extra.py: 17 tests — except clauses, finally, raise/reraise
- test_generators_extra.py: 19 tests — yield, send, yield-from, genexps

Total CPython test suites: 52

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jgarzik

Makefile

@@ -150,6 +150,11 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_unpacking.py
 	@echo "Compiling tests/cpython/test_inheritance.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_inheritance.py
+	@$(PYTHON) -m py_compile tests/cpython/test_del.py
+	@$(PYTHON) -m py_compile tests/cpython/test_assert.py
+	@$(PYTHON) -m py_compile tests/cpython/test_assignment.py
+	@$(PYTHON) -m py_compile tests/cpython/test_exceptions_extra.py
+	@$(PYTHON) -m py_compile tests/cpython/test_generators_extra.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -247,3 +252,13 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_unpacking.cpython-312.pyc
 	@echo "Running CPython test_inheritance.py..."
 	@./apython tests/cpython/__pycache__/test_inheritance.cpython-312.pyc
+	@echo "Running CPython test_del.py..."
+	@./apython tests/cpython/__pycache__/test_del.cpython-312.pyc
+	@echo "Running CPython test_assert.py..."
+	@./apython tests/cpython/__pycache__/test_assert.cpython-312.pyc
+	@echo "Running CPython test_assignment.py..."
+	@./apython tests/cpython/__pycache__/test_assignment.cpython-312.pyc
+	@echo "Running CPython test_exceptions_extra.py..."
+	@./apython tests/cpython/__pycache__/test_exceptions_extra.cpython-312.pyc
+	@echo "Running CPython test_generators_extra.py..."
+	@./apython tests/cpython/__pycache__/test_generators_extra.cpython-312.pyc

src/opcodes_misc.asm

@@ -1863,14 +1863,23 @@ DEF_FUNC op_send, SND_FRAME
     DISPATCH
 
 .send_exhausted:
-    ; Generator exhausted. Push gi_return_value (for yield-from protocol).
-    ; Stack: ... | receiver | → becomes ... | receiver | return_value |
-    ; Then jump to END_SEND which will handle cleanup.
-    mov rdi, [rbp - SND_RECV]  ; receiver = generator
+    ; Receiver exhausted. Push return value (for yield-from protocol).
+    ; Gen/coro/task/awaitable/asend all have gi_return_value at offset +48.
+    ; Guard: only read if receiver's type has tp_basicsize > 56 (enough for +48 field).
+    ; Plain iterators (str_iter, list_iter) have smaller objects → push None.
+    mov rdi, [rbp - SND_RECV]
+    cmp byte [r15 - 1], TAG_PTR
+    jne .send_no_retval
+    test rdi, rdi
+    jz .send_no_retval
+    mov rax, [rdi + PyObject.ob_type]
+    cmp qword [rax + PyTypeObject.tp_basicsize], 56
+    jle .send_no_retval
     mov rax, [rdi + PyGenObject.gi_return_value]
     mov rdx, [rdi + PyGenObject.gi_return_tag]
     test edx, edx
     jnz .send_have_retval
+.send_no_retval:
     ; No return value — push None
     lea rax, [rel none_singleton]
     INCREF rax

src/pyo/generator.asm

@@ -1263,6 +1263,7 @@ async_gen_type:
 ags_name_str: db "async_generator_asend", 0
 
 align 8
+global async_gen_asend_type
 async_gen_asend_type:
     dq 1                        ; ob_refcnt (immortal)
     dq type_type                ; ob_type

tests/cpython/test_assert.py

@@ -0,0 +1,58 @@
+"""Tests for assert statement"""
+
+import unittest
+
+
+class AssertTest(unittest.TestCase):
+
+    def test_assert_true(self):
+        assert True
+        assert 1
+        assert "nonempty"
+        assert [1]
+
+    def test_assert_false(self):
+        with self.assertRaises(AssertionError):
+            assert False
+
+    def test_assert_zero(self):
+        with self.assertRaises(AssertionError):
+            assert 0
+
+    def test_assert_none(self):
+        with self.assertRaises(AssertionError):
+            assert None
+
+    def test_assert_empty(self):
+        with self.assertRaises(AssertionError):
+            assert ""
+        with self.assertRaises(AssertionError):
+            assert []
+        with self.assertRaises(AssertionError):
+            assert {}
+
+    def test_assert_message(self):
+        try:
+            assert False, "custom message"
+        except AssertionError as e:
+            self.assertEqual(str(e), "custom message")
+        else:
+            self.fail("AssertionError not raised")
+
+    def test_assert_expression(self):
+        x = 5
+        assert x > 0
+        assert x < 10
+        assert x == 5
+
+    def test_assert_in_function(self):
+        def check(x):
+            assert x > 0, "must be positive"
+            return x * 2
+        self.assertEqual(check(5), 10)
+        with self.assertRaises(AssertionError):
+            check(-1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_assignment.py

@@ -0,0 +1,173 @@
+"""Tests for various assignment forms"""
+
+import unittest
+
+
+class SimpleAssignTest(unittest.TestCase):
+
+    def test_basic(self):
+        x = 42
+        self.assertEqual(x, 42)
+
+    def test_multiple_targets(self):
+        a = b = c = 10
+        self.assertEqual(a, 10)
+        self.assertEqual(b, 10)
+        self.assertEqual(c, 10)
+
+    def test_tuple_assign(self):
+        a, b = 1, 2
+        self.assertEqual(a, 1)
+        self.assertEqual(b, 2)
+
+    def test_list_assign(self):
+        [a, b, c] = [4, 5, 6]
+        self.assertEqual((a, b, c), (4, 5, 6))
+
+    def test_swap(self):
+        a, b = 1, 2
+        a, b = b, a
+        self.assertEqual(a, 2)
+        self.assertEqual(b, 1)
+
+    def test_chained(self):
+        x = y = z = []
+        x.append(1)
+        self.assertEqual(y, [1])
+        self.assertEqual(z, [1])
+        self.assertIs(x, y)
+
+
+class AugmentedAssignTest(unittest.TestCase):
+
+    def test_iadd(self):
+        x = 10
+        x += 5
+        self.assertEqual(x, 15)
+
+    def test_isub(self):
+        x = 10
+        x -= 3
+        self.assertEqual(x, 7)
+
+    def test_imul(self):
+        x = 4
+        x *= 3
+        self.assertEqual(x, 12)
+
+    def test_ifloordiv(self):
+        x = 10
+        x //= 3
+        self.assertEqual(x, 3)
+
+    def test_imod(self):
+        x = 10
+        x %= 3
+        self.assertEqual(x, 1)
+
+    def test_ipow(self):
+        x = 2
+        x **= 10
+        self.assertEqual(x, 1024)
+
+    def test_iand(self):
+        x = 0xFF
+        x &= 0x0F
+        self.assertEqual(x, 0x0F)
+
+    def test_ior(self):
+        x = 0x0F
+        x |= 0xF0
+        self.assertEqual(x, 0xFF)
+
+    def test_ixor(self):
+        x = 0xFF
+        x ^= 0x0F
+        self.assertEqual(x, 0xF0)
+
+    def test_ilshift(self):
+        x = 1
+        x <<= 10
+        self.assertEqual(x, 1024)
+
+    def test_irshift(self):
+        x = 1024
+        x >>= 10
+        self.assertEqual(x, 1)
+
+    def test_iadd_list(self):
+        x = [1, 2]
+        y = x
+        x += [3, 4]
+        self.assertEqual(x, [1, 2, 3, 4])
+        self.assertIs(x, y)  # list += modifies in place
+
+    def test_iadd_string(self):
+        x = "hello"
+        x += " world"
+        self.assertEqual(x, "hello world")
+
+    def test_imul_list(self):
+        x = [1, 2]
+        x *= 3
+        self.assertEqual(x, [1, 2, 1, 2, 1, 2])
+
+
+class SubscriptAssignTest(unittest.TestCase):
+
+    def test_list_index(self):
+        a = [0, 0, 0]
+        a[0] = 1
+        a[2] = 3
+        self.assertEqual(a, [1, 0, 3])
+
+    def test_list_negative(self):
+        a = [1, 2, 3]
+        a[-1] = 99
+        self.assertEqual(a, [1, 2, 99])
+
+    def test_list_slice(self):
+        a = [1, 2, 3, 4, 5]
+        a[1:3] = [20, 30]
+        self.assertEqual(a, [1, 20, 30, 4, 5])
+
+    def test_dict_assign(self):
+        d = {}
+        d['key'] = 'value'
+        self.assertEqual(d['key'], 'value')
+
+    def test_nested_assign(self):
+        a = [[0, 0], [0, 0]]
+        a[0][1] = 42
+        self.assertEqual(a[0][1], 42)
+
+
+class AttributeAssignTest(unittest.TestCase):
+
+    def test_instance_attr(self):
+        class C:
+            pass
+        obj = C()
+        obj.x = 42
+        self.assertEqual(obj.x, 42)
+
+    def test_overwrite(self):
+        class C:
+            pass
+        obj = C()
+        obj.x = 1
+        obj.x = 2
+        self.assertEqual(obj.x, 2)
+
+    def test_multiple_attrs(self):
+        class C:
+            pass
+        obj = C()
+        obj.a = 1
+        obj.b = 2
+        obj.c = 3
+        self.assertEqual(obj.a + obj.b + obj.c, 6)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_del.py

@@ -0,0 +1,56 @@
+"""Tests for del statement"""
+
+import unittest
+
+
+class DelTest(unittest.TestCase):
+
+    def test_del_local(self):
+        x = 42
+        del x
+        with self.assertRaises(UnboundLocalError):
+            x
+
+    def test_del_list_item(self):
+        a = [1, 2, 3, 4, 5]
+        del a[2]
+        self.assertEqual(a, [1, 2, 4, 5])
+
+    def test_del_list_slice(self):
+        a = [0, 1, 2, 3, 4]
+        del a[1:3]
+        self.assertEqual(a, [0, 3, 4])
+
+    def test_del_dict_item(self):
+        d = {'a': 1, 'b': 2, 'c': 3}
+        del d['b']
+        self.assertEqual(sorted(d.keys()), ['a', 'c'])
+
+    def test_del_attribute(self):
+        class C:
+            pass
+        obj = C()
+        obj.x = 42
+        self.assertEqual(obj.x, 42)
+        del obj.x
+        with self.assertRaises(AttributeError):
+            obj.x
+
+    def test_del_multiple(self):
+        a = 1
+        b = 2
+        c = 3
+        del a, b
+        self.assertEqual(c, 3)
+        with self.assertRaises(UnboundLocalError):
+            a
+
+    def test_del_in_loop(self):
+        lst = list(range(5))
+        while lst:
+            del lst[-1]
+        self.assertEqual(lst, [])
+
+
+if __name__ == "__main__":
+    unittest.main()