GeezerVison

Copilot AI left a comment

A METH_VARARGS | METH_KEYWORDS function received an empty dict when the
call had no keywords, where the calling convention passes NULL. A callee
that rejects keywords by testing the pointer saw a non-NULL kwargs.
The METH_FASTCALL | METH_KEYWORDS path already passed a NULL kwnames.

Name the four function pointer types the PyMethodPointer union holds
instead of spelling out each signature inline.

Assisted-by: Claude

The tp_new slot holds a Rust fn pointer, which a C `newfunc` cannot be.
Put the C function in a `CSlots` table owned by the heap type it belongs
to, and store `c_new_trampoline` in `new`; the trampoline reads the table
off the type it is called with, so a subclass that inherited both reaches
the same function and passes itself as `subtype`.

`PyTypeSlots` holds one 8-byte pointer to the table rather than a field
per C-provided slot, so further slots are a field in `CSlots` and a
trampoline beside this one. The pointer is inherited with `new` by
`set_new` and by `update_one_slot`, and dropped when a Python-level
`__new__` replaces the slot.

Compare what tp_new dispatches to, not the slot, in the "is not safe"
check: every C type shares one trampoline, so comparing `new` alone let
`CBase.__new__(CSub)` run CSub's tp_new.

Move the C call marshalling from capi to `types::c_slots` so the
trampoline and the METH_* call paths share it.

Assisted-by: Claude

PyType_GetSlot reported Py_tp_new only for a function installed from C.
A Rust slot such as int's or object's read as NULL, so an extension that
reads its base type's tp_new to call it with its own subtype had nothing
to call.

Pair each Rust tp_new with a statically instantiated extern "C"
function. `c_new_for::<S>` marshals `(subtype, args, kwds)`, calls
`S::call`, and returns the object or NULL with the exception pending.
`S` is `ViaConstructor<T>` for a `#[pyclass(with(Constructor))]` payload
and `PythonNew` for `new_wrapper`; the target is fixed by the type
parameter, so a subtype passed in runs the base's body.

The derive macro emits a `HasStaticCSlots::TABLE` const per Constructor
class holding the (Rust fn, C fn) pair, and stores a reference to it in
the new `PyTypeSlots::static_c_slots` field on the defining type only.
`PyType::c_tp_new` resolves a C-installed slot from `CSlots`, and a Rust
slot by matching the slot's address against the tables along the MRO,
then against the `new_wrapper` pair.

An empty heap subclass of object now reports object's tp_new rather
than NULL; the round-trip test is updated for that.

Assisted-by: Claude
Assisted-by: Grok

Reproduce what pyo3's PyNativeTypeInitializer does: a heap type whose C
tp_new fetches the base type's tp_new through PyType_GetSlot and calls
it with the subtype it was given. Cover object and int as bases, a
Python-level subclass of the extension type, the slot each type reports,
and a ValueError raised by the base crossing both trampolines.

Replace a map/unwrap_or_else pair in a test helper that clippy flags.

Assisted-by: Claude
Assisted-by: Grok

Assisted-by: Grok:4.6

pyresult_to_ret_ptr stored the error with set_exception, which is the
exc_info slot PUSH_EXC_INFO and POP_EXCEPT maintain. The C side reads the
pending error with raised_exception and take_raised_exception, so a Rust
tp_new reached through c_new_for returned NULL with nothing raised.
Use set_raised_exception, and the same in the test helper that reports a
missing base tp_new.

Assisted-by: Claude

PyType_FromSlots left the Py_tp_new entry as a TODO. Hand it to
set_tp_new once the type exists, so the type instantiates through the
C function, gets the checked __new__ wrapper, and reports the function
from PyType_GetSlot.

A spec test covers those three paths. The pyo3 tests zero_sized_class
and subclass_with_property were ignored; they pass now that
PyType_GetSlot answers Py_tp_new for object and list, so the ignore
markers are removed. rust_class and rust_class_with_member stay ignored
because the spec asks for a non-zero basicsize.

Assisted-by: Claude

set_tp_new now returns TypeError when the type's own dict already has
__new__, matching its documented precondition. HeapTypeExt::c_slots is
narrowed to pub(crate), and update_one_slot loads the type's C slot
table once instead of twice.

Add a capi test for the refusal and for the second installation, and a
pyo3 test that a #[new] taking arguments runs from Python code, raises
its error, and refuses a Python subclass.

Assisted-by: Claude