pub ml_name: *const c_char,

pub ml_meth: PyMethodPointer,

pub ml_flags: c_int,

pub ml_doc: *const c_char,

pub(crate) fn iter<'a>(mut methods: *const Self) -> impl Iterator<Item = &'a Self> {

core::iter::from_fn(move || {

let def = unsafe { &*methods };

if def.ml_name.is_null() {

None

} else {

methods = unsafe { methods.add(1) };

Some(def)

}

})

}

pub(crate) fn build_method_def(

&self,

vm: &VirtualMachine,

has_self: bool,

) -> PyResult<PyRef<HeapMethodDef>> {

let name = unsafe { self.ml_name.try_as_str(vm) }?;

let doc = unsafe { self.ml_doc.try_as_str_opt(vm) }?;

let doc = doc

.filter(|doc| !doc.is_empty())

.map_or(ItemDoc::NONE, |doc| {

let text: &'static str = Box::leak(doc.to_owned().into_boxed_str());

ItemDoc::static_text(text)

});

let flags = PyMethodFlags::from_bits(self.ml_flags as u32)

.ok_or_else(|| vm.new_system_error("PyMethodDef contains unknown flags"))?;

let has_self = has_self && !flags.contains(PyMethodFlags::STATIC);

let method = self.ml_meth;

if flags.contains(PyMethodFlags::METHOD) {

return Err(vm.new_system_error("METH_METHOD is not supported on abi3"));

}

let call_flags = flags

& (PyMethodFlags::VARARGS

| PyMethodFlags::KEYWORDS

| PyMethodFlags::NOARGS

| PyMethodFlags::O

| PyMethodFlags::FASTCALL);

bitflags::bitflags_match!(call_flags, {

PyMethodFlags::NOARGS => {

if has_self {

let callable = move |zelf: PyObjectRef, vm: &VirtualMachine| unsafe {

let f = method.PyCFunction;

f(zelf.as_raw().cast_mut(), core::ptr::null_mut()).assume_owned_or_err(vm)

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

} else {

let callable = move |vm: &VirtualMachine| unsafe {

let f = method.PyCFunction;

f(core::ptr::null_mut(), core::ptr::null_mut()).assume_owned_or_err(vm)

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

}

},

PyMethodFlags::VARARGS => {

let callable = move |args: PosArgs, vm: &VirtualMachine| unsafe {

call_function(vm, method, has_self, Some(args))

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

},

PyMethodFlags::VARARGS | PyMethodFlags::KEYWORDS => {

let callable = move | args: FuncArgs, vm: &VirtualMachine| unsafe {

call_function_with_keywords(vm, method, has_self, args)

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

},

PyMethodFlags::FASTCALL | PyMethodFlags::KEYWORDS => {

let callable = move |args: FuncArgs, vm: &VirtualMachine| unsafe {

call_fast_function_with_keywords(vm, method, has_self, args)

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

},

PyMethodFlags::FASTCALL => {

let callable = move |args: PosArgs, vm: &VirtualMachine| unsafe {

call_fast_function(vm, method, has_self, args)

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

},

PyMethodFlags::O => {

let f = unsafe { method.PyCFunction };

if has_self {

let callable = move |zelf: PyObjectRef, arg: PyObjectRef, vm: &VirtualMachine| -> PyResult {

unsafe { f(zelf.as_raw().cast_mut(), arg.as_raw().cast_mut()).assume_owned_or_err(vm) }

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

} else {

let callable = move |arg: PyObjectRef, vm: &VirtualMachine| -> PyResult {

unsafe { f(core::ptr::null_mut(), arg.as_raw().cast_mut()).assume_owned_or_err(vm) }

};

Ok(vm.ctx.new_method_def(name, callable, flags, doc))

}

},

_ => {

Err(vm.new_system_error(format!(

"function {name} has unsupported or invalid calling-convention flags: {flags:?}"

)))

},

})

}

slf: *mut PyObject,

args: *mut PyObject,

kwargs: *mut PyObject,

slf: *mut PyObject,

args: *const *mut PyObject,

nargs: isize,

slf: *mut PyObject,

args: *const *mut PyObject,

nargs: isize,

kwnames: *mut PyObject,

pub PyCFunction: PyCFunction,

pub PyCFunctionWithKeywords: PyCFunctionWithKeywords,

pub PyCFunctionFast: PyCFunctionFast,

pub PyCFunctionFastWithKeywords: PyCFunctionFastWithKeywords,

fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

unsafe { self.PyCFunction.fmt(f) }

}

vm: &VirtualMachine,

method: PyMethodPointer,

has_self: bool,

args: Option<A>,

) -> PyResult {

let f = unsafe { method.PyCFunction };

let (slf, arg_tuple) = if let Some(mut args) = args.map(Into::into) {

let slf = take_self_arg(&mut args, has_self);

let arg_tuple = vm.ctx.new_tuple(args.args);

(slf, Some(arg_tuple))

} else {

(None, None)

};

let slf_ptr = slf

.as_ref()

.map(|obj| obj.as_object().as_raw().cast_mut())

.unwrap_or_default();

let arg_ptr = arg_tuple

.as_ref()

.map(|tuple| tuple.as_object().as_raw().cast_mut())

.unwrap_or_default();

unsafe { f(slf_ptr, arg_ptr).assume_owned_or_err(vm) }

vm: &VirtualMachine,

method: PyMethodPointer,

has_self: bool,

mut args: FuncArgs,

) -> PyResult {

let f = unsafe { method.PyCFunctionWithKeywords };

let slf = take_self_arg(&mut args, has_self);

let slf_ptr = slf

.as_ref()

.map(|obj| obj.as_object().as_raw().cast_mut())

.unwrap_or_default();

let (arg_tuple, kwargs) = split_args(vm, args)?;

unsafe {

f(

slf_ptr,

arg_tuple.as_object().as_raw().cast_mut(),

kwargs_ptr(kwargs.as_ref()),

)

.assume_owned_or_err(vm)

}

vm: &VirtualMachine,

method: PyMethodPointer,

has_self: bool,

mut args: FuncArgs,

) -> PyResult {

let f = unsafe { method.PyCFunctionFastWithKeywords };

let slf = take_self_arg(&mut args, has_self);

let slf_ptr = slf

.as_ref()

.map(|obj| obj.as_object().as_raw().cast_mut())

.unwrap_or_default();

let nargs = args.args.len();

let mut fastcall_args = args.args;

let kwnames_tuple = if !args.kwargs.is_empty() {

let mut kwnames = Vec::with_capacity(args.kwargs.len());

for (k, v) in args.kwargs {

kwnames.push(vm.ctx.new_str(k).into());

fastcall_args.push(v);

}

Some(vm.ctx.new_tuple(kwnames))

} else {

None

};

let kwnames_ptr = kwnames_tuple

.as_ref()

.map(|tuple| tuple.as_object().as_raw().cast_mut())

.unwrap_or_default();

// SAFETY: PyObjectRef is repr(transparent) over a pointer to PyObject, so a

// Vec<PyObjectRef> has a layout-compatible contiguous backing buffer. The

// vector is kept alive for the duration of the call.

let fastcall_arg_ptrs = fastcall_args.as_ptr().cast::<*mut PyObject>();

unsafe { f(slf_ptr, fastcall_arg_ptrs, nargs as isize, kwnames_ptr).assume_owned_or_err(vm) }

vm: &VirtualMachine,

method: PyMethodPointer,

has_self: bool,

args: PosArgs,

) -> PyResult {

let f = unsafe { method.PyCFunctionFast };

let mut args: FuncArgs = args.into();

let slf = take_self_arg(&mut args, has_self);

let slf_ptr = slf

.as_ref()

.map(|obj| obj.as_object().as_raw().cast_mut())

.unwrap_or_default();

// SAFETY: PyObjectRef is repr(transparent) over a pointer to PyObject, so a

// Vec<PyObjectRef> has a layout-compatible contiguous backing buffer. The

// vector is kept alive for the duration of the call.

let fastcall_arg_ptrs = args.args.as_mut_ptr().cast::<*mut PyObject>();

unsafe { f(slf_ptr, fastcall_arg_ptrs, args.args.len() as isize).assume_owned_or_err(vm) }

if !has_self {

None

} else {

args.take_positional()

}

ml: *mut PyMethodDef,

slf: *mut PyObject,

_module: *mut PyObject,

_cls: *mut PyTypeObject,

) -> *mut PyObject {

with_vm(|vm| -> PyResult {

assert!(

_cls.is_null(),

"PyCMethod_New does not support METH_METHOD on abi3"

);

let ml = unsafe { &*ml };

let zelf = unsafe { slf.assume_borrowed_or_opt() }.map(ToOwned::to_owned);

Ok(ml

.build_method_def(vm, zelf.is_some())?

.build_function(vm, zelf)

.into())

})

ml: *mut PyMethodDef,

slf: *mut PyObject,

) -> *mut PyObject {

unsafe { PyCMethod_New(ml, slf, core::ptr::null_mut(), core::ptr::null_mut()) }

ml: *mut PyMethodDef,

slf: *mut PyObject,

module: *mut PyObject,

) -> *mut PyObject {

unsafe { PyCMethod_New(ml, slf, module, core::ptr::null_mut()) }

use pyo3::exceptions::PyException;

use pyo3::ffi::{PyLong_FromLong, PyObject};

use pyo3::prelude::*;

use pyo3::types::{PyCFunction, PyInt, PyString};

#[test]

fn closure_function() {

Python::attach(|py| {

let f = PyCFunction::new_closure(py, None, None, |_args, _kwargs| "Hello from Rust!")

.unwrap();

assert_eq!(

f.call0().unwrap().cast::<PyString>().unwrap(),

"Hello from Rust!"

);

})

}

#[test]

fn function_no_args() {

Python::attach(|py| {

unsafe extern "C" fn c_fn(_self: *mut PyObject, _args: *mut PyObject) -> *mut PyObject {

assert!(_self.is_null());

assert!(_args.is_null());

unsafe { PyLong_FromLong(4200) }

}

let py_fn = PyCFunction::new(py, c_fn, c"py_fn", c"", None).unwrap();

let result = py_fn

.call0()

.unwrap()

.cast::<PyInt>()

.unwrap()

.extract::<u32>()

.unwrap();

assert_eq!(result, 4200);

assert!(py_fn.call((1,), None).is_err());

assert!(py_fn.call((1, 2), None).is_err());

})

}

#[test]

fn closure_function_error() {

Python::attach(|py| {

let f = PyCFunction::new_closure(py, None, None, |_args, _kwargs| {

Err::<(), _>(PyException::new_err("Something went wrong"))

})

.unwrap();

let err = f.call0().unwrap_err();

assert_eq!(

err.value(py).repr().unwrap(),

"Exception('Something went wrong')"

);

})

}

#[test]

fn wrap_static_no_args_function() {

#[pyfunction()]

fn f() {}

Python::attach(|py| {

let module = PyModule::new(py, "test_wrap_pyfunction_forms").unwrap();

let func = wrap_pyfunction!(f, &module).unwrap();

func.call0().unwrap();

});

}

#[test]

fn wrap_one_arg_function_with_no_module() {

#[pyfunction]

fn one_arg(value: i64) -> i64 {

value

}

Python::attach(|py| {

let func = wrap_pyfunction!(one_arg, py).unwrap();

func.call1((7,)).unwrap();

});

}

#[test]

fn no_keywords_before_arity() {

Python::attach(|py| {

unsafe extern "C" fn c_fn(_self: *mut PyObject, _args: *mut PyObject) -> *mut PyObject {

unsafe { PyLong_FromLong(42) }

}

let f = PyCFunction::new(py, c_fn, c"no_keywords", c"", None).unwrap();

let kwargs = pyo3::types::PyDict::new(py);

kwargs.set_item("unexpected", 1).unwrap();

let err = f.call((1,), Some(&kwargs)).unwrap_err();

assert_eq!(

err.value(py).str().unwrap().to_str().unwrap(),

"no_keywords() takes no keyword arguments"

);

kwargs.clear();

assert_eq!(

f.call((), Some(&kwargs)).unwrap().extract::<i32>().unwrap(),

42

);

});

}