Add method arg validation, functools/itertools/pickle stubs

Infrastructure for importing real CPython tests:

- Add min_args/max_args to PyBuiltinObject, validate in builtin_func_call
  Methods like list.append() now raise TypeError when called with wrong
  number of args instead of segfaulting.
- Add builtin_func_new_checked and add_method_to_dict_checked helpers
- Register list methods with proper arg count bounds
- Create lib/functools.py (cmp_to_key, reduce, partial)
- Create lib/itertools.py (chain, islice, count, repeat, cycle,
  accumulate, starmap, product)
- Create lib/pickle.py (stub with HIGHEST_PROTOCOL constant)

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

Author: jgarzik

include/builtins.inc

@@ -60,6 +60,8 @@ struc PyBuiltinObject
     .func_id:     resq 1  ; +16: builtin function ID
     .func_name:   resq 1  ; +24: ptr to name string
     .func_ptr:    resq 1  ; +32: ptr to C implementation
+    .min_args:    resq 1  ; +40: minimum nargs (including self), 0 = no check
+    .max_args:    resq 1  ; +48: maximum nargs, -1 = no max check
 endstruc
 
 %endif ; BUILTINS_INC

lib/functools.py

@@ -0,0 +1,44 @@
+# functools - adapted from CPython for apython
+
+def cmp_to_key(mycmp):
+    """Convert a cmp= function into a key= function"""
+    class K(object):
+        __slots__ = ['obj']
+        def __init__(self, obj):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) < 0
+        def __gt__(self, other):
+            return mycmp(self.obj, other.obj) > 0
+        def __eq__(self, other):
+            return mycmp(self.obj, other.obj) == 0
+        def __le__(self, other):
+            return mycmp(self.obj, other.obj) <= 0
+        def __ge__(self, other):
+            return mycmp(self.obj, other.obj) >= 0
+        __hash__ = None
+    return K
+
+
+def reduce(function, iterable, initial=None):
+    """Apply function of two arguments cumulatively to iterable items."""
+    it = iter(iterable)
+    if initial is None:
+        try:
+            value = next(it)
+        except StopIteration:
+            raise TypeError("reduce() of empty iterable with no initial value")
+    else:
+        value = initial
+    for element in it:
+        value = function(value, element)
+    return value
+
+
+def partial(func, *args, **kwargs):
+    """Create a partial function application."""
+    def wrapper(*more_args, **more_kwargs):
+        all_kwargs = dict(kwargs)
+        all_kwargs.update(more_kwargs)
+        return func(*args, *more_args, **all_kwargs)
+    return wrapper

lib/itertools.py

@@ -0,0 +1,104 @@
+# itertools - adapted from CPython for apython
+
+def chain(*iterables):
+    """chain(*iterables) --> chain object
+    Return a chain object whose .__next__() method returns elements from the
+    first iterable until it is exhausted, then elements from the next
+    iterable, until all of the iterables are exhausted."""
+    for it in iterables:
+        yield from it
+
+
+def islice(iterable, *args):
+    """islice(iterable, stop) or islice(iterable, start, stop[, step])"""
+    if len(args) == 1:
+        start, stop, step = 0, args[0], 1
+    elif len(args) == 2:
+        start, stop, step = args[0], args[1], 1
+    elif len(args) == 3:
+        start, stop, step = args
+    else:
+        raise TypeError("islice expected 2-4 arguments")
+
+    it = iter(iterable)
+    # Skip start elements
+    for i in range(start):
+        try:
+            next(it)
+        except StopIteration:
+            return
+
+    count = 0
+    for i, item in enumerate(it):
+        if stop is not None and start + i >= stop:
+            return
+        if i % step == 0:
+            yield item
+
+
+def count(start=0, step=1):
+    """count(start=0, step=1) --> count object
+    Return a count object whose .__next__() method returns consecutive values."""
+    n = start
+    while True:
+        yield n
+        n += step
+
+
+def repeat(obj, times=None):
+    """repeat(object [,times]) -> create an iterator which returns the object
+    for the specified number of times."""
+    if times is None:
+        while True:
+            yield obj
+    else:
+        for i in range(times):
+            yield obj
+
+
+def cycle(iterable):
+    """cycle(iterable) --> cycle object
+    Return elements from the iterable until it is exhausted.
+    Then repeat the sequence indefinitely."""
+    saved = []
+    for element in iterable:
+        yield element
+        saved.append(element)
+    while saved:
+        for element in saved:
+            yield element
+
+
+def accumulate(iterable, func=None, initial=None):
+    """accumulate(iterable[, func, initial]) --> accumulate object"""
+    it = iter(iterable)
+    if initial is not None:
+        total = initial
+    else:
+        try:
+            total = next(it)
+        except StopIteration:
+            return
+    yield total
+    for element in it:
+        if func is None:
+            total = total + element
+        else:
+            total = func(total, element)
+        yield total
+
+
+def starmap(function, iterable):
+    """starmap(function, iterable) --> starmap object"""
+    for args in iterable:
+        yield function(*args)
+
+
+def product(*iterables, repeat=1):
+    """product(*iterables, repeat=1) --> product object"""
+    pools = [list(pool) for pool in iterables] * repeat
+    result = [[]]
+    for pool in pools:
+        result = [x + [y] for x in result for y in pool]
+    for prod in result:
+        yield tuple(prod)

lib/pickle.py

@@ -0,0 +1,30 @@
+# pickle - minimal stub for apython
+# Serialization is not yet implemented. This stub provides
+# constants so tests can import pickle and check HIGHEST_PROTOCOL.
+
+HIGHEST_PROTOCOL = 5
+DEFAULT_PROTOCOL = 5
+
+
+class PicklingError(Exception):
+    pass
+
+
+class UnpicklingError(Exception):
+    pass
+
+
+def dumps(obj, protocol=None):
+    raise NotImplementedError("not implemented in apython")
+
+
+def loads(data):
+    raise NotImplementedError("not implemented in apython")
+
+
+def dump(obj, file, protocol=None):
+    raise NotImplementedError("not implemented in apython")
+
+
+def load(file):
+    raise NotImplementedError("not implemented in apython")

src/builtins.asm

@@ -161,6 +161,8 @@ DEF_FUNC builtin_func_new
     mov qword [rax + PyBuiltinObject.func_id], 0   ; not used for func_ptr dispatch
     mov [rax + PyBuiltinObject.func_name], r13
     mov [rax + PyBuiltinObject.func_ptr], rbx
+    mov qword [rax + PyBuiltinObject.min_args], 0  ; 0 = no check
+    mov qword [rax + PyBuiltinObject.max_args], -1 ; -1 = no max check
 
     pop r13
     pop r12
@@ -169,18 +171,65 @@ DEF_FUNC builtin_func_new
     ret
 END_FUNC builtin_func_new
 
+;; ============================================================================
+;; builtin_func_new_checked(void *func_ptr, const char *name_cstr,
+;;                          int64_t min_args, int64_t max_args)
+;; Like builtin_func_new but sets arg count bounds for validation.
+;; rdx = min_args (including self), rcx = max_args (-1 = no max)
+;; ============================================================================
+global builtin_func_new_checked
+DEF_FUNC builtin_func_new_checked
+    push r14
+    push r15
+    mov r14, rdx                ; min_args
+    mov r15, rcx                ; max_args
+    call builtin_func_new
+    mov [rax + PyBuiltinObject.min_args], r14
+    mov [rax + PyBuiltinObject.max_args], r15
+    pop r15
+    pop r14
+    leave
+    ret
+END_FUNC builtin_func_new_checked
+
 ;; ============================================================================
 ;; builtin_func_call(PyObject *self, PyObject **args, int64_t nargs) -> PyObject*
 ;; Dispatch to the underlying C function: func_ptr(args, nargs)
+;; Validates nargs against min_args/max_args if set.
 ;; ============================================================================
 DEF_FUNC_BARE builtin_func_call
     ; self = rdi, args = rsi, nargs = rdx
+    ; Check min_args (0 = no check)
+    mov rcx, [rdi + PyBuiltinObject.min_args]
+    test rcx, rcx
+    jz .bfc_no_min_check
+    cmp rdx, rcx
+    jl .bfc_too_few
+.bfc_no_min_check:
+    ; Check max_args (-1 = no check)
+    mov rcx, [rdi + PyBuiltinObject.max_args]
+    cmp rcx, -1
+    je .bfc_no_max_check
+    cmp rdx, rcx
+    jg .bfc_too_many
+.bfc_no_max_check:
     ; Extract func_ptr from self
     mov rax, [rdi + PyBuiltinObject.func_ptr]
     ; Call func_ptr(args, nargs)
     mov rdi, rsi                ; args
     mov rsi, rdx                ; nargs
     jmp rax                     ; tail call
+
+.bfc_too_few:
+    extern exc_TypeError_type
+    extern raise_exception
+    lea rdi, [rel exc_TypeError_type]
+    CSTRING rsi, "function takes at least 1 argument"
+    call raise_exception
+.bfc_too_many:
+    lea rdi, [rel exc_TypeError_type]
+    CSTRING rsi, "function takes at most N arguments"
+    call raise_exception
 END_FUNC builtin_func_call
 
 ;; ============================================================================