&PyTuple and &PyTupleRef works like &[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/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) {

vm/src/builtins/genericalias.rs

@@ -110,7 +110,6 @@ impl PyGenericAlias {
                 "()".to_owned()
             } else {
                 self.args
-                    .as_slice()
                     .iter()
                     .map(|o| repr_item(o.clone(), vm))
                     .collect::<PyResult<Vec<_>>>()?
@@ -153,7 +152,7 @@ impl PyGenericAlias {
     #[pymethod(magic)]
     fn dir(&self, vm: &VirtualMachine) -> PyResult<PyList> {
         let dir = vm.dir(Some(self.origin()))?;
-        for exc in ATTR_EXCEPTIONS.iter() {
+        for exc in &ATTR_EXCEPTIONS {
             if !dir.contains((*exc).to_pyobject(vm), vm)? {
                 dir.append((*exc).to_pyobject(vm));
             }
@@ -198,7 +197,7 @@ fn is_typevar(obj: &PyObjectRef) -> bool {
 
 fn make_parameters(args: &PyTupleRef, vm: &VirtualMachine) -> PyTupleRef {
     let mut parameters: Vec<PyObjectRef> = Vec::with_capacity(args.len());
-    for arg in args.as_slice() {
+    for arg in args {
         if is_typevar(arg) {
             if !parameters.iter().any(|param| param.is(arg)) {
                 parameters.push(arg.clone());
@@ -208,7 +207,7 @@ fn make_parameters(args: &PyTupleRef, vm: &VirtualMachine) -> PyTupleRef {
             .get_attr("__parameters__", vm)
             .and_then(|obj| PyTupleRef::try_from_object(vm, obj))
         {
-            for subparam in subparams.as_slice() {
+            for subparam in &subparams {
                 if !parameters.iter().any(|param| param.is(subparam)) {
                     parameters.push(subparam.clone());
                 }
@@ -222,7 +221,7 @@ fn make_parameters(args: &PyTupleRef, vm: &VirtualMachine) -> PyTupleRef {
 
 #[inline]
 fn tuple_index(tuple: &PyTupleRef, item: &PyObjectRef) -> Option<usize> {
-    tuple.as_slice().iter().position(|element| element.is(item))
+    tuple.iter().position(|element| element.is(item))
 }
 
 fn subs_tvars(
@@ -240,7 +239,6 @@ fn subs_tvars(
                 .map(|sub_params| {
                     if sub_params.len() > 0 {
                         let sub_args = sub_params
-                            .as_slice()
                             .iter()
                             .map(|arg| {
                                 if let Some(idx) = tuple_index(params, arg) {
@@ -290,7 +288,6 @@ pub fn subs_parameters<F: Fn(&VirtualMachine) -> PyResult<String>>(
     }
 
     let new_args = args
-        .as_slice()
         .iter()
         .map(|arg| {
             if is_typevar(arg) {
@@ -370,7 +367,7 @@ impl Hashable for PyGenericAlias {
 
 impl GetAttr for PyGenericAlias {
     fn getattro(zelf: PyRef<Self>, attr: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        for exc in ATTR_EXCEPTIONS.iter() {
+        for exc in &ATTR_EXCEPTIONS {
             if *(*exc) == attr.to_string() {
                 return vm.generic_getattribute(zelf.as_object().to_owned(), attr);
             }