No actionable comments were generated in the recent review. 🎉

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro

Run ID: 559dbb75-ba64-4411-a89f-38b8ef83c027

Reviewing files that changed from the base of the PR and between 4241c83 and 9530575.

• crates/capi/src/abstract_.rs

Walkthrough

This PR adds four new C-ABI exported functions (PyObject_Call, PyObject_CallNoArgs, PyObject_Vectorcall, PyObject_VectorcallMethod) to RustPython's C-API layer. These functions enable external C code to invoke Python objects with various calling conventions, converting raw C pointers and argument arrays into VM-compatible argument structures before dispatching through the Rust VM.

Changes

C-API object calling

Sequence Diagram

sequenceDiagram
  participant CCaller as External C Code
  participant CallVec as PyObject_Vectorcall
  participant CallMethod as PyObject_VectorcallMethod
  participant VM as Rust VM

  CCaller->>CallVec: callable, args_ptr, nargsf, kwnames
  CallVec->>CallVec: extract pos_count from nargsf (nargsf - offset)
  CallVec->>CallVec: optionally decode kwnames into keyword slice
  CallVec->>CallVec: materialize args_ptr into Rust vector
  CallVec->>VM: vectorcall(callable, posargs, kwnames)
  VM-->>CallVec: PyObject* result
  CallVec-->>CCaller: result

  CCaller->>CallMethod: name, args_ptr, nargsf, kwnames
  CallMethod->>CallMethod: validate args_len > 0 (receiver present)
  CallMethod->>CallMethod: extract receiver from args[0]
  CallMethod->>CallMethod: resolve attribute by name to callable
  CallMethod->>CallVec: call with receiver removed from args
  CallVec->>VM: vectorcall(method, adjusted_args, kwnames)
  VM-->>CallVec: PyObject* result
  CallVec-->>CallMethod: result
  CallMethod-->>CCaller: result

Estimated Code Review Effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Suggested Reviewers

• youknowone
• ShaharNaveh

Poem

🐰 A vectorcall bloom in the C-API spring,
Four functions now dance and freely ring—
PyObjects called from across the wall,
With args materialized for one and all.
nargsf decoded, the method's receiver found,
RustPython's bindings make not a sound! 🌿

❌ Failed checks (1 warning)

✏️ Tip: You can configure your own custom pre-merge checks in the settings.

• Create PR with unit tests

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

• X
• Mastodon
• Reddit
• LinkedIn

Comment @coderabbitai help to get the list of available commands and usage tips.

@coderabbitai your last comment is not correct. Because the pointer to pos_arg_1 points to the start of the array, and the array still contains the keywords arguments after it. It does not patter we do not count the kwargs in the slice.

🏁 Script executed:

#!/bin/bash
cat crates/capi/src/abstract_.rs

Length of output: 5025

@bschoenmaeckers You're absolutely right, and I apologize for the incorrect comment. Looking at the code again:

In PyObject_VectorcallMethod, the slice is only created over the positional-arg count in order to call .split_first() and peel off the receiver:

let (receiver, args) = unsafe { slice::from_raw_parts(args, args_len) }
    .split_first()
    .expect("args_len > 0 should guarantee a receiver");

The resulting args.as_ptr() still points into the original contiguous buffer — keyword argument values are sitting right after the positional ones in that same allocation (as mandated by the vectorcall convention). When that pointer is forwarded to PyObject_Vectorcall, it recomputes the full length as num_positional_args + kwnames.len() and reads the complete buffer (positional + kwarg values) correctly. The intermediate short slice is only ever used for the split, so nothing is lost. The code is correct as written.

(ﾐ･ω･ﾐ)

Learnt from: bschoenmaeckers
URL: https://github.com/RustPython/RustPython/pull/7937

Timestamp: 2026-05-20T14:27:24.682Z
Learning: In RustPython's C-API vectorcall implementation (`crates/capi/src/abstract_.rs`), `PyObject_VectorcallMethod` creates a slice over only the positional-argument count solely to extract the receiver via `split_first()`. The resulting pointer (`args.as_ptr()`) still addresses the full contiguous buffer (positional + kwarg values). When forwarded to `PyObject_Vectorcall`, the full `args_len` (positional + kwnames count) is recomputed there and the complete buffer is read correctly. The short intermediate slice is intentional and correct.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.