Fix clippy lints

Signed-off-by: Alex Saveau <[email protected]>

src/sys/aio.rs

@@ -163,7 +163,7 @@ impl AioCb {
             0 => Ok(()),
             num if num > 0 => Err(Errno::from_i32(num)),
             -1 => Err(Errno::last()),
-            num => panic!("unknown aio_error return value {:?}", num),
+            num => panic!("unknown aio_error return value {num:?}"),
         }
     }
 

src/sys/socket/addr.rs

@@ -2373,7 +2373,7 @@ mod tests {
                 sdl_slen: 0,
                 ..unsafe { mem::zeroed() }
             });
-            format!("{}", la);
+            format!("{la}");
         }
 
         #[cfg(all(
@@ -2495,7 +2495,7 @@ mod tests {
         fn display() {
             let s = "127.0.0.1:8080";
             let addr = SockaddrIn::from_str(s).unwrap();
-            assert_eq!(s, format!("{}", addr));
+            assert_eq!(s, format!("{addr}"));
         }
 
         #[test]
@@ -2515,7 +2515,7 @@ mod tests {
         fn display() {
             let s = "[1234:5678:90ab:cdef::1111:2222]:8080";
             let addr = SockaddrIn6::from_str(s).unwrap();
-            assert_eq!(s, format!("{}", addr));
+            assert_eq!(s, format!("{addr}"));
         }
 
         #[test]

src/sys/socket/mod.rs

@@ -12,7 +12,6 @@ use libc::{
     self, c_int, c_void, iovec, size_t, socklen_t, CMSG_DATA, CMSG_FIRSTHDR,
     CMSG_LEN, CMSG_NXTHDR,
 };
-use std::convert::TryFrom;
 use std::io::{IoSlice, IoSliceMut};
 #[cfg(feature = "net")]
 use std::net;

src/sys/socket/sockopt.rs

@@ -6,13 +6,10 @@ use crate::Result;
 use cfg_if::cfg_if;
 use libc::{self, c_int, c_void, socklen_t};
 use std::ffi::{OsStr, OsString};
+use std::mem::{self, MaybeUninit};
 #[cfg(target_family = "unix")]
 use std::os::unix::ffi::OsStrExt;
 use std::os::unix::io::RawFd;
-use std::{
-    convert::TryFrom,
-    mem::{self, MaybeUninit},
-};
 
 // Constants
 // TCP_CA_NAME_MAX isn't defined in user space include files

src/sys/time.rs

@@ -261,8 +261,7 @@ impl TimeValLike for TimeSpec {
     fn seconds(seconds: i64) -> TimeSpec {
         assert!(
             (TS_MIN_SECONDS..=TS_MAX_SECONDS).contains(&seconds),
-            "TimeSpec out of bounds; seconds={}",
-            seconds
+            "TimeSpec out of bounds; seconds={seconds}",
         );
         let mut ts = zero_init_timespec();
         ts.tv_sec = seconds as time_t;
@@ -428,20 +427,20 @@ impl fmt::Display for TimeSpec {
 
         let sec = abs.tv_sec();
 
-        write!(f, "{}", sign)?;
+        write!(f, "{sign}")?;
 
         if abs.tv_nsec() == 0 {
-            if abs.tv_sec() == 1 {
-                write!(f, "{} second", sec)?;
+            if sec == 1 {
+                write!(f, "1 second")?;
             } else {
-                write!(f, "{} seconds", sec)?;
+                write!(f, "{sec} seconds")?;
             }
         } else if abs.tv_nsec() % 1_000_000 == 0 {
-            write!(f, "{}.{:03} seconds", sec, abs.tv_nsec() / 1_000_000)?;
+            write!(f, "{sec}.{:03} seconds", abs.tv_nsec() / 1_000_000)?;
         } else if abs.tv_nsec() % 1_000 == 0 {
-            write!(f, "{}.{:06} seconds", sec, abs.tv_nsec() / 1_000)?;
+            write!(f, "{sec}.{:06} seconds", abs.tv_nsec() / 1_000)?;
         } else {
-            write!(f, "{}.{:09} seconds", sec, abs.tv_nsec())?;
+            write!(f, "{sec}.{:09} seconds", abs.tv_nsec())?;
         }
 
         Ok(())
@@ -497,8 +496,7 @@ impl TimeValLike for TimeVal {
     fn seconds(seconds: i64) -> TimeVal {
         assert!(
             (TV_MIN_SECONDS..=TV_MAX_SECONDS).contains(&seconds),
-            "TimeVal out of bounds; seconds={}",
-            seconds
+            "TimeVal out of bounds; seconds={seconds}"
         );
         #[cfg_attr(target_env = "musl", allow(deprecated))]
         // https://github.com/rust-lang/libc/issues/1848
@@ -662,18 +660,18 @@ impl fmt::Display for TimeVal {
 
         let sec = abs.tv_sec();
 
-        write!(f, "{}", sign)?;
+        write!(f, "{sign}")?;
 
         if abs.tv_usec() == 0 {
-            if abs.tv_sec() == 1 {
-                write!(f, "{} second", sec)?;
+            if sec == 1 {
+                write!(f, "1 second")?;
             } else {
-                write!(f, "{} seconds", sec)?;
+                write!(f, "{sec} seconds")?;
             }
         } else if abs.tv_usec() % 1000 == 0 {
-            write!(f, "{}.{:03} seconds", sec, abs.tv_usec() / 1000)?;
+            write!(f, "{sec}.{:03} seconds", abs.tv_usec() / 1000)?;
         } else {
-            write!(f, "{}.{:06} seconds", sec, abs.tv_usec())?;
+            write!(f, "{sec}.{:06} seconds", abs.tv_usec())?;
         }
 
         Ok(())

test/sys/test_aio.rs

@@ -610,7 +610,7 @@ fn test_aio_suspend() {
             let r = aio_suspend(&cbbuf[..], Some(timeout));
             match r {
                 Err(Errno::EINTR) => continue,
-                Err(e) => panic!("aio_suspend returned {:?}", e),
+                Err(e) => panic!("aio_suspend returned {e:?}"),
                 Ok(_) => (),
             };
         }

test/sys/test_signal.rs

@@ -54,9 +54,8 @@ fn test_sigprocmask() {
     // test don't make sense.
     assert!(
         !old_signal_set.contains(SIGNAL),
-        "the {:?} signal is already blocked, please change to a \
-             different one",
-        SIGNAL
+        "the {SIGNAL:?} signal is already blocked, please change to a \
+             different one"
     );
 
     // Now block the signal.
@@ -71,8 +70,7 @@ fn test_sigprocmask() {
         .expect("expect to be able to retrieve old signals");
     assert!(
         old_signal_set.contains(SIGNAL),
-        "expected the {:?} to be blocked",
-        SIGNAL
+        "expected the {SIGNAL:?} to be blocked"
     );
 
     // Reset the signal.

test/sys/test_socket.rs

@@ -626,7 +626,7 @@ mod recvfrom {
                 println!("IPv6 not available, skipping test.");
                 return;
             }
-            Err(e) => panic!("bind: {}", e),
+            Err(e) => panic!("bind: {e}"),
             Ok(()) => (),
         }
         let ssock = socket(
@@ -1272,7 +1272,7 @@ fn test_scm_credentials() {
                 ControlMessageOwned::ScmCredentials(cred) => cred,
                 #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
                 ControlMessageOwned::ScmCreds(cred) => cred,
-                other => panic!("unexpected cmsg {:?}", other),
+                other => panic!("unexpected cmsg {other:?}"),
             };
             assert!(received_cred.is_none());
             assert_eq!(cred.pid(), getpid().as_raw());
@@ -1550,7 +1550,7 @@ fn loopback_address(
         Err(e) => {
             let stdioerr = io::stderr();
             let mut handle = stdioerr.lock();
-            writeln!(handle, "getifaddrs: {:?}", e).unwrap();
+            writeln!(handle, "getifaddrs: {e:?}").unwrap();
             return None;
         }
     };
@@ -2347,7 +2347,7 @@ mod linux_errqueue {
                     }
                     *ext_err
                 } else {
-                    panic!("Unexpected control message {:?}", cmsg);
+                    panic!("Unexpected control message {cmsg:?}");
                 }
             },
         )
@@ -2398,7 +2398,7 @@ mod linux_errqueue {
                     }
                     *ext_err
                 } else {
-                    panic!("Unexpected control message {:?}", cmsg);
+                    panic!("Unexpected control message {cmsg:?}");
                 }
             },
         )
@@ -2432,7 +2432,7 @@ mod linux_errqueue {
             MsgFlags::empty(),
         ) {
             assert_eq!(e, Errno::EADDRNOTAVAIL);
-            println!("{:?} not available, skipping test.", af);
+            println!("{af:?} not available, skipping test.");
             return;
         }
 

test/test_fcntl.rs

@@ -559,7 +559,7 @@ mod test_posix_fallocate {
         let err = posix_fallocate(rd as RawFd, 0, 100).unwrap_err();
         match err {
             Errno::EINVAL | Errno::ENODEV | Errno::ESPIPE | Errno::EBADF => (),
-            errno => panic!("unexpected errno {}", errno,),
+            errno => panic!("unexpected errno {errno}",),
         }
     }
 }

test/test_mount.rs

@@ -38,7 +38,7 @@ exit 23";
             MsFlags::empty(),
             NONE,
         )
-        .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        .unwrap_or_else(|e| panic!("mount failed: {e}"));
 
         let test_path = tempdir.path().join("test");
 
@@ -67,31 +67,30 @@ exit 23";
                     .unwrap();
                     process::exit(0);
                 } else {
-                    panic!("open failed: {}", e);
+                    panic!("open failed: {e}");
                 }
             })
             .and_then(|mut f| f.write(SCRIPT_CONTENTS))
-            .unwrap_or_else(|e| panic!("write failed: {}", e));
+            .unwrap_or_else(|e| panic!("write failed: {e}"));
 
         // Verify read.
         let mut buf = Vec::new();
         File::open(&test_path)
             .and_then(|mut f| f.read_to_end(&mut buf))
-            .unwrap_or_else(|e| panic!("read failed: {}", e));
+            .unwrap_or_else(|e| panic!("read failed: {e}"));
         assert_eq!(buf, SCRIPT_CONTENTS);
 
         // Verify execute.
         assert_eq!(
             EXPECTED_STATUS,
             Command::new(&test_path)
                 .status()
-                .unwrap_or_else(|e| panic!("exec failed: {}", e))
+                .unwrap_or_else(|e| panic!("exec failed: {e}"))
                 .code()
                 .unwrap_or_else(|| panic!("child killed by signal"))
         );
 
-        umount(tempdir.path())
-            .unwrap_or_else(|e| panic!("umount failed: {}", e));
+        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {e}"));
     }
 
     pub fn test_mount_rdonly_disallows_write() {
@@ -104,7 +103,7 @@ exit 23";
             MsFlags::MS_RDONLY,
             NONE,
         )
-        .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        .unwrap_or_else(|e| panic!("mount failed: {e}"));
 
         // EROFS: Read-only file system
         assert_eq!(
@@ -115,8 +114,7 @@ exit 23";
                 .unwrap()
         );
 
-        umount(tempdir.path())
-            .unwrap_or_else(|e| panic!("umount failed: {}", e));
+        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {e}"));
     }
 
     pub fn test_mount_noexec_disallows_exec() {
@@ -129,7 +127,7 @@ exit 23";
             MsFlags::MS_NOEXEC,
             NONE,
         )
-        .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        .unwrap_or_else(|e| panic!("mount failed: {e}"));
 
         let test_path = tempdir.path().join("test");
 
@@ -139,13 +137,13 @@ exit 23";
             .mode((Mode::S_IRWXU | Mode::S_IRWXG | Mode::S_IRWXO).bits())
             .open(&test_path)
             .and_then(|mut f| f.write(SCRIPT_CONTENTS))
-            .unwrap_or_else(|e| panic!("write failed: {}", e));
+            .unwrap_or_else(|e| panic!("write failed: {e}"));
 
         // Verify that we cannot execute despite a+x permissions being set.
         let mode = stat::Mode::from_bits_truncate(
             fs::metadata(&test_path)
                 .map(|md| md.permissions().mode())
-                .unwrap_or_else(|e| panic!("metadata failed: {}", e)),
+                .unwrap_or_else(|e| panic!("metadata failed: {e}")),
         );
 
         assert!(
@@ -164,8 +162,7 @@ exit 23";
                 .unwrap()
         );
 
-        umount(tempdir.path())
-            .unwrap_or_else(|e| panic!("umount failed: {}", e));
+        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {e}"));
     }
 
     pub fn test_mount_bind() {
@@ -182,18 +179,18 @@ exit 23";
                 MsFlags::MS_BIND,
                 NONE,
             )
-            .unwrap_or_else(|e| panic!("mount failed: {}", e));
+            .unwrap_or_else(|e| panic!("mount failed: {e}"));
 
             fs::OpenOptions::new()
                 .create(true)
                 .write(true)
                 .mode((Mode::S_IRWXU | Mode::S_IRWXG | Mode::S_IRWXO).bits())
                 .open(mount_point.path().join(file_name))
                 .and_then(|mut f| f.write(SCRIPT_CONTENTS))
-                .unwrap_or_else(|e| panic!("write failed: {}", e));
+                .unwrap_or_else(|e| panic!("write failed: {e}"));
 
             umount(mount_point.path())
-                .unwrap_or_else(|e| panic!("umount failed: {}", e));
+                .unwrap_or_else(|e| panic!("umount failed: {e}"));
         }
 
         // Verify the file written in the mount shows up in source directory, even
@@ -202,7 +199,7 @@ exit 23";
         let mut buf = Vec::new();
         File::open(tempdir.path().join(file_name))
             .and_then(|mut f| f.read_to_end(&mut buf))
-            .unwrap_or_else(|e| panic!("read failed: {}", e));
+            .unwrap_or_else(|e| panic!("read failed: {e}"));
         assert_eq!(buf, SCRIPT_CONTENTS);
     }
 
@@ -214,8 +211,7 @@ exit 23";
             let stderr = io::stderr();
             let mut handle = stderr.lock();
             writeln!(handle,
-                     "unshare failed: {}. Are unprivileged user namespaces available?",
-                     e).unwrap();
+                     "unshare failed: {e}. Are unprivileged user namespaces available?").unwrap();
             writeln!(handle, "mount is not being tested").unwrap();
             // Exit with success because not all systems support unprivileged user namespaces, and
             // that's not what we're testing for.
@@ -226,8 +222,8 @@ exit 23";
         fs::OpenOptions::new()
             .write(true)
             .open("/proc/self/uid_map")
-            .and_then(|mut f| f.write(format!("1000 {} 1\n", uid).as_bytes()))
-            .unwrap_or_else(|e| panic!("could not write uid map: {}", e));
+            .and_then(|mut f| f.write(format!("1000 {uid} 1\n").as_bytes()))
+            .unwrap_or_else(|e| panic!("could not write uid map: {e}"));
     }
 }