Make __r*__ methods work with operators

pyo3-derive-backend/src/defs.rs

@@ -7,6 +7,21 @@ pub struct Proto {
     pub py_methods: &'static [PyMethod],
 }
 
+impl Proto {
+    pub(crate) fn get_proto<Q>(&self, query: Q) -> Option<&'static MethodProto>
+    where
+        Q: PartialEq<&'static str>,
+    {
+        self.methods.iter().find(|m| query == m.name())
+    }
+    pub(crate) fn get_method<Q>(&self, query: Q) -> Option<&'static PyMethod>
+    where
+        Q: PartialEq<&'static str>,
+    {
+        self.py_methods.iter().find(|m| query == m.name)
+    }
+}
+
 pub struct PyMethod {
     pub name: &'static str,
     pub proto: &'static str,

pyo3-derive-backend/src/func.rs

@@ -69,7 +69,7 @@ impl MethodProto {
     }
 }
 
-pub fn impl_method_proto(
+pub(crate) fn impl_method_proto(
     cls: &syn::Type,
     sig: &mut syn::Signature,
     meth: &MethodProto,

pyo3-derive-backend/src/pyclass.rs

@@ -459,7 +459,6 @@ fn impl_descriptors(
         .collect::<syn::Result<_>>()?;
 
     Ok(quote! {
-
         pyo3::inventory::submit! {
             #![crate = pyo3] {
                 type ClsInventory = <#cls as pyo3::class::methods::PyMethodsInventoryDispatch>::InventoryType;

pyo3-derive-backend/src/pyproto.rs

@@ -63,39 +63,35 @@ fn impl_proto_impl(
 
     for iimpl in impls.iter_mut() {
         if let syn::ImplItem::Method(ref mut met) = iimpl {
-            for m in proto.methods {
-                if met.sig.ident == m.name() {
-                    impl_method_proto(ty, &mut met.sig, m).to_tokens(&mut tokens);
-                }
+            if let Some(m) = proto.get_proto(&met.sig.ident) {
+                impl_method_proto(ty, &mut met.sig, m).to_tokens(&mut tokens);
             }
-            for m in proto.py_methods {
-                if met.sig.ident == m.name {
-                    let name = &met.sig.ident;
-                    let proto: syn::Path = syn::parse_str(m.proto).unwrap();
+            if let Some(m) = proto.get_method(&met.sig.ident) {
+                let name = &met.sig.ident;
+                let proto: syn::Path = syn::parse_str(m.proto).unwrap();
 
-                    let fn_spec = match FnSpec::parse(&met.sig, &mut met.attrs, false) {
-                        Ok(fn_spec) => fn_spec,
-                        Err(err) => return err.to_compile_error(),
-                    };
-                    let meth = pymethod::impl_proto_wrap(ty, &fn_spec);
+                let fn_spec = match FnSpec::parse(&met.sig, &mut met.attrs, false) {
+                    Ok(fn_spec) => fn_spec,
+                    Err(err) => return err.to_compile_error(),
+                };
+                let meth = pymethod::impl_proto_wrap(ty, &fn_spec);
 
-                    py_methods.push(quote! {
-                        impl #proto for #ty
-                        {
-                            #[inline]
-                            fn #name() -> Option<pyo3::class::methods::PyMethodDef> {
-                                #meth
+                py_methods.push(quote! {
+                    impl #proto for #ty
+                    {
+                        #[inline]
+                        fn #name() -> Option<pyo3::class::methods::PyMethodDef> {
+                            #meth
 
-                                Some(pyo3::class::PyMethodDef {
-                                    ml_name: stringify!(#name),
-                                    ml_meth: pyo3::class::PyMethodType::PyCFunctionWithKeywords(__wrap),
-                                    ml_flags: pyo3::ffi::METH_VARARGS | pyo3::ffi::METH_KEYWORDS,
-                                    ml_doc: ""
-                                })
-                            }
+                            Some(pyo3::class::PyMethodDef {
+                                ml_name: stringify!(#name),
+                                ml_meth: pyo3::class::PyMethodType::PyCFunctionWithKeywords(__wrap),
+                                ml_flags: pyo3::ffi::METH_VARARGS | pyo3::ffi::METH_KEYWORDS,
+                                ml_doc: ""
+                            })
                         }
-                    });
-                }
+                    }
+                });
             }
         }
     }

src/class/macros.rs

@@ -127,6 +127,29 @@ macro_rules! py_binary_num_func {
     }};
 }
 
+#[macro_export]
+#[doc(hidden)]
+macro_rules! py_binary_reverse_num_func {
+    ($trait:ident, $class:ident :: $f:ident, $conv:expr) => {{
+        unsafe extern "C" fn wrap<T>(
+            lhs: *mut ffi::PyObject,
+            rhs: *mut ffi::PyObject,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
+        {
+            use $crate::ObjectProtocol;
+            let py = $crate::Python::assume_gil_acquired();
+            let _pool = $crate::GILPool::new(py);
+            // Swap lhs <-> rhs
+            let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(rhs);
+            let arg = py.from_borrowed_ptr::<$crate::PyAny>(lhs);
+            call_ref_with_converter!(slf, $conv, py, $f, arg)
+        }
+        Some(wrap::<$class>)
+    }};
+}
+
 // NOTE(kngwyu): This macro is used only for inplace operations, so I used call_mut here.
 #[macro_export]
 #[doc(hidden)]
@@ -254,6 +277,31 @@ macro_rules! py_ternary_num_func {
     }};
 }
 
+#[macro_export]
+#[doc(hidden)]
+macro_rules! py_ternary_reverse_num_func {
+    ($trait:ident, $class:ident :: $f:ident, $conv:expr) => {{
+        unsafe extern "C" fn wrap<T>(
+            arg1: *mut $crate::ffi::PyObject,
+            arg2: *mut $crate::ffi::PyObject,
+            arg3: *mut $crate::ffi::PyObject,
+        ) -> *mut $crate::ffi::PyObject
+        where
+            T: for<'p> $trait<'p>,
+        {
+            use $crate::ObjectProtocol;
+            let py = $crate::Python::assume_gil_acquired();
+            let _pool = $crate::GILPool::new(py);
+            // Swap lhs <-> rhs
+            let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(arg2);
+            let arg1 = py.from_borrowed_ptr::<$crate::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::PyAny>(arg3);
+            call_ref_with_converter!(slf, $conv, py, $f, arg1, arg2)
+        }
+        Some(wrap::<$class>)
+    }};
+}
+
 #[macro_export]
 #[doc(hidden)]
 macro_rules! py_ternary_self_func {