Import CPython test_tuple.py, fix tuple+/*/index and add bugs.md

Import adapted CPython tuple tests (19 tests) and fix bugs:

- Fix tuple+tuple: add sq_concat fallback in BINARY_OP when tp_as_number is NULL
- Fix tuple*=int: add sq_repeat fallback for NB_INPLACE_MULTIPLY
- Fix tuple['x'] segfault: add int_type check before int_to_i64
- Fix tuple.index() ignoring start/stop parameters
- Add bugs.md documenting all 14 bugs found during test import

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

Author: jgarzik

Makefile

@@ -76,6 +76,8 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_augassign.py
 	@echo "Compiling tests/cpython/test_list.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_list.py
+	@echo "Compiling tests/cpython/test_tuple.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_tuple.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -99,3 +101,5 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_augassign.cpython-312.pyc
 	@echo "Running CPython test_list.py..."
 	@./apython tests/cpython/__pycache__/test_list.cpython-312.pyc
+	@echo "Running CPython test_tuple.py..."
+	@./apython tests/cpython/__pycache__/test_tuple.cpython-312.pyc

bugs.md

@@ -0,0 +1,78 @@
+# Bug Log - CPython Container Test Import
+
+## Bugs Found & Fixed
+
+### 1. Negative-step slicelength missing guard (list.asm, tuple.asm)
+**Symptom**: `a[3:3:-2]` causes OOM (allocates huge array)
+**Root cause**: Negative step slicelength formula `(start-stop-1)/abs(step)+1` used unsigned div without checking `start <= stop` first. When start==stop, `start-stop-1 = -1 = 0xFFFFFFFFFFFFFFFF` unsigned.
+**Fix**: Add `jle .empty` guard after `sub rax, r14` in both list and tuple getslice.
+
+### 2. slice_indices start/stop clamping for negative step (slice.asm)
+**Symptom**: `a[100:-100:-1]` segfaults (out-of-bounds read)
+**Root cause**: `start >= length` clamped to `length` for all steps, but negative step needs `length-1`. `stop < 0` after adding length clamped to 0 for all steps, but negative step needs `-1`.
+**Fix**: Conditional clamping based on step sign, matching CPython's PySlice_AdjustIndices.
+
+### 3. slice_indices NONE_SENTINEL collision with sys.maxsize (slice.asm)
+**Symptom**: `a[1::sys.maxsize]` treats step as None (defaults to 1)
+**Root cause**: NONE_SENTINEL = 0x7FFFFFFFFFFFFFFF == sys.maxsize. When step = sys.maxsize, the comparison `cmp rax, NONE_SENTINEL` matched and step was treated as None.
+**Fix**: Check actual payload against `none_singleton` pointer AND tag for `TAG_NONE` or `TAG_PTR` with None, instead of comparing integer values.
+
+### 4. `del a[i]` not decrementing ob_size (list.asm)
+**Symptom**: `del a[1]` on `[0, 1]` gives `[0, ]` (size still 2, second slot cleared)
+**Root cause**: `list_ass_subscript` with value=NULL always called `list_setitem` which replaces the slot with NULL but doesn't remove it or update size.
+**Fix**: Add `.las_int_delete` path that DECREFs old, shifts elements via memmove, decrements `ob_size`.
+
+### 5. `list[string_key]` segfault (list.asm, tuple.asm)
+**Symptom**: `a['x']` segfaults instead of raising TypeError
+**Root cause**: `list_subscript` assumed non-SmallInt, non-slice keys were heap ints and called `int_to_i64` on them, crashing on strings.
+**Fix**: Check `ob_type == int_type` before calling `int_to_i64`; raise TypeError otherwise.
+
+### 6. list.index() ignoring start/stop parameters (methods.asm)
+**Symptom**: `[-2,-1,0,0,1,2].index(0, 3)` returns 2 instead of 3
+**Root cause**: `list_method_index` always searched from index 0 regardless of nargs.
+**Fix**: Check nargs >= 3/4 and extract start/stop from args[2]/args[3] with negative index handling.
+
+### 7. tuple*int dispatch missing (opcodes_misc.asm)
+**Symptom**: `(1,2)*2` raises TypeError
+**Root cause**: BINARY_OP only checked right operand for sq_repeat when left was SmallInt. When left was a sequence (tuple/list) and right was SmallInt, it fell through to tp_as_number which is NULL for tuples.
+**Fix**: Add `.binop_try_left_seq` check in `.binop_not_smallint_left` path.
+
+### 8. tuple+tuple dispatch missing (opcodes_misc.asm)
+**Symptom**: `(1,2) + (3,4)` raises TypeError
+**Root cause**: BINARY_OP for NB_ADD only checked tp_as_number, not tp_as_sequence.sq_concat.
+**Fix**: Add `.binop_try_seq_fallback` that checks sq_concat for ADD and sq_repeat for MULTIPLY when tp_as_number is NULL.
+
+### 9. list_inplace_repeat tag realloc using wrong size (list.asm)
+**Symptom**: `s *= 10` corrupts memory / changes list identity
+**Root cause**: After payload `ap_realloc` (which returns new ptr in rax), the tag realloc used `rax` (the pointer!) as the size instead of the actual new_size from the stack.
+**Fix**: `mov rsi, [rsp]` to load new_size from stack instead of `mov rsi, rax`.
+
+### 10. list_inplace_multiply dispatched to sq_repeat (opcodes_misc.asm)
+**Symptom**: `s *= 10` changed list identity (`id(s)` differed after)
+**Root cause**: NB_INPLACE_MULTIPLY was dispatched to sq_repeat (creates new object) instead of nb_imul/sq_inplace_repeat (mutates in place).
+**Fix**: Remove NB_INPLACE_MULTIPLY from the left-seq sq_repeat dispatch; let it fall through to nb_imul.
+
+### 11. List extended slice self-assignment corruption (list.asm)
+**Symptom**: `a[::-1] = a` gives `[0, 1, 1, 0]` instead of `[3, 2, 1, 0]`
+**Root cause**: Extended slice loop reads from source and writes to target simultaneously; when source == target, writes corrupt subsequent reads.
+**Fix**: Detect self-assignment (`r12 == rbx`), create shallow copy via `list_copy()`, use copy as source. Store copy in LAS_TEMP for cleanup.
+
+### 12. List step-1 slice self-assignment corruption (list.asm)
+**Symptom**: `a[1:] = a` gives `[1, 1, 1, 1, 1, 1]` instead of `[1, 1, 2, 3, 4, 5]`
+**Root cause**: Same as #11 but for the step-1 path. Also: `call list_copy` clobbered `rcx` (old_len).
+**Fix**: Self-assignment detection + `list_copy` + save/restore `rcx` around the call.
+
+### 13. Exhausted list iterator not marked (iter.asm, opcodes_build.asm)
+**Symptom**: `list(exhausted_iter)` picks up newly-appended elements
+**Root cause**: `FOR_ITER_LIST` specialized opcode didn't mark iterators as exhausted (set `it_seq = NULL`) when done. Only the generic `list_iter_next` path did.
+**Fix**: Add `it_seq = NULL` + DECREF in `FOR_ITER_LIST`'s `.fil_exhausted` path. Guard dealloc against NULL `it_seq`.
+
+### 14. tuple.index() ignoring start/stop parameters (methods.asm)
+**Symptom**: Same as #6 but for tuples
+**Fix**: Same pattern as list.index - check nargs, extract start/stop.
+
+## New Infrastructure Added
+- `list_copy()` - standalone shallow copy function
+- `ALWAYS_EQ`, `NEVER_EQ`, `C_RECURSION_LIMIT` in `lib/test/support/__init__.py`
+- `lib/test/seq_tests.py` - adapted base test class
+- `lib/test/list_tests.py` - adapted list test class

src/methods.asm

@@ -6378,20 +6378,66 @@ END_FUNC list_method_reversed
 
 ;; ============================================================================
 ;; tuple_method_index(args, nargs) -> SmallInt index
-;; args[0]=self (tuple), args[1]=value
+;; args[0]=self (tuple), args[1]=value, optional args[2]=start, args[3]=stop
 ;; ============================================================================
-DEF_FUNC tuple_method_index
+DEF_FUNC tuple_method_index, 16
     push rbx
     push r12
     push r13
     push r14
 
+    mov [rbp - 8], rdi      ; save args
+    mov [rbp - 16], rsi     ; save nargs
     mov rbx, [rdi]          ; self (tuple)
     mov r12, [rdi + 16]     ; value to find (payload)
     mov r14d, [rdi + 24]    ; value tag
-    mov r13, [rbx + PyTupleObject.ob_size]
+    mov r13, [rbx + PyTupleObject.ob_size]  ; default stop = size
 
+    xor ecx, ecx            ; default start = 0
+
+    ; Check for optional start arg (nargs >= 3)
+    cmp qword [rbp - 16], 3
+    jl .ti_have_bounds
+    mov rax, [rbp - 8]
+    push rcx
+    mov rdi, [rax + 32]      ; args[2] payload
+    mov edx, [rax + 40]      ; args[2] tag
+    call int_to_i64
+    pop rcx
+    mov rcx, rax
+    ; Handle negative start
+    test rcx, rcx
+    jns .ti_start_pos
+    add rcx, r13
+    test rcx, rcx
+    jns .ti_start_pos
     xor ecx, ecx
+.ti_start_pos:
+
+    ; Check for optional stop arg (nargs >= 4)
+    cmp qword [rbp - 16], 4
+    jl .ti_have_bounds
+    mov rax, [rbp - 8]
+    push rcx
+    mov rdi, [rax + 48]      ; args[3] payload
+    mov edx, [rax + 56]      ; args[3] tag
+    call int_to_i64
+    pop rcx
+    ; Handle negative stop
+    test rax, rax
+    jns .ti_stop_pos
+    add rax, r13
+    test rax, rax
+    jns .ti_stop_pos
+    xor eax, eax
+.ti_stop_pos:
+    cmp rax, r13
+    jle .ti_stop_ok
+    mov rax, r13
+.ti_stop_ok:
+    mov r13, rax            ; r13 = stop
+
+.ti_have_bounds:
 .tindex_loop:
     cmp rcx, r13
     jge .tindex_not_found

src/opcodes_misc.asm

@@ -286,9 +286,14 @@ DEF_FUNC_BARE op_binary_op
     lea rax, [rel int_type]
     jmp .binop_have_type
 .binop_have_type:
+    push rax                   ; save type ptr for sq fallback
     mov rax, [rax + PyTypeObject.tp_as_number]
     test rax, rax
-    jz .binop_try_dunder
+    jnz .binop_have_number
+    pop rax                    ; restore type ptr
+    jmp .binop_try_seq_fallback
+.binop_have_number:
+    add rsp, 8                 ; discard saved type ptr
     jmp .binop_call_method
 
 .use_float_methods:
@@ -394,6 +399,41 @@ DEF_FUNC_BARE op_binary_op
     add rbx, 2
     DISPATCH
 
+.binop_try_seq_fallback:
+    ; rax = type ptr. Check if type has tp_as_sequence for ADD/MUL ops.
+    mov rax, [rax + PyTypeObject.tp_as_sequence]
+    test rax, rax
+    jz .binop_try_dunder
+    ; NB_ADD (0) or NB_INPLACE_ADD (13) → sq_concat / sq_inplace_concat
+    cmp r9d, 0              ; NB_ADD
+    je .binop_seq_concat
+    cmp r9d, 13             ; NB_INPLACE_ADD
+    je .binop_seq_concat
+    ; NB_MULTIPLY (5) or NB_INPLACE_MULTIPLY (18) → sq_repeat
+    cmp r9d, 5
+    je .binop_seq_repeat_left
+    cmp r9d, 18             ; NB_INPLACE_MULTIPLY
+    je .binop_seq_repeat_left
+    jmp .binop_try_dunder
+
+.binop_seq_concat:
+    mov rax, [rax + PySequenceMethods.sq_concat]
+    test rax, rax
+    jz .binop_try_dunder
+    ; sq_concat(left, right): rdi=left, rsi=right already set
+    call rax
+    jmp .binop_have_result
+
+.binop_seq_repeat_left:
+    mov rax, [rax + PySequenceMethods.sq_repeat]
+    test rax, rax
+    jz .binop_try_dunder
+    ; sq_repeat(left=sequence, right=count)
+    mov edx, [rsp + BO_RTAG]
+    mov ecx, edx
+    call rax
+    jmp .binop_have_result
+
 .binop_try_dunder:
     ; Try dunder method on heaptype objects
     extern binop_dunder_table

src/pyo/tuple.asm

@@ -168,6 +168,10 @@ DEF_FUNC tuple_subscript
     lea rcx, [rel slice_type]
     cmp rax, rcx
     je .ts_slice
+    ; Check if key is actually an int type
+    lea rcx, [rel int_type]
+    cmp rax, rcx
+    jne .ts_type_error
 
 .ts_int:
     mov rdi, rsi               ; key
@@ -186,6 +190,11 @@ DEF_FUNC tuple_subscript
     pop rbx
     leave
     ret
+
+.ts_type_error:
+    lea rdi, [rel exc_TypeError_type]
+    CSTRING rsi, "tuple indices must be integers or slices"
+    call raise_exception
 END_FUNC tuple_subscript
 
 ; tuple_len(PyTupleObject *tuple) -> int64_t

tests/cpython/test_tuple.py

@@ -0,0 +1,84 @@
+"""CPython test_tuple.py adapted for apython."""
+from test import seq_tests
+import unittest
+
+class TupleTest(seq_tests.CommonTest):
+    type2test = tuple
+
+    def test_constructors(self):
+        self.assertEqual(tuple(), ())
+        t0_3 = (0, 1, 2, 3)
+        t0_3_bis = tuple(t0_3)
+        # Skip identity test: tuple(t) is t is a CPython optimization
+        self.assertEqual(t0_3, t0_3_bis)
+        self.assertEqual(tuple([]), ())
+        self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
+        self.assertEqual(tuple(''), ())
+        self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm'))
+        self.assertEqual(tuple(x for x in range(10) if x % 2),
+                         (1, 3, 5, 7, 9))
+
+    def test_truth(self):
+        super().test_truth()
+        self.assertTrue(not ())
+        self.assertTrue((42, ))
+
+    def test_len(self):
+        super().test_len()
+        self.assertEqual(len(()), 0)
+        self.assertEqual(len((0,)), 1)
+        self.assertEqual(len((0, 1, 2)), 3)
+
+    def test_iadd(self):
+        super().test_iadd()
+        u = (0, 1)
+        u2 = u
+        u += (2, 3)
+        self.assertTrue(u is not u2)
+
+    def test_imul(self):
+        super().test_imul()
+        u = (0, 1)
+        u2 = u
+        u *= 3
+        self.assertTrue(u is not u2)
+
+    def test_tupleresizebug(self):
+        # Check that a specific bug in _PyTuple_Resize() is squashed.
+        def f():
+            for i in range(1000):
+                yield i
+        self.assertEqual(list(tuple(f())), list(range(1000)))
+
+    def test_repr(self):
+        l0 = tuple()
+        l2 = (0, 1, 2)
+        a0 = self.type2test(l0)
+        a2 = self.type2test(l2)
+
+        self.assertEqual(str(a0), repr(l0))
+        self.assertEqual(str(a2), repr(l2))
+        self.assertEqual(repr(a0), "()")
+        self.assertEqual(repr(a2), "(0, 1, 2)")
+
+    def test_repr_large(self):
+        # Check the repr of large tuple objects
+        def check(n):
+            l = (0,) * n
+            s = repr(l)
+            self.assertEqual(s,
+                '(' + ', '.join(['0'] * n) + ')')
+        check(10)       # check our checking code
+        check(1000000)
+
+    def test_lexicographic_ordering(self):
+        # Issue 21100
+        a = self.type2test([1, 2])
+        b = self.type2test([1, 2, 0])
+        c = self.type2test([1, 3])
+        self.assertLess(a, b)
+        self.assertLess(b, c)
+
+
+if __name__ == "__main__":
+    unittest.main()