Merge pull request RustPython#4735 from youknowone/try_from_borrowed_object

apply TryFromBorrowed more

Author: youknowone

src/lib.rs

@@ -106,7 +106,6 @@ fn setup_main_module(vm: &VirtualMachine) -> PyResult<Scope> {
         .expect("Failed to initialize __main__.__annotations__");
 
     vm.sys_module
-        .clone()
         .get_attr("modules", vm)?
         .set_item("__main__", main_module, vm)?;
 

src/shell.rs

@@ -105,7 +105,6 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
         let prompt_name = if continuing { "ps2" } else { "ps1" };
         let prompt = vm
             .sys_module
-            .clone()
             .get_attr(prompt_name, vm)
             .and_then(|prompt| prompt.str(vm));
         let prompt = match prompt {

stdlib/src/array.rs

@@ -44,10 +44,10 @@ mod array {
             atomic_func,
             builtins::{
                 PositionIterInternal, PyByteArray, PyBytes, PyBytesRef, PyDictRef, PyFloat, PyInt,
-                PyIntRef, PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyTypeRef,
+                PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyTypeRef,
             },
             class_or_notimplemented,
-            convert::{ToPyObject, ToPyResult, TryFromObject},
+            convert::{ToPyObject, ToPyResult, TryFromBorrowedObject, TryFromObject},
             function::{
                 ArgBytesLike, ArgIntoFloat, ArgIterable, KwArgs, OptionalArg, PyComparisonValue,
             },
@@ -828,7 +828,7 @@ mod array {
 
         #[pymethod]
         fn fromunicode(zelf: &Py<Self>, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let utf8 = PyStrRef::try_from_object(vm, obj.clone()).map_err(|_| {
+            let utf8: &str = obj.try_to_value(vm).map_err(|_| {
                 vm.new_type_error(format!(
                     "fromunicode() argument must be str, not {}",
                     obj.class().name()
@@ -840,7 +840,7 @@ mod array {
                 ));
             }
             let mut w = zelf.try_resizable(vm)?;
-            let bytes = Self::_unicode_to_wchar_bytes(utf8.as_str(), w.itemsize());
+            let bytes = Self::_unicode_to_wchar_bytes(utf8, w.itemsize());
             w.frombytes_move(bytes);
             Ok(())
         }
@@ -1489,9 +1489,9 @@ mod array {
         }
     }
 
-    impl TryFromObject for MachineFormatCode {
-        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            PyIntRef::try_from_object(vm, obj.clone())
+    impl<'a> TryFromBorrowedObject<'a> for MachineFormatCode {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+            obj.try_to_ref::<PyInt>(vm)
                 .map_err(|_| {
                     vm.new_type_error(format!(
                         "an integer is required (got type {})",

stdlib/src/csv.rs

@@ -4,7 +4,7 @@ pub(crate) use _csv::make_module;
 mod _csv {
     use crate::common::lock::PyMutex;
     use crate::vm::{
-        builtins::{PyStr, PyStrRef, PyTypeRef},
+        builtins::{PyStr, PyTypeRef},
         function::{ArgIterable, ArgumentError, FromArgs, FuncArgs},
         match_class,
         protocol::{PyIter, PyIterReturn},
@@ -97,8 +97,8 @@ mod _csv {
     impl FromArgs for FormatOptions {
         fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
             let delimiter = if let Some(delimiter) = args.kwargs.remove("delimiter") {
-                PyStrRef::try_from_object(vm, delimiter)?
-                    .as_str()
+                delimiter
+                    .try_to_value::<&str>(vm)?
                     .bytes()
                     .exactly_one()
                     .map_err(|_| {
@@ -110,8 +110,8 @@ mod _csv {
             };
 
             let quotechar = if let Some(quotechar) = args.kwargs.remove("quotechar") {
-                PyStrRef::try_from_object(vm, quotechar)?
-                    .as_str()
+                quotechar
+                    .try_to_value::<&str>(vm)?
                     .bytes()
                     .exactly_one()
                     .map_err(|_| {

vm/src/anystr.rs

@@ -1,8 +1,9 @@
 use crate::{
-    builtins::{PyIntRef, PyTupleRef},
+    builtins::{PyIntRef, PyTuple},
     cformat::cformat_string,
+    convert::TryFromBorrowedObject,
     function::OptionalOption,
-    PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
 };
 use num_traits::{cast::ToPrimitive, sign::Signed};
 
@@ -213,21 +214,21 @@ pub trait AnyStr {
         F: Fn(&Self) -> PyObjectRef;
 
     #[inline]
-    fn py_startsendswith<T, F>(
+    fn py_startsendswith<'a, T, F>(
         &self,
-        affix: PyObjectRef,
+        affix: &'a PyObject,
         func_name: &str,
         py_type_name: &str,
         func: F,
         vm: &VirtualMachine,
     ) -> PyResult<bool>
     where
-        T: TryFromObject,
-        F: Fn(&Self, &T) -> bool,
+        T: TryFromBorrowedObject<'a>,
+        F: Fn(&Self, T) -> bool,
     {
         single_or_tuple_any(
             affix,
-            &|s: &T| Ok(func(self, s)),
+            &|s: T| Ok(func(self, s)),
             &|o| {
                 format!(
                     "{} first arg must be {} or a tuple of {}, not {}",
@@ -448,24 +449,25 @@ pub trait AnyStr {
 /// test that any of the values contained within the tuples satisfies the predicate. Type parameter
 /// T specifies the type that is expected, if the input value is not of that type or a tuple of
 /// values of that type, then a TypeError is raised.
-pub fn single_or_tuple_any<T, F, M>(
-    obj: PyObjectRef,
+pub fn single_or_tuple_any<'a, T, F, M>(
+    obj: &'a PyObject,
     predicate: &F,
     message: &M,
     vm: &VirtualMachine,
 ) -> PyResult<bool>
 where
-    T: TryFromObject,
-    F: Fn(&T) -> PyResult<bool>,
+    T: TryFromBorrowedObject<'a>,
+    F: Fn(T) -> PyResult<bool>,
     M: Fn(&PyObject) -> String,
 {
-    match T::try_from_object(vm, obj.clone()) {
-        Ok(single) => (predicate)(&single),
+    match obj.try_to_value::<T>(vm) {
+        Ok(single) => (predicate)(single),
         Err(_) => {
-            let tuple = PyTupleRef::try_from_object(vm, obj.clone())
-                .map_err(|_| vm.new_type_error((message)(&obj)))?;
-            for obj in &tuple {
-                if single_or_tuple_any(obj.clone(), predicate, message, vm)? {
+            let tuple: &Py<PyTuple> = obj
+                .try_to_value(vm)
+                .map_err(|_| vm.new_type_error((message)(obj)))?;
+            for obj in tuple {
+                if single_or_tuple_any(obj, predicate, message, vm)? {
                     return Ok(true);
                 }
             }

vm/src/builtins/bytearray.rs

@@ -375,10 +375,10 @@ impl PyByteArray {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "endswith",
             "bytes",
-            |s, x: &PyBytesInner| s.ends_with(x.as_bytes()),
+            |s, x: PyBytesInner| s.ends_with(x.as_bytes()),
             vm,
         )
     }
@@ -396,10 +396,10 @@ impl PyByteArray {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "startswith",
             "bytes",
-            |s, x: &PyBytesInner| s.starts_with(x.as_bytes()),
+            |s, x: PyBytesInner| s.starts_with(x.as_bytes()),
             vm,
         )
     }

vm/src/builtins/bytes.rs

@@ -300,10 +300,10 @@ impl PyBytes {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "endswith",
             "bytes",
-            |s, x: &PyBytesInner| s.ends_with(x.as_bytes()),
+            |s, x: PyBytesInner| s.ends_with(x.as_bytes()),
             vm,
         )
     }
@@ -320,10 +320,10 @@ impl PyBytes {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "startswith",
             "bytes",
-            |s, x: &PyBytesInner| s.starts_with(x.as_bytes()),
+            |s, x: PyBytesInner| s.starts_with(x.as_bytes()),
             vm,
         )
     }

vm/src/builtins/genericalias.rs

@@ -77,8 +77,8 @@ impl Constructor for PyGenericAlias {
 )]
 impl PyGenericAlias {
     pub fn new(origin: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> Self {
-        let args: PyTupleRef = if let Ok(tuple) = PyTupleRef::try_from_object(vm, args.clone()) {
-            tuple
+        let args = if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
+            tuple.to_owned()
         } else {
             PyTuple::new_ref(vec![args], &vm.ctx)
         };
@@ -224,21 +224,19 @@ pub(crate) fn is_typevar(obj: &PyObjectRef, vm: &VirtualMachine) -> bool {
             .unwrap_or(false)
 }
 
-fn make_parameters(args: &PyTupleRef, vm: &VirtualMachine) -> PyTupleRef {
+pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
     let mut parameters: Vec<PyObjectRef> = Vec::with_capacity(args.len());
     for arg in args {
         if is_typevar(arg, vm) {
             if !parameters.iter().any(|param| param.is(arg)) {
                 parameters.push(arg.clone());
             }
-        } else if let Ok(subparams) = arg
-            .clone()
-            .get_attr(identifier!(vm, __parameters__), vm)
-            .and_then(|obj| PyTupleRef::try_from_object(vm, obj))
-        {
-            for sub_param in &subparams {
-                if !parameters.iter().any(|param| param.is(sub_param)) {
-                    parameters.push(sub_param.clone());
+        } else if let Ok(obj) = arg.get_attr(identifier!(vm, __parameters__), vm) {
+            if let Ok(sub_params) = obj.try_to_ref::<PyTuple>(vm) {
+                for sub_param in sub_params {
+                    if !parameters.iter().any(|param| param.is(sub_param)) {
+                        parameters.push(sub_param.clone());
+                    }
                 }
             }
         }
@@ -259,13 +257,12 @@ fn subs_tvars(
     argitems: &[PyObjectRef],
     vm: &VirtualMachine,
 ) -> PyResult {
-    obj.clone()
-        .get_attr(identifier!(vm, __parameters__), vm)
+    obj.get_attr(identifier!(vm, __parameters__), vm)
         .ok()
         .and_then(|sub_params| {
             PyTupleRef::try_from_object(vm, sub_params)
                 .ok()
-                .map(|sub_params| {
+                .and_then(|sub_params| {
                     if sub_params.len() > 0 {
                         let sub_args = sub_params
                             .iter()
@@ -284,7 +281,6 @@ fn subs_tvars(
                     }
                 })
         })
-        .flatten()
         .unwrap_or(Ok(obj))
 }
 
@@ -300,9 +296,9 @@ pub fn subs_parameters<F: Fn(&VirtualMachine) -> PyResult<String>>(
         return Err(vm.new_type_error(format!("There are no type variables left in {}", repr(vm)?)));
     }
 
-    let items = PyTupleRef::try_from_object(vm, needle.clone());
+    let items = needle.try_to_ref::<PyTuple>(vm);
     let arg_items = match items {
-        Ok(ref tuple) => tuple.as_slice(),
+        Ok(tuple) => tuple.as_slice(),
         Err(_) => std::slice::from_ref(&needle),
     };
 

vm/src/builtins/str.rs

@@ -647,10 +647,10 @@ impl PyStr {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "endswith",
             "str",
-            |s, x: &PyStrRef| s.ends_with(x.as_str()),
+            |s, x: &Py<PyStr>| s.ends_with(x.as_str()),
             vm,
         )
     }
@@ -667,10 +667,10 @@ impl PyStr {
                 None => return Ok(false),
             };
         substr.py_startsendswith(
-            affix,
+            &affix,
             "startswith",
             "str",
-            |s, x: &PyStrRef| s.starts_with(x.as_str()),
+            |s, x: &Py<PyStr>| s.starts_with(x.as_str()),
             vm,
         )
     }

vm/src/builtins/tuple.rs

@@ -139,7 +139,7 @@ impl<'a> std::iter::IntoIterator for &'a PyTuple {
     }
 }
 
-impl<'a> std::iter::IntoIterator for &'a PyTupleRef {
+impl<'a> std::iter::IntoIterator for &'a Py<PyTuple> {
     type Item = &'a PyObjectRef;
     type IntoIter = std::slice::Iter<'a, PyObjectRef>;
 
@@ -482,7 +482,7 @@ pub struct PyTupleTyped<T: TransmuteFromObject> {
 impl<T: TransmuteFromObject> TryFromObject for PyTupleTyped<T> {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         let tuple = PyTupleRef::try_from_object(vm, obj)?;
-        for elem in &tuple {
+        for elem in &*tuple {
             T::check(vm, elem)?
         }
         // SAFETY: the contract of TransmuteFromObject upholds the variant on `tuple`