update extract_argument to use Bound APIs

guide/src/class.md

@@ -1253,7 +1253,7 @@ impl<'a, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a
     type Holder = ::std::option::Option<pyo3::PyRef<'py, MyClass>>;
 
     #[inline]
-    fn extract(obj: &'py pyo3::PyAny, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
+    fn extract(obj: pyo3::impl_::extract_argument::PyArg<'py>, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
         pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
     }
 }
@@ -1263,7 +1263,7 @@ impl<'a, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py> for &'a
     type Holder = ::std::option::Option<pyo3::PyRefMut<'py, MyClass>>;
 
     #[inline]
-    fn extract(obj: &'py pyo3::PyAny, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
+    fn extract(obj: pyo3::impl_::extract_argument::PyArg<'py>, holder: &'a mut Self::Holder) -> pyo3::PyResult<Self> {
         pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
     }
 }

pyo3-benches/benches/bench_comparisons.rs

@@ -45,17 +45,17 @@ impl OrderedRichcmp {
 
 fn bench_ordered_dunder_methods(b: &mut Bencher<'_>) {
     Python::with_gil(|py| {
-        let obj1 = Py::new(py, OrderedDunderMethods(0)).unwrap().into_ref(py);
-        let obj2 = Py::new(py, OrderedDunderMethods(1)).unwrap().into_ref(py);
+        let obj1 = &Bound::new(py, OrderedDunderMethods(0)).unwrap().into_any();
+        let obj2 = &Bound::new(py, OrderedDunderMethods(1)).unwrap().into_any();
 
         b.iter(|| obj2.gt(obj1).unwrap());
     });
 }
 
 fn bench_ordered_richcmp(b: &mut Bencher<'_>) {
     Python::with_gil(|py| {
-        let obj1 = Py::new(py, OrderedRichcmp(0)).unwrap().into_ref(py);
-        let obj2 = Py::new(py, OrderedRichcmp(1)).unwrap().into_ref(py);
+        let obj1 = &Bound::new(py, OrderedRichcmp(0)).unwrap().into_any();
+        let obj2 = &Bound::new(py, OrderedRichcmp(1)).unwrap().into_any();
 
         b.iter(|| obj2.gt(obj1).unwrap());
     });

pyo3-macros-backend/src/method.rs

@@ -199,7 +199,7 @@ impl SelfType {
                 });
                 error_mode.handle_error(quote_spanned! { *span =>
                     _pyo3::impl_::extract_argument::#method::<#cls>(
-                        #py.from_borrowed_ptr::<_pyo3::PyAny>(#slf),
+                        _pyo3::impl_::extract_argument::PyArg::from_ptr(#py, #slf),
                         &mut #holder,
                     )
                 })

pyo3-macros-backend/src/params.rs

@@ -44,8 +44,8 @@ pub fn impl_arg_params(
             .collect::<Result<_>>()?;
         return Ok((
             quote! {
-                let _args = py.from_borrowed_ptr::<_pyo3::types::PyTuple>(_args);
-                let _kwargs: ::std::option::Option<&_pyo3::types::PyDict> = py.from_borrowed_ptr_or_opt(_kwargs);
+                let _args = _pyo3::impl_::extract_argument::PyArg::from_ptr(py, _args);
+                let _kwargs = _pyo3::impl_::extract_argument::PyArg::from_ptr_or_opt(py, _kwargs);
             },
             arg_convert,
         ));
@@ -132,7 +132,7 @@ pub fn impl_arg_params(
                     keyword_only_parameters: &[#(#keyword_only_parameters),*],
                 };
                 let mut #args_array = [::std::option::Option::None; #num_params];
-                let (_args, _kwargs) = #extract_expression;
+                let (_args, _kwargs) = &#extract_expression;
         },
         param_conversion,
     ))
@@ -180,7 +180,8 @@ fn impl_arg_param(
         let holder = push_holder();
         return Ok(quote_arg_span! {
             _pyo3::impl_::extract_argument::extract_argument(
-                _args,
+                #[allow(clippy::useless_conversion)]
+                ::std::convert::From::from(_args),
                 &mut #holder,
                 #name_str
             )?
@@ -193,7 +194,8 @@ fn impl_arg_param(
         let holder = push_holder();
         return Ok(quote_arg_span! {
             _pyo3::impl_::extract_argument::extract_optional_argument(
-                _kwargs.map(::std::convert::AsRef::as_ref),
+                #[allow(clippy::useless_conversion, clippy::redundant_closure)]
+                _kwargs.as_ref().map(|kwargs| ::std::convert::From::from(kwargs)),
                 &mut #holder,
                 #name_str,
                 || ::std::option::Option::None
@@ -217,7 +219,7 @@ fn impl_arg_param(
             quote_arg_span! {
                 #[allow(clippy::redundant_closure)]
                 _pyo3::impl_::extract_argument::from_py_with_with_default(
-                    #arg_value.map(_pyo3::PyNativeType::as_borrowed).as_deref(),
+                    #arg_value.map(_pyo3::impl_::extract_argument::PyArg::as_borrowed).as_deref(),
                     #name_str,
                     #expr_path as fn(_) -> _,
                     || #default

pyo3-macros-backend/src/pyclass.rs

@@ -1369,7 +1369,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                     type Holder = ::std::option::Option<_pyo3::PyRef<'py, #cls>>;
 
                     #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
+                    fn extract(obj: _pyo3::impl_::extract_argument::PyArg<'py>, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
                         _pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
                     }
                 }
@@ -1381,7 +1381,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                     type Holder = ::std::option::Option<_pyo3::PyRef<'py, #cls>>;
 
                     #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
+                    fn extract(obj: _pyo3::impl_::extract_argument::PyArg<'py>, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
                         _pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
                     }
                 }
@@ -1391,7 +1391,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                     type Holder = ::std::option::Option<_pyo3::PyRefMut<'py, #cls>>;
 
                     #[inline]
-                    fn extract(obj: &'py _pyo3::PyAny, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
+                    fn extract(obj: _pyo3::impl_::extract_argument::PyArg<'py>, holder: &'a mut Self::Holder) -> _pyo3::PyResult<Self> {
                         _pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
                     }
                 }

pyo3-macros-backend/src/pymethod.rs

@@ -930,39 +930,31 @@ impl Ty {
                 extract_error_mode,
                 holders,
                 &name_str,
-                quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(#ident)
-                },
+                quote! { #ident },
             ),
             Ty::MaybeNullObject => extract_object(
                 extract_error_mode,
                 holders,
                 &name_str,
                 quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(
-                        if #ident.is_null() {
-                            _pyo3::ffi::Py_None()
-                        } else {
-                            #ident
-                        }
-                    )
+                    if #ident.is_null() {
+                        _pyo3::ffi::Py_None()
+                    } else {
+                        #ident
+                    }
                 },
             ),
             Ty::NonNullObject => extract_object(
                 extract_error_mode,
                 holders,
                 &name_str,
-                quote! {
-                    py.from_borrowed_ptr::<_pyo3::PyAny>(#ident.as_ptr())
-                },
+                quote! { #ident.as_ptr() },
             ),
             Ty::IPowModulo => extract_object(
                 extract_error_mode,
                 holders,
                 &name_str,
-                quote! {
-                    #ident.to_borrowed_any(py)
-                },
+                quote! { #ident.as_ptr() },
             ),
             Ty::CompareOp => extract_error_mode.handle_error(
                 quote! {
@@ -988,7 +980,7 @@ fn extract_object(
     extract_error_mode: ExtractErrorMode,
     holders: &mut Vec<TokenStream>,
     name: &str,
-    source: TokenStream,
+    source_ptr: TokenStream,
 ) -> TokenStream {
     let holder = syn::Ident::new(&format!("holder_{}", holders.len()), Span::call_site());
     holders.push(quote! {
@@ -997,7 +989,7 @@ fn extract_object(
     });
     extract_error_mode.handle_error(quote! {
         _pyo3::impl_::extract_argument::extract_argument(
-            #source,
+            _pyo3::impl_::extract_argument::PyArg::from_ptr(py, #source_ptr),
             &mut #holder,
             #name
         )

pyo3-macros-backend/src/quotes.rs

@@ -16,6 +16,7 @@ pub(crate) fn ok_wrap(obj: TokenStream) -> TokenStream {
 
 pub(crate) fn map_result_into_ptr(result: TokenStream) -> TokenStream {
     quote! {
-        _pyo3::impl_::wrap::map_result_into_ptr(py, #result)
+        let result = _pyo3::impl_::wrap::map_result_into_ptr(py, #result);
+        result
     }
 }

pytests/src/pyfunctions.rs

@@ -4,62 +4,66 @@ use pyo3::types::{PyDict, PyTuple};
 #[pyfunction(signature = ())]
 fn none() {}
 
+type Any<'py> = Bound<'py, PyAny>;
+type Dict<'py> = Bound<'py, PyDict>;
+type Tuple<'py> = Bound<'py, PyTuple>;
+
 #[pyfunction(signature = (a, b = None, *, c = None))]
-fn simple<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    c: Option<&'a PyAny>,
-) -> (&'a PyAny, Option<&'a PyAny>, Option<&'a PyAny>) {
+fn simple<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    c: Option<Any<'py>>,
+) -> (Any<'py>, Option<Any<'py>>, Option<Any<'py>>) {
     (a, b, c)
 }
 
 #[pyfunction(signature = (a, b = None, *args, c = None))]
-fn simple_args<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    args: &'a PyTuple,
-    c: Option<&'a PyAny>,
-) -> (&'a PyAny, Option<&'a PyAny>, &'a PyTuple, Option<&'a PyAny>) {
+fn simple_args<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    args: Tuple<'py>,
+    c: Option<Any<'py>>,
+) -> (Any<'py>, Option<Any<'py>>, Tuple<'py>, Option<Any<'py>>) {
     (a, b, args, c)
 }
 
 #[pyfunction(signature = (a, b = None, c = None, **kwargs))]
-fn simple_kwargs<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    c: Option<&'a PyAny>,
-    kwargs: Option<&'a PyDict>,
+fn simple_kwargs<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    c: Option<Any<'py>>,
+    kwargs: Option<Dict<'py>>,
 ) -> (
-    &'a PyAny,
-    Option<&'a PyAny>,
-    Option<&'a PyAny>,
-    Option<&'a PyDict>,
+    Any<'py>,
+    Option<Any<'py>>,
+    Option<Any<'py>>,
+    Option<Dict<'py>>,
 ) {
     (a, b, c, kwargs)
 }
 
 #[pyfunction(signature = (a, b = None, *args, c = None, **kwargs))]
-fn simple_args_kwargs<'a>(
-    a: &'a PyAny,
-    b: Option<&'a PyAny>,
-    args: &'a PyTuple,
-    c: Option<&'a PyAny>,
-    kwargs: Option<&'a PyDict>,
+fn simple_args_kwargs<'py>(
+    a: Any<'py>,
+    b: Option<Any<'py>>,
+    args: Tuple<'py>,
+    c: Option<Any<'py>>,
+    kwargs: Option<Dict<'py>>,
 ) -> (
-    &'a PyAny,
-    Option<&'a PyAny>,
-    &'a PyTuple,
-    Option<&'a PyAny>,
-    Option<&'a PyDict>,
+    Any<'py>,
+    Option<Any<'py>>,
+    Tuple<'py>,
+    Option<Any<'py>>,
+    Option<Dict<'py>>,
 ) {
     (a, b, args, c, kwargs)
 }
 
 #[pyfunction(signature = (*args, **kwargs))]
-fn args_kwargs<'a>(
-    args: &'a PyTuple,
-    kwargs: Option<&'a PyDict>,
-) -> (&'a PyTuple, Option<&'a PyDict>) {
+fn args_kwargs<'py>(
+    args: Tuple<'py>,
+    kwargs: Option<Dict<'py>>,
+) -> (Tuple<'py>, Option<Dict<'py>>) {
     (args, kwargs)
 }