diff --git a/CHANGELOG.md b/CHANGELOG.md index e3de59c2f57..f237cfbf173 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Expose `pyo3-build-config` APIs for cross-compiling and Python configuration discovery for use in other projects. [#1996](https://github.com/PyO3/pyo3/pull/1996) - Add buffer magic methods `__getbuffer__` and `__releasebuffer__` to `#[pymethods]`. [#2067](https://github.com/PyO3/pyo3/pull/2067) - Accept paths in `wrap_pyfunction` and `wrap_pymodule`. [#2081](https://github.com/PyO3/pyo3/pull/2081) +- Add check for correct number of arguments on magic methods. [#2083](https://github.com/PyO3/pyo3/pull/2083) ### Changed @@ -46,6 +47,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - internal `handle_panic` helper [#2074](https://github.com/PyO3/pyo3/pull/2074) - `#[pyfunction]` and `#[pymethods]` argument extraction [#2075](https://github.com/PyO3/pyo3/pull/2075) [#2085](https://github.com/PyO3/pyo3/pull/2085) - `#[pyclass]` type object creation [#2076](https://github.com/PyO3/pyo3/pull/2076) [#2081](https://github.com/PyO3/pyo3/pull/2081) +- `__ipow__` now supports modulo argument on Python 3.8+. [#2083](https://github.com/PyO3/pyo3/pull/2083) +- `pyo3-macros-backend` is now compiled with PyO3 cfgs to enable different magic method definitions based on version. [#2083](https://github.com/PyO3/pyo3/pull/2083) ### Removed diff --git a/guide/src/class/protocols.md b/guide/src/class/protocols.md index bab3d3d07e4..fc6867c8897 100644 --- a/guide/src/class/protocols.md +++ b/guide/src/class/protocols.md @@ -289,13 +289,15 @@ This trait also has support the augmented arithmetic assignments (`+=`, `-=`, * `fn __itruediv__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __ifloordiv__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __imod__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` - * `fn __ipow__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` + * `fn __ipow__(&'p mut self, other: impl FromPyObject, modulo: impl FromPyObject) -> PyResult<()>` on Python 3.8^ + * `fn __ipow__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` on Python 3.7 see https://bugs.python.org/issue36379 * `fn __ilshift__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __irshift__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __iand__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __ior__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` * `fn __ixor__(&'p mut self, other: impl FromPyObject) -> PyResult<()>` + The following methods implement the unary arithmetic operations (`-`, `+`, `abs()` and `~`): * `fn __neg__(&'p self) -> PyResult` diff --git a/pyo3-macros-backend/src/defs.rs b/pyo3-macros-backend/src/defs.rs index be90f137974..258029d63f7 100644 --- a/pyo3-macros-backend/src/defs.rs +++ b/pyo3-macros-backend/src/defs.rs @@ -421,7 +421,7 @@ pub const NUM: Proto = Proto { .args(&["Other"]) .has_self(), MethodProto::new("__ipow__", "PyNumberIPowProtocol") - .args(&["Other"]) + .args(&["Other", "Modulo"]) .has_self(), MethodProto::new("__ilshift__", "PyNumberILShiftProtocol") .args(&["Other"]) diff --git a/pyo3-macros-backend/src/pymethod.rs b/pyo3-macros-backend/src/pymethod.rs index b8cc764d622..31efb6b3c0d 100644 --- a/pyo3-macros-backend/src/pymethod.rs +++ b/pyo3-macros-backend/src/pymethod.rs @@ -532,8 +532,8 @@ const __IMOD__: SlotDef = SlotDef::new("Py_nb_inplace_remainder", "binaryfunc") .arguments(&[Ty::Object]) .extract_error_mode(ExtractErrorMode::NotImplemented) .return_self(); -const __IPOW__: SlotDef = SlotDef::new("Py_nb_inplace_power", "ternaryfunc") - .arguments(&[Ty::Object, Ty::Object]) +const __IPOW__: SlotDef = SlotDef::new("Py_nb_inplace_power", "ipowfunc") + .arguments(&[Ty::Object, Ty::IPowModulo]) .extract_error_mode(ExtractErrorMode::NotImplemented) .return_self(); const __ILSHIFT__: SlotDef = SlotDef::new("Py_nb_inplace_lshift", "binaryfunc") @@ -613,6 +613,7 @@ enum Ty { Object, MaybeNullObject, NonNullObject, + IPowModulo, CompareOp, Int, PyHashT, @@ -626,6 +627,7 @@ impl Ty { match self { Ty::Object | Ty::MaybeNullObject => quote! { *mut _pyo3::ffi::PyObject }, Ty::NonNullObject => quote! { ::std::ptr::NonNull<_pyo3::ffi::PyObject> }, + Ty::IPowModulo => quote! { _pyo3::impl_::pymethods::IPowModulo }, Ty::Int | Ty::CompareOp => quote! { ::std::os::raw::c_int }, Ty::PyHashT => quote! { _pyo3::ffi::Py_hash_t }, Ty::PySsizeT => quote! { _pyo3::ffi::Py_ssize_t }, @@ -679,6 +681,16 @@ impl Ty { ); extract_object(cls, arg.ty, ident, extract) } + Ty::IPowModulo => { + let extract = handle_error( + extract_error_mode, + py, + quote! { + #ident.extract(#py) + }, + ); + extract_object(cls, arg.ty, ident, extract) + } Ty::CompareOp => { let extract = handle_error( extract_error_mode, @@ -888,8 +900,11 @@ fn generate_method_body( ) -> Result { let self_conversion = spec.tp.self_conversion(Some(cls), extract_error_mode); let rust_name = spec.name; - let (arg_idents, conversions) = + let (arg_idents, arg_count, conversions) = extract_proto_arguments(cls, py, &spec.args, arguments, extract_error_mode)?; + if arg_count != arguments.len() { + bail_spanned!(spec.name.span() => format!("Expected {} arguments, got {}", arguments.len(), arg_count)); + } let call = quote! { _pyo3::callback::convert(#py, #cls::#rust_name(_slf, #(#arg_idents),*)) }; let body = if let Some(return_mode) = return_mode { return_mode.return_call_output(py, call) @@ -1058,7 +1073,7 @@ fn extract_proto_arguments( method_args: &[FnArg], proto_args: &[Ty], extract_error_mode: ExtractErrorMode, -) -> Result<(Vec, TokenStream)> { +) -> Result<(Vec, usize, TokenStream)> { let mut arg_idents = Vec::with_capacity(method_args.len()); let mut non_python_args = 0; @@ -1077,9 +1092,8 @@ fn extract_proto_arguments( arg_idents.push(ident); } } - let conversions = quote!(#(#args_conversions)*); - Ok((arg_idents, conversions)) + Ok((arg_idents, non_python_args, conversions)) } struct StaticIdent(&'static str); diff --git a/src/class/number.rs b/src/class/number.rs index 2b0c2ade799..b320f0c1bcd 100644 --- a/src/class/number.rs +++ b/src/class/number.rs @@ -221,7 +221,7 @@ pub trait PyNumberProtocol<'p>: PyClass { { unimplemented!() } - fn __ipow__(&'p mut self, other: Self::Other) -> Self::Result + fn __ipow__(&'p mut self, other: Self::Other, modulo: Option) -> Self::Result where Self: PyNumberIPowProtocol<'p>, { @@ -504,6 +504,8 @@ pub trait PyNumberIDivmodProtocol<'p>: PyNumberProtocol<'p> { pub trait PyNumberIPowProtocol<'p>: PyNumberProtocol<'p> { type Other: FromPyObject<'p>; type Result: IntoPyCallbackOutput<()>; + // See https://bugs.python.org/issue36379 + type Modulo: FromPyObject<'p>; } #[allow(clippy::upper_case_acronyms)] @@ -718,17 +720,28 @@ py_binary_self_func!(imod, PyNumberIModProtocol, T::__imod__); pub unsafe extern "C" fn ipow( slf: *mut ffi::PyObject, other: *mut ffi::PyObject, - _modulo: *mut ffi::PyObject, + modulo: crate::impl_::pymethods::IPowModulo, ) -> *mut ffi::PyObject where T: for<'p> PyNumberIPowProtocol<'p>, { - // NOTE: Somehow __ipow__ causes SIGSEGV in Python < 3.8 when we extract, - // so we ignore it. It's the same as what CPython does. crate::callback_body!(py, { let slf_cell = py.from_borrowed_ptr::>(slf); let other = py.from_borrowed_ptr::(other); - call_operator_mut!(py, slf_cell, __ipow__, other).convert(py)?; + slf_cell + .try_borrow_mut()? + .__ipow__( + extract_or_return_not_implemented!(other), + match modulo.extract(py) { + Ok(value) => value, + Err(_) => { + let res = crate::ffi::Py_NotImplemented(); + crate::ffi::Py_INCREF(res); + return Ok(res); + } + }, + ) + .convert(py)?; ffi::Py_INCREF(slf); Ok::<_, PyErr>(slf) }) diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs index 428c71c6694..82e59e9920f 100644 --- a/src/ffi/mod.rs +++ b/src/ffi/mod.rs @@ -204,3 +204,7 @@ mod cpython; #[cfg(not(Py_LIMITED_API))] pub use self::cpython::*; + +/// Helper to enable #\[pymethods\] to see the workaround for __ipow__ on Python 3.7 +#[doc(hidden)] +pub use crate::impl_::pymethods::ipowfunc; diff --git a/src/impl_.rs b/src/impl_.rs index d591886f901..3a35a8788b8 100644 --- a/src/impl_.rs +++ b/src/impl_.rs @@ -12,4 +12,6 @@ pub mod frompyobject; pub(crate) mod not_send; #[doc(hidden)] pub mod pyclass; +#[doc(hidden)] +pub mod pymethods; pub mod pymodule; diff --git a/src/impl_/pymethods.rs b/src/impl_/pymethods.rs new file mode 100644 index 00000000000..2a8d743a9c0 --- /dev/null +++ b/src/impl_/pymethods.rs @@ -0,0 +1,33 @@ +use crate::{ffi, FromPyObject, PyAny, PyResult, Python}; + +/// Python 3.8 and up - __ipow__ has modulo argument correctly populated. +#[cfg(Py_3_8)] +#[repr(transparent)] +pub struct IPowModulo(*mut ffi::PyObject); + +/// Python 3.7 and older - __ipow__ does not have modulo argument correctly populated. +#[cfg(not(Py_3_8))] +#[repr(transparent)] +pub struct IPowModulo(std::mem::MaybeUninit<*mut ffi::PyObject>); + +/// Helper to use as pymethod ffi definition +#[allow(non_camel_case_types)] +pub type ipowfunc = unsafe extern "C" fn( + arg1: *mut ffi::PyObject, + arg2: *mut ffi::PyObject, + arg3: IPowModulo, +) -> *mut ffi::PyObject; + +impl IPowModulo { + #[cfg(Py_3_8)] + #[inline] + pub fn extract<'a, T: FromPyObject<'a>>(self, py: Python<'a>) -> PyResult { + unsafe { py.from_borrowed_ptr::(self.0) }.extract() + } + + #[cfg(not(Py_3_8))] + #[inline] + pub fn extract<'a, T: FromPyObject<'a>>(self, py: Python<'a>) -> PyResult { + unsafe { py.from_borrowed_ptr::(ffi::Py_None()) }.extract() + } +} diff --git a/src/test_hygiene/pymethods.rs b/src/test_hygiene/pymethods.rs index 832e72396d3..e46112288b2 100644 --- a/src/test_hygiene/pymethods.rs +++ b/src/test_hygiene/pymethods.rs @@ -9,6 +9,7 @@ pub struct Dummy; #[pyo3(crate = "crate")] pub struct DummyIter; +#[cfg(Py_3_8)] #[crate::pymethods] #[pyo3(crate = "crate")] impl Dummy { @@ -401,3 +402,396 @@ impl Dummy { // PyGcProtocol // Buffer protocol? } + +#[cfg(not(Py_3_8))] +#[crate::pymethods] +#[pyo3(crate = "crate")] +impl Dummy { + ////////////////////// + // Basic customization + ////////////////////// + fn __repr__(&self) -> &'static str { + "Dummy" + } + + fn __str__(&self) -> &'static str { + "Dummy" + } + + fn __bytes__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyBytes { + crate::types::PyBytes::new(py, &[0]) + } + + fn __format__(&self, format_spec: ::std::string::String) -> ::std::string::String { + ::std::panic!("unimplemented isn't hygienic before 1.50") + } + + fn __lt__(&self, other: &Self) -> bool { + false + } + + fn __le__(&self, other: &Self) -> bool { + false + } + fn __eq__(&self, other: &Self) -> bool { + false + } + fn __ne__(&self, other: &Self) -> bool { + false + } + fn __gt__(&self, other: &Self) -> bool { + false + } + fn __ge__(&self, other: &Self) -> bool { + false + } + + fn __hash__(&self) -> u64 { + 42 + } + + fn __bool__(&self) -> bool { + true + } + + ////////////////////// + // Customizing attribute access + ////////////////////// + + fn __getattr__(&self, name: ::std::string::String) -> &crate::PyAny { + ::std::panic!("unimplemented isn't hygienic before 1.50") + } + + fn __getattribute__(&self, name: ::std::string::String) -> &crate::PyAny { + ::std::panic!("unimplemented isn't hygienic before 1.50") + } + + fn __setattr__(&mut self, name: ::std::string::String, value: ::std::string::String) {} + + fn __delattr__(&mut self, name: ::std::string::String) {} + + fn __dir__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyList { + crate::types::PyList::new(py, ::std::vec![0_u8]) + } + + ////////////////////// + // Implementing Descriptors + ////////////////////// + + fn __get__( + &self, + instance: &crate::PyAny, + owner: &crate::PyAny, + ) -> crate::PyResult<&crate::PyAny> { + ::std::panic!("unimplemented isn't hygienic before 1.50") + } + + fn __set__(&self, instance: &crate::PyAny, owner: &crate::PyAny) {} + + fn __delete__(&self, instance: &crate::PyAny) {} + + fn __set_name__(&self, owner: &crate::PyAny, name: &crate::PyAny) {} + + ////////////////////// + // Implementing Descriptors + ////////////////////// + + fn __len__(&self) -> usize { + 0 + } + + fn __getitem__(&self, key: u32) -> crate::PyResult { + ::std::result::Result::Err(crate::exceptions::PyKeyError::new_err("boo")) + } + + fn __setitem__(&self, key: u32, value: u32) {} + + fn __delitem__(&self, key: u32) {} + + fn __iter__(_: crate::pycell::PyRef, py: crate::Python) -> crate::Py { + crate::Py::new(py, DummyIter {}).unwrap() + } + + fn __next__(&mut self) -> ::std::option::Option<()> { + ::std::option::Option::None + } + + fn __reversed__(slf: crate::pycell::PyRef, py: crate::Python) -> crate::Py { + crate::Py::new(py, DummyIter {}).unwrap() + } + + fn __contains__(&self, item: u32) -> bool { + false + } + + ////////////////////// + // Emulating numeric types + ////////////////////// + + fn __add__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __sub__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __mul__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __truediv__(&self, _other: &Self) -> crate::PyResult<()> { + ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo")) + } + + fn __floordiv__(&self, _other: &Self) -> crate::PyResult<()> { + ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo")) + } + + fn __mod__(&self, _other: &Self) -> u32 { + 0 + } + + fn __divmod__(&self, _other: &Self) -> (u32, u32) { + (0, 0) + } + + fn __pow__(&self, _other: &Self, modulo: ::std::option::Option) -> Dummy { + Dummy {} + } + + fn __lshift__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rshift__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __and__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __xor__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __or__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __radd__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rrsub__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rmul__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rtruediv__(&self, _other: &Self) -> crate::PyResult<()> { + ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo")) + } + + fn __rfloordiv__(&self, _other: &Self) -> crate::PyResult<()> { + ::std::result::Result::Err(crate::exceptions::PyZeroDivisionError::new_err("boo")) + } + + fn __rmod__(&self, _other: &Self) -> u32 { + 0 + } + + fn __rdivmod__(&self, _other: &Self) -> (u32, u32) { + (0, 0) + } + + fn __rpow__(&self, _other: &Self, modulo: ::std::option::Option) -> Dummy { + Dummy {} + } + + fn __rlshift__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rrshift__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rand__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __rxor__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __ror__(&self, other: &Self) -> Dummy { + Dummy {} + } + + fn __iadd__(&mut self, other: &Self) {} + + fn __irsub__(&mut self, other: &Self) {} + + fn __imul__(&mut self, other: &Self) {} + + fn __itruediv__(&mut self, _other: &Self) {} + + fn __ifloordiv__(&mut self, _other: &Self) {} + + fn __imod__(&mut self, _other: &Self) {} + + fn __ipow__(&mut self, _other: &Self, _modulo: ::std::option::Option) {} + fn __ilshift__(&mut self, other: &Self) {} + + fn __irshift__(&mut self, other: &Self) {} + + fn __iand__(&mut self, other: &Self) {} + + fn __ixor__(&mut self, other: &Self) {} + + fn __ior__(&mut self, other: &Self) {} + + fn __neg__(slf: crate::pycell::PyRef) -> crate::pycell::PyRef { + slf + } + + fn __pos__(slf: crate::pycell::PyRef) -> crate::pycell::PyRef { + slf + } + + fn __abs__(slf: crate::pycell::PyRef) -> crate::pycell::PyRef { + slf + } + + fn __invert__(slf: crate::pycell::PyRef) -> crate::pycell::PyRef { + slf + } + + fn __complex__<'py>(&self, py: crate::Python<'py>) -> &'py crate::types::PyComplex { + crate::types::PyComplex::from_doubles(py, 0.0, 0.0) + } + + fn __int__(&self) -> u32 { + 0 + } + + fn __float__(&self) -> f64 { + 0.0 + } + + fn __index__(&self) -> u32 { + 0 + } + + fn __round__(&self, ndigits: ::std::option::Option) -> u32 { + 0 + } + + fn __trunc__(&self) -> u32 { + 0 + } + + fn __floor__(&self) -> u32 { + 0 + } + + fn __ceil__(&self) -> u32 { + 0 + } + + ////////////////////// + // With Statement Context Managers + ////////////////////// + + fn __enter__(&mut self) {} + + fn __exit__( + &mut self, + exc_type: &crate::PyAny, + exc_value: &crate::PyAny, + traceback: &crate::PyAny, + ) { + } + + ////////////////////// + // Awaitable Objects + ////////////////////// + + fn __await__(slf: crate::pycell::PyRef) -> crate::pycell::PyRef { + slf + } + + ////////////////////// + + // Asynchronous Iterators + ////////////////////// + + fn __aiter__(slf: crate::pycell::PyRef, py: crate::Python) -> crate::Py { + crate::Py::new(py, DummyIter {}).unwrap() + } + + fn __anext__(&mut self) -> ::std::option::Option<()> { + ::std::option::Option::None + } + + ////////////////////// + // Asynchronous Context Managers + ////////////////////// + + fn __aenter__(&mut self) {} + + fn __aexit__( + &mut self, + exc_type: &crate::PyAny, + exc_value: &crate::PyAny, + traceback: &crate::PyAny, + ) { + } + + // Things with attributes + + #[args(x = "1", "*", _z = "2")] + fn test(&self, _y: &Dummy, _z: i32) {} + #[staticmethod] + fn staticmethod() {} + #[classmethod] + fn clsmethod(_: &crate::types::PyType) {} + #[args(args = "*", kwds = "**")] + fn __call__( + &self, + _args: &crate::types::PyTuple, + _kwds: ::std::option::Option<&crate::types::PyDict>, + ) -> crate::PyResult { + ::std::panic!("unimplemented isn't hygienic before 1.50") + } + #[new] + fn new(a: u8) -> Self { + Dummy {} + } + #[getter] + fn get(&self) -> i32 { + 0 + } + #[setter] + fn set(&mut self, _v: i32) {} + #[classattr] + fn class_attr() -> i32 { + 0 + } + + // Dunder methods invented for protocols + + fn __richcmp__( + &self, + other: &Self, + op: crate::class::basic::CompareOp, + ) -> crate::PyResult { + ::std::result::Result::Ok(false) + } + // PyGcProtocol + // Buffer protocol? +} diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs index 5d9e2b1a316..ed1870bbcbe 100644 --- a/tests/test_arithmetics.rs +++ b/tests/test_arithmetics.rs @@ -95,7 +95,7 @@ impl InPlaceOperations { self.value |= other; } - fn __ipow__(&mut self, other: u32) { + fn __ipow__(&mut self, other: u32, _modulo: Option) { self.value = self.value.pow(other); } } @@ -566,12 +566,12 @@ mod return_not_implemented { fn __itruediv__(&mut self, _other: PyRef) {} fn __ifloordiv__(&mut self, _other: PyRef) {} fn __imod__(&mut self, _other: PyRef) {} - fn __ipow__(&mut self, _other: PyRef) {} fn __ilshift__(&mut self, _other: PyRef) {} fn __irshift__(&mut self, _other: PyRef) {} fn __iand__(&mut self, _other: PyRef) {} fn __ior__(&mut self, _other: PyRef) {} fn __ixor__(&mut self, _other: PyRef) {} + fn __ipow__(&mut self, _other: PyRef, _modulo: Option) {} } fn _test_binary_dunder(dunder: &str) { diff --git a/tests/test_arithmetics_protos.rs b/tests/test_arithmetics_protos.rs index b57c5f49268..86b30c1385e 100644 --- a/tests/test_arithmetics_protos.rs +++ b/tests/test_arithmetics_protos.rs @@ -108,11 +108,10 @@ impl PyNumberProtocol for InPlaceOperations { self.value |= other; } - fn __ipow__(&mut self, other: u32) { + fn __ipow__(&mut self, other: u32, _modulo: Option) { self.value = self.value.pow(other); } } - #[test] fn inplace_operations() { let gil = Python::acquire_gil(); @@ -589,7 +588,7 @@ mod return_not_implemented { fn __itruediv__(&'p mut self, _other: PyRef<'p, Self>) {} fn __ifloordiv__(&'p mut self, _other: PyRef<'p, Self>) {} fn __imod__(&'p mut self, _other: PyRef<'p, Self>) {} - fn __ipow__(&'p mut self, _other: PyRef<'p, Self>) {} + fn __ipow__(&'p mut self, _other: PyRef<'p, Self>, _modulo: Option) {} fn __ilshift__(&'p mut self, _other: PyRef<'p, Self>) {} fn __irshift__(&'p mut self, _other: PyRef<'p, Self>) {} fn __iand__(&'p mut self, _other: PyRef<'p, Self>) {} diff --git a/tests/test_compile_error.rs b/tests/test_compile_error.rs index fb3ad6686b1..7bf7312d74e 100644 --- a/tests/test_compile_error.rs +++ b/tests/test_compile_error.rs @@ -32,6 +32,8 @@ fn _test_compile_errors() { t.compile_fail("tests/ui/missing_clone.rs"); t.compile_fail("tests/ui/reject_generics.rs"); t.compile_fail("tests/ui/not_send.rs"); + t.compile_fail("tests/ui/invalid_pymethod_proto_args.rs"); + t.compile_fail("tests/ui/invalid_pymethod_proto_args_py.rs"); tests_rust_1_49(&t); tests_rust_1_55(&t); diff --git a/tests/ui/invalid_pymethod_proto_args.rs b/tests/ui/invalid_pymethod_proto_args.rs new file mode 100644 index 00000000000..3c3e96ab3b6 --- /dev/null +++ b/tests/ui/invalid_pymethod_proto_args.rs @@ -0,0 +1,13 @@ +use pyo3::prelude::*; + +#[pyclass] +struct MyClass {} + +#[pymethods] +impl MyClass { + fn __truediv__(&self) -> PyResult<()> { + Ok(()) + } +} + +fn main() {} diff --git a/tests/ui/invalid_pymethod_proto_args.stderr b/tests/ui/invalid_pymethod_proto_args.stderr new file mode 100644 index 00000000000..04d77c76308 --- /dev/null +++ b/tests/ui/invalid_pymethod_proto_args.stderr @@ -0,0 +1,5 @@ +error: Expected 1 arguments, got 0 + --> tests/ui/invalid_pymethod_proto_args.rs:8:8 + | +8 | fn __truediv__(&self) -> PyResult<()> { + | ^^^^^^^^^^^ diff --git a/tests/ui/invalid_pymethod_proto_args_py.rs b/tests/ui/invalid_pymethod_proto_args_py.rs new file mode 100644 index 00000000000..e5f9345f0b9 --- /dev/null +++ b/tests/ui/invalid_pymethod_proto_args_py.rs @@ -0,0 +1,13 @@ +use pyo3::prelude::*; + +#[pyclass] +struct MyClass {} + +#[pymethods] +impl MyClass { + fn __truediv__(&self, _py: Python) -> PyResult<()> { + Ok(()) + } +} + +fn main() {} diff --git a/tests/ui/invalid_pymethod_proto_args_py.stderr b/tests/ui/invalid_pymethod_proto_args_py.stderr new file mode 100644 index 00000000000..5661ed450d7 --- /dev/null +++ b/tests/ui/invalid_pymethod_proto_args_py.stderr @@ -0,0 +1,5 @@ +error: Expected 1 arguments, got 0 + --> tests/ui/invalid_pymethod_proto_args_py.rs:8:8 + | +8 | fn __truediv__(&self, _py: Python) -> PyResult<()> { + | ^^^^^^^^^^^