Fix dict.update/popitem/set.update, add more tests

- Fix dict.update() no-args crash: add nargs guard
- Fix dict.popitem() key tag: read from entry instead of hardcoding TAG_PTR
- Implement set.update() method and register in tp_dict
- Add test_popitem to test_dict.py (25 tests now)
- Restore dict.update() no-args test
- Update set.update test to use real method
- Update bugs.md with fixes #17-#19

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

Author: jgarzik

bugs.md

@@ -81,14 +81,28 @@
 **Root cause**: `dict_type.tp_call = 0`, so `type_call` used generic `instance_new` which allocated a PyDictObject-sized block but didn't initialize the hash table entries array.
 **Fix**: Implement `dict_type_call` that calls `dict_new` for no-args case and copies entries for dict(other_dict) case.
 
+### 17. dict.update() no-args crash (methods.asm)
+**Symptom**: `d.update()` segfaults
+**Root cause**: Always reads `args[1]` without checking nargs first
+**Fix**: Add `cmp rsi, 1; jle .du_done` guard at start
+
+### 18. dict.popitem() key tag hardcoded to TAG_PTR (methods.asm)
+**Symptom**: `d.popitem()` segfaults on dicts with non-string keys
+**Root cause**: Key tag hardcoded to TAG_PTR, `INCREF` used instead of `INCREF_VAL`, key tag not read from entry
+**Fix**: Read key_tag from entry, use INCREF_VAL, pass correct tag to dict_del
+
+### 19. set.update() method missing (methods.asm)
+**Symptom**: `s.update({3,4})` raises AttributeError
+**Root cause**: Method not implemented, not registered in set tp_dict
+**Fix**: Implement set_method_update, register in init_builtin_methods
+
 ### Known Bugs Not Yet Fixed
-- `dict.update()` with no args segfaults (methods.asm)
 - `dict.update(x=1, y=2)` with kwargs segfaults (methods.asm)
-- `dict.popitem()` segfaults (methods.asm)
-- `set.update()` method not implemented (use |= instead)
 - `repr(d.keys())` returns wrong value (dict view repr not implemented)
 - `(1,1) in d.items()` fails (dict_items __contains__ not implemented)
 - `tuple(t) is t` identity optimization not implemented
+- `list.append()` no-args segfaults (method arg count validation missing)
+- `assertRaises(fn)` double-free crash (exception handling memory issue)
 
 ## New Infrastructure Added
 - `list_copy()` - standalone shallow copy function

src/methods.asm

@@ -5846,6 +5846,11 @@ DEF_FUNC dict_method_update
     push r14
 
     mov rbx, [rdi]          ; self
+
+    ; If nargs == 1 (just self, no args), return None immediately
+    cmp rsi, 1
+    jle .du_done
+
     mov r12, [rdi + 16]     ; other dict
 
     mov r13, [r12 + PyDictObject.capacity]
@@ -6145,29 +6150,34 @@ DEF_FUNC dict_method_popitem
 
 .dpopitem_found:
     ; r13 = key, r14 = value, rcx = value_tag
+    ; Also save key_tag from the entry
+    mov rax, [rbx + PyDictObject.entries]
+    imul rdx, r12, DICT_ENTRY_SIZE
+    add rax, rdx
+    movzx r8d, byte [rax + DictEntry.key_tag]
+    push r8                  ; save key_tag
     push rcx                 ; save value_tag across tuple_new
     ; Create 2-tuple
     mov rdi, 2
     call tuple_new
     pop rcx                  ; restore value_tag
+    pop r8                   ; restore key_tag
     mov r12, rax             ; r12 = tuple
 
-    ; Set tuple[0] = key, tuple[1] = value
+    ; Set tuple[0] = key with correct tag, tuple[1] = value
     mov r9, [r12 + PyTupleObject.ob_item]
     mov r10, [r12 + PyTupleObject.ob_item_tags]
-    ; Key from dict entries — always heap ptr (strings)
     mov [r9], r13
-    mov byte [r10], TAG_PTR
-    INCREF r13
+    mov byte [r10], r8b     ; key tag from entry
+    INCREF_VAL r13, r8
     mov [r9 + 8], r14
-    ; Use stored value_tag from dict entry
-    mov byte [r10 + 1], cl
+    mov byte [r10 + 1], cl  ; value tag from entry
     INCREF_VAL r14, rcx
 
     ; Delete key from dict
     mov rdi, rbx
     mov rsi, r13
-    mov edx, TAG_PTR
+    movzx edx, byte [r10]   ; key tag
     call dict_del
 
     mov rax, r12
@@ -6919,6 +6929,57 @@ DEF_FUNC set_method_union
     call raise_exception
 END_FUNC set_method_union
 
+;; ============================================================================
+;; set_method_update(args, nargs) -> None
+;; args[0]=self, args[1]=other (set). Adds all elements of other to self.
+;; ============================================================================
+DEF_FUNC set_method_update
+    push rbx
+    push r12
+    push r13
+
+    mov rbx, [rdi]          ; self
+    ; If no other arg, no-op
+    cmp rsi, 2
+    jl .supd_done
+
+    mov r12, [rdi + 16]     ; other set
+    mov r13, [r12 + PyDictObject.capacity]
+    xor ecx, ecx
+
+.supd_loop:
+    cmp rcx, r13
+    jge .supd_done
+
+    imul rax, rcx, SET_ENTRY_SIZE
+    add rax, [r12 + PyDictObject.entries]
+    push rcx
+
+    cmp qword [rax + SET_ENTRY_KEY_TAG], 0
+    je .supd_next
+
+    mov rdi, rbx
+    mov rsi, [rax + SET_ENTRY_KEY]
+    mov rdx, [rax + SET_ENTRY_KEY_TAG]
+    call set_add
+
+.supd_next:
+    pop rcx
+    inc ecx
+    jmp .supd_loop
+
+.supd_done:
+    extern none_singleton
+    lea rax, [rel none_singleton]
+    inc qword [rax + PyObject.ob_refcnt]
+    mov edx, TAG_PTR
+    pop r13
+    pop r12
+    pop rbx
+    leave
+    ret
+END_FUNC set_method_update
+
 ;; ============================================================================
 ;; set_method_intersection(args, nargs) -> new set = self & other
 ;; args[0]=self, args[1]=other
@@ -9781,6 +9842,11 @@ DEF_FUNC methods_init
     lea rdx, [rel set_method_isdisjoint]
     call add_method_to_dict
 
+    mov rdi, rbx
+    lea rsi, [rel mn_update]
+    lea rdx, [rel set_method_update]
+    call add_method_to_dict
+
     ; Store in set_type.tp_dict
     lea rax, [rel set_type]
     mov [rax + PyTypeObject.tp_dict], rbx

tests/cpython/test_dict.py

@@ -78,7 +78,7 @@ def test_update(self):
         d.update({1: 1, 2: 2, 3: 3})
         self.assertEqual(d, {1: 1, 2: 2, 3: 3})
 
-        # Skip: d.update() with no args crashes (known bug)
+        d.update()
         self.assertEqual(d, {1: 1, 2: 2, 3: 3})
 
     def test_fromkeys(self):
@@ -135,6 +135,19 @@ def test_pop(self):
         self.assertEqual(d.pop('abc', 'ghi'), 'ghi')
         self.assertEqual(len(d), 0)
 
+    def test_popitem(self):
+        d = {1: 'a', 2: 'b', 3: 'c'}
+        items = []
+        while d:
+            items.append(d.popitem())
+        self.assertEqual(len(items), 3)
+        self.assertEqual(sorted(items), [(1, 'a'), (2, 'b'), (3, 'c')])
+        try:
+            d.popitem()
+            self.fail("Expected KeyError")
+        except KeyError:
+            pass
+
     def test_repr(self):
         d = {}
         self.assertEqual(repr(d), '{}')

tests/cpython/test_set.py

@@ -157,9 +157,11 @@ def test_large_set(self):
             self.assertIn(i, s)
 
     def test_update(self):
-        # set.update via |= (update method not available)
         s = {1, 2}
-        s |= {3, 4}
+        s.update({3, 4})
+        self.assertEqual(sorted(s), [1, 2, 3, 4])
+        # No-arg update is a no-op
+        s.update()
         self.assertEqual(sorted(s), [1, 2, 3, 4])
 
     def test_set_from_list(self):