Merge pull request RustPython#3659 from youknowone/pytuple-as-slice

PyTuple deref to [PyObjectRef]

Author: youknowone

derive/src/pyclass.rs

@@ -694,7 +694,7 @@ impl GetSetNursery {
 
     fn validate(&mut self) -> Result<()> {
         let mut errors = Vec::new();
-        for ((name, _cfgs), (getter, setter, deleter)) in self.map.iter() {
+        for ((name, _cfgs), (getter, setter, deleter)) in &self.map {
             if getter.is_none() {
                 errors.push(syn::Error::new_spanned(
                     setter.as_ref().or(deleter.as_ref()).unwrap(),

stdlib/src/binascii.rs

@@ -38,7 +38,7 @@ mod decl {
     fn hexlify(data: ArgBytesLike) -> Vec<u8> {
         data.with_ref(|bytes| {
             let mut hex = Vec::<u8>::with_capacity(bytes.len() * 2);
-            for b in bytes.iter() {
+            for b in bytes {
                 hex.push(hex_nibble(b >> 4));
                 hex.push(hex_nibble(b & 0xf));
             }

stdlib/src/math.rs

@@ -516,7 +516,7 @@ mod math {
         }
 
         let mut res = argvec[0].as_bigint().clone();
-        for num in argvec[1..].iter() {
+        for num in &argvec[1..] {
             res = op(&res, num)
         }
         res

stdlib/src/posixsubprocess.rs

@@ -33,9 +33,9 @@ mod _posixsubprocess {
                 .chain(std::iter::once(std::ptr::null()))
                 .collect::<Vec<_>>()
         };
-        let argv = cstrs_to_ptrs(args.args.as_slice());
+        let argv = cstrs_to_ptrs(&args.args);
         let argv = &argv;
-        let envp = args.env_list.as_ref().map(|s| cstrs_to_ptrs(s.as_slice()));
+        let envp = args.env_list.as_ref().map(|s| cstrs_to_ptrs(s));
         let envp = envp.as_deref();
         match unsafe { nix::unistd::fork() }.map_err(|err| err.to_pyexception(vm))? {
             nix::unistd::ForkResult::Child => exec(&args, ProcArgs { argv, envp }),
@@ -149,7 +149,7 @@ fn exec_inner(args: &ForkExecArgs, procargs: ProcArgs) -> nix::Result<Never> {
 
     if args.close_fds {
         #[cfg(not(target_os = "redox"))]
-        close_fds(3, args.fds_to_keep.as_slice())?;
+        close_fds(3, &args.fds_to_keep)?;
     }
 
     let mut first_err = None;

stdlib/src/random.rs

@@ -88,9 +88,9 @@ mod _random {
 
         #[pymethod]
         fn seed(&self, n: OptionalOption<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
-            let new_rng = match n.flatten() {
-                None => PyRng::default(),
-                Some(n) => {
+            let new_rng = n
+                .flatten()
+                .map(|n| {
                     // Fallback to using hash if object isn't Int-like.
                     let (_, mut key) = match n.downcast::<PyInt>() {
                         Ok(n) => n.as_bigint().abs(),
@@ -101,9 +101,12 @@ mod _random {
                         key.reverse();
                     }
                     let key = if key.is_empty() { &[0] } else { key.as_slice() };
-                    PyRng::MT(Box::new(mt19937::MT19937::new_with_slice_seed(key)))
-                }
-            };
+                    Ok(PyRng::MT(Box::new(mt19937::MT19937::new_with_slice_seed(
+                        key,
+                    ))))
+                })
+                .transpose()?
+                .unwrap_or_default();
 
             *self.rng.lock() = new_rng;
             Ok(())

stdlib/src/socket.rs

@@ -450,13 +450,12 @@ mod _socket {
                             obj.class().name()
                         ))
                     })?;
-                    let tuple = tuple.as_slice();
                     if tuple.len() != 2 {
                         return Err(vm.new_type_error(
                             "AF_INET address must be a pair (host, post)".to_owned(),
                         ));
                     }
-                    let addr = Address::from_tuple(tuple, vm)?;
+                    let addr = Address::from_tuple(&tuple, vm)?;
                     let mut addr4 = get_addr(vm, addr.host, c::AF_INET)?;
                     match &mut addr4 {
                         SocketAddr::V4(addr4) => {
@@ -474,15 +473,14 @@ mod _socket {
                             obj.class().name()
                         ))
                     })?;
-                    let tuple = tuple.as_slice();
                     match tuple.len() {
                         2 | 3 | 4 => {}
                         _ => return Err(vm.new_type_error(
                             "AF_INET6 address must be a tuple (host, port[, flowinfo[, scopeid]])"
                                 .to_owned(),
                         )),
                     }
-                    let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(tuple, vm)?;
+                    let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&tuple, vm)?;
                     let mut addr6 = get_addr(vm, addr.host, c::AF_INET6)?;
                     match &mut addr6 {
                         SocketAddr::V6(addr6) => {
@@ -1044,10 +1042,10 @@ mod _socket {
     impl TryFromObject for Address {
         fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
             let tuple = PyTupleRef::try_from_object(vm, obj)?;
-            if tuple.as_slice().len() != 2 {
+            if tuple.len() != 2 {
                 Err(vm.new_type_error("Address tuple should have only 2 values".to_owned()))
             } else {
-                Self::from_tuple(tuple.as_slice(), vm)
+                Self::from_tuple(&tuple, vm)
             }
         }
     }
@@ -1481,12 +1479,11 @@ mod _socket {
         flags: i32,
         vm: &VirtualMachine,
     ) -> PyResult<(String, String)> {
-        let address = address.as_slice();
         match address.len() {
             2 | 3 | 4 => {}
             _ => return Err(vm.new_type_error("illegal sockaddr argument".to_owned())),
         }
-        let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(address, vm)?;
+        let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&address, vm)?;
         let hints = dns_lookup::AddrInfoHints {
             address: c::AF_UNSPEC,
             socktype: c::SOCK_DGRAM,

vm/src/buffer.rs

@@ -361,7 +361,7 @@ impl FormatSpec {
 
         let mut args = args.into_iter();
         // Loop over all opcodes:
-        for code in self.codes.iter() {
+        for code in &self.codes {
             buffer = &mut buffer[code.pre_padding..];
             debug!("code: {:?}", code);
             match code.code {

vm/src/builtins/bytearray.rs

@@ -185,10 +185,10 @@ impl PyByteArray {
                     bytes_from_object(vm, &value)?
                 };
                 if let Some(mut w) = zelf.try_resizable_opt() {
-                    w.elements.set_item_by_slice(vm, slice, items.as_slice())
+                    w.elements.set_item_by_slice(vm, slice, &items)
                 } else {
                     zelf.borrow_buf_mut()
-                        .set_item_by_slice_no_resize(vm, slice, items.as_slice())
+                        .set_item_by_slice_no_resize(vm, slice, &items)
                 }
             }
         }

vm/src/builtins/code.rs

@@ -52,7 +52,7 @@ fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<PyConstant> {
         }
         ref t @ super::tuple::PyTuple => {
             BorrowedConstant::Tuple {
-                elements: Box::new(t.as_slice().iter().map(|o| borrow_obj_constant(o))),
+                elements: Box::new(t.iter().map(|o| borrow_obj_constant(o))),
             }
         }
         super::singletons::PyNone => BorrowedConstant::None,

vm/src/builtins/function/jitfunc.rs

@@ -174,7 +174,6 @@ pub(crate) fn get_jit_args<'a>(
 
     // fill in positional defaults
     if let Some(defaults) = defaults {
-        let defaults = defaults.as_slice();
         for (i, default) in defaults.iter().enumerate() {
             let arg_idx = i + func.code.arg_count - defaults.len();
             if !jit_args.is_set(arg_idx) {