Fix clippy warnings on nightly

rtzoeller · rtzoeller · commit 056b6834dcb2 · 2022-11-28T22:45:36.000-06:00
Clippy is now smarter about detecting unnecessary casts and
useless conversions, which means we need to be more explicit
about when the conversions are needed for a subset of platforms.

Required changes found by repeatedly running the following command
against a list of the supported platforms.

`xargs -t -I {} sh -c "cargo clippy -Zbuild-std --target {} --all-targets -- -D warnings || exit 255"`

I removed the casts it complained about, and then restored them
with an `#[allow]` if a later target needed the cast.
diff --git a/src/dir.rs b/src/dir.rs
@@ -208,6 +208,8 @@ pub enum Type {
 impl Entry {
     /// Returns the inode number (`d_ino`) of the underlying `dirent`.
     #[allow(clippy::useless_conversion)]    // Not useless on all OSes
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     pub fn ino(&self) -> u64 {
         cfg_if! {
             if #[cfg(any(target_os = "android",
diff --git a/src/errno.rs b/src/errno.rs
@@ -47,7 +47,7 @@ fn clear() {
 
 /// Returns the platform-specific value of errno
 pub fn errno() -> i32 {
-    unsafe { (*errno_location()) as i32 }
+    unsafe { *errno_location() }
 }
 
 impl Errno {
diff --git a/src/sys/pthread.rs b/src/sys/pthread.rs
@@ -28,6 +28,7 @@ feature! {
 /// won't send any signal.
 ///
 /// [`pthread_kill(3)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_kill.html
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[cfg(not(target_os = "redox"))]
 pub fn pthread_kill<T>(thread: Pthread, signal: T) -> Result<()>
     where T: Into<Option<crate::sys::signal::Signal>>
diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs
@@ -935,7 +935,7 @@ impl SockaddrLike for UnixAddr {
                 return None;
             }
         }
-        if (*addr).sa_family as i32 != libc::AF_UNIX as i32 {
+        if (*addr).sa_family as i32 != libc::AF_UNIX {
             return None;
         }
         let mut su: libc::sockaddr_un = mem::zeroed();
@@ -1192,7 +1192,7 @@ impl SockaddrLike for SockaddrIn {
                 return None;
             }
         }
-        if (*addr).sa_family as i32 != libc::AF_INET as i32 {
+        if (*addr).sa_family as i32 != libc::AF_INET {
             return None;
         }
         Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -1298,7 +1298,7 @@ impl SockaddrLike for SockaddrIn6 {
                 return None;
             }
         }
-        if (*addr).sa_family as i32 != libc::AF_INET6 as i32 {
+        if (*addr).sa_family as i32 != libc::AF_INET6 {
             return None;
         }
         Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2185,7 +2185,7 @@ pub mod netlink {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_NETLINK as i32 {
+            if (*addr).sa_family as i32 != libc::AF_NETLINK {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2229,7 +2229,7 @@ pub mod alg {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_ALG as i32 {
+            if (*addr).sa_family as i32 != libc::AF_ALG {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2343,7 +2343,7 @@ pub mod sys_control {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_SYSTEM as i32 {
+            if (*addr).sa_family as i32 != libc::AF_SYSTEM {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2450,12 +2450,12 @@ mod datalink {
         // Returns an Option just for cross-platform compatibility
         pub fn addr(&self) -> Option<[u8; 6]> {
             Some([
-                self.0.sll_addr[0] as u8,
-                self.0.sll_addr[1] as u8,
-                self.0.sll_addr[2] as u8,
-                self.0.sll_addr[3] as u8,
-                self.0.sll_addr[4] as u8,
-                self.0.sll_addr[5] as u8,
+                self.0.sll_addr[0],
+                self.0.sll_addr[1],
+                self.0.sll_addr[2],
+                self.0.sll_addr[3],
+                self.0.sll_addr[4],
+                self.0.sll_addr[5],
             ])
         }
     }
@@ -2486,7 +2486,7 @@ mod datalink {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_PACKET as i32 {
+            if (*addr).sa_family as i32 != libc::AF_PACKET {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2561,6 +2561,8 @@ mod datalink {
         }
 
         /// Physical-layer address (MAC)
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         pub fn addr(&self) -> Option<[u8; 6]> {
             let nlen = self.nlen();
             let data = self.0.sdl_data;
@@ -2606,7 +2608,7 @@ mod datalink {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_LINK as i32 {
+            if (*addr).sa_family as i32 != libc::AF_LINK {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
@@ -2650,7 +2652,7 @@ pub mod vsock {
                     return None;
                 }
             }
-            if (*addr).sa_family as i32 != libc::AF_VSOCK as i32 {
+            if (*addr).sa_family as i32 != libc::AF_VSOCK {
                 return None;
             }
             Some(Self(ptr::read_unaligned(addr as *const _)))
diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs
@@ -839,6 +839,8 @@ impl ControlMessageOwned {
     unsafe fn decode_from(header: &cmsghdr) -> ControlMessageOwned
     {
         let p = CMSG_DATA(header);
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         let len = header as *const _ as usize + header.cmsg_len as usize
             - p as usize;
         match (header.cmsg_level, header.cmsg_type) {
@@ -1643,7 +1645,7 @@ pub fn recvmmsg<'a, I, S>(
             }
         );
 
-        (msg_controllen as usize, &mut d.cmsg_buffer)
+        (msg_controllen, &mut d.cmsg_buffer)
     }).collect();
 
     let timeout = if let Some(mut t) = timeout {
@@ -1662,6 +1664,8 @@ pub fn recvmmsg<'a, I, S>(
         .zip(addresses.iter().map(|addr| unsafe{addr.assume_init()}))
         .zip(results.into_iter())
         .map(|((mmsghdr, address), (msg_controllen, cmsg_buffer))| {
+            // The cast is not unnecessary on all platforms.
+            #[allow(clippy::unnecessary_cast)]
             unsafe {
                 read_mhdr(
                     mmsghdr.msg_hdr,
@@ -1684,6 +1688,8 @@ unsafe fn read_mhdr<'a, 'b, S>(
 ) -> RecvMsg<'b, S>
     where S: SockaddrLike
 {
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     let cmsghdr = {
         if mhdr.msg_controllen > 0 {
             // got control message(s)
@@ -2131,15 +2137,15 @@ pub fn sockaddr_storage_to_addr(
     match c_int::from(addr.ss_family) {
         #[cfg(feature = "net")]
         libc::AF_INET => {
-            assert!(len as usize >= mem::size_of::<sockaddr_in>());
+            assert!(len >= mem::size_of::<sockaddr_in>());
             let sin = unsafe {
                 *(addr as *const sockaddr_storage as *const sockaddr_in)
             };
             Ok(SockAddr::Inet(InetAddr::V4(sin)))
         }
         #[cfg(feature = "net")]
         libc::AF_INET6 => {
-            assert!(len as usize >= mem::size_of::<sockaddr_in6>());
+            assert!(len >= mem::size_of::<sockaddr_in6>());
             let sin6 = unsafe {
                 *(addr as *const _ as *const sockaddr_in6)
             };
diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs
@@ -863,7 +863,7 @@ struct SetU8 {
 
 impl<'a> Set<'a, u8> for SetU8 {
     fn new(val: &'a u8) -> SetU8 {
-        SetU8 { val: *val as u8 }
+        SetU8 { val: *val }
     }
 
     fn ffi_ptr(&self) -> *const c_void {
diff --git a/src/sys/statfs.rs b/src/sys/statfs.rs
@@ -702,6 +702,8 @@ mod test {
         assert_fs_equals(fs, vfs);
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn assert_fs_equals(fs: Statfs, vfs: Statvfs) {
         assert_eq!(fs.files() as u64, vfs.files() as u64);
         assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
@@ -749,6 +751,8 @@ mod test {
         assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn assert_fs_equals_strict(fs: Statfs, vfs: Statvfs) {
         assert_eq!(fs.files_free() as u64, vfs.files_free() as u64);
         assert_eq!(fs.blocks_free() as u64, vfs.blocks_free() as u64);
diff --git a/src/sys/sysinfo.rs b/src/sys/sysinfo.rs
@@ -30,6 +30,8 @@ impl SysInfo {
     }
 
     /// Returns the time since system boot.
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     pub fn uptime(&self) -> Duration {
         // Truncate negative values to 0
         Duration::from_secs(cmp::max(self.0.uptime, 0) as u64)
@@ -64,6 +66,8 @@ impl SysInfo {
         self.scale_mem(self.0.freeram)
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn scale_mem(&self, units: mem_blocks_t) -> u64 {
         units as u64 * self.0.mem_unit as u64
     }
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
@@ -894,6 +894,8 @@ cfg_if!{
         /// [cfgetispeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetispeed.html)).
         ///
         /// `cfgetispeed()` extracts the input baud rate from the given `Termios` structure.
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         pub fn cfgetispeed(termios: &Termios) -> u32 {
             let inner_termios = termios.get_libc_termios();
             unsafe { libc::cfgetispeed(&*inner_termios) as u32 }
@@ -903,6 +905,8 @@ cfg_if!{
         /// [cfgetospeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetospeed.html)).
         ///
         /// `cfgetospeed()` extracts the output baud rate from the given `Termios` structure.
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         pub fn cfgetospeed(termios: &Termios) -> u32 {
             let inner_termios = termios.get_libc_termios();
             unsafe { libc::cfgetospeed(&*inner_termios) as u32 }
diff --git a/src/sys/time.rs b/src/sys/time.rs
@@ -304,6 +304,8 @@ impl TimeValLike for TimeSpec {
         TimeSpec(ts)
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_seconds(&self) -> i64 {
         if self.tv_sec() < 0 && self.tv_nsec() > 0 {
             (self.tv_sec() + 1) as i64
@@ -320,6 +322,8 @@ impl TimeValLike for TimeSpec {
         self.num_nanoseconds() / 1_000
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_nanoseconds(&self) -> i64 {
         let secs = self.num_seconds() * 1_000_000_000;
         let nsec = self.nanos_mod_sec();
@@ -547,6 +551,8 @@ impl TimeValLike for TimeVal {
         })
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_seconds(&self) -> i64 {
         if self.tv_sec() < 0 && self.tv_usec() > 0 {
             (self.tv_sec() + 1) as i64
@@ -559,6 +565,8 @@ impl TimeValLike for TimeVal {
         self.num_microseconds() / 1_000
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_microseconds(&self) -> i64 {
         let secs = self.num_seconds() * 1_000_000;
         let usec = self.micros_mod_sec();
diff --git a/src/sys/uio.rs b/src/sys/uio.rs
@@ -153,7 +153,7 @@ impl<T> IoVec<T> {
         unsafe {
             slice::from_raw_parts(
                 self.0.iov_base as *const u8,
-                self.0.iov_len as usize)
+                self.0.iov_len)
         }
     }
 }
diff --git a/test/sys/test_ioctl.rs b/test/sys/test_ioctl.rs
@@ -30,6 +30,8 @@ ioctl_readwrite_buf!(readwritebuf_test, 0, 0, u32);
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux {
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_none() {
         if cfg!(any(
@@ -46,6 +48,8 @@ mod linux {
         }
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_write() {
         if cfg!(any(
@@ -78,6 +82,8 @@ mod linux {
         }
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_read() {
         if cfg!(any(
@@ -110,6 +116,8 @@ mod linux {
         }
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_read_write() {
         assert_eq!(request_code_readwrite!(b'z', 10, 1) as u32, 0xC001_7A0A);
diff --git a/test/sys/test_stat.rs b/test/sys/test_stat.rs
@@ -1,3 +1,5 @@
+// The conversion is not useless on all platforms.
+#[allow(clippy::useless_conversion)]
 #[cfg(target_os = "freebsd")]
 #[test]
 fn test_chflags() {
diff --git a/test/test_mount.rs b/test/test_mount.rs
@@ -108,7 +108,7 @@ exit 23";
 
         // EROFS: Read-only file system
         assert_eq!(
-            EROFS as i32,
+            EROFS,
             File::create(tempdir.path().join("test"))
                 .unwrap_err()
                 .raw_os_error()
@@ -156,7 +156,7 @@ exit 23";
 
         // EACCES: Permission denied
         assert_eq!(
-            EACCES as i32,
+            EACCES,
             Command::new(&test_path)
                 .status()
                 .unwrap_err()

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ fn clear() {`
`47`	`47`
`48`	`48`	`/// Returns the platform-specific value of errno`
`49`	`49`	`pub fn errno() -> i32 {`
`50`		`- unsafe { (*errno_location()) as i32 }`
	`50`	`+ unsafe { *errno_location() }`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`impl Errno {`
Original file line number	Diff line number	Diff line change
`@@ -935,7 +935,7 @@ impl SockaddrLike for UnixAddr {`
`935`	`935`	`return None;`
`936`	`936`	`}`
`937`	`937`	`}`
`938`		`- if (*addr).sa_family as i32 != libc::AF_UNIX as i32 {`
	`938`	`+ if (*addr).sa_family as i32 != libc::AF_UNIX {`
`939`	`939`	`return None;`
`940`	`940`	`}`
`941`	`941`	`let mut su: libc::sockaddr_un = mem::zeroed();`
`@@ -1192,7 +1192,7 @@ impl SockaddrLike for SockaddrIn {`
`1192`	`1192`	`return None;`
`1193`	`1193`	`}`
`1194`	`1194`	`}`
`1195`		`- if (*addr).sa_family as i32 != libc::AF_INET as i32 {`
	`1195`	`+ if (*addr).sa_family as i32 != libc::AF_INET {`
`1196`	`1196`	`return None;`
`1197`	`1197`	`}`
`1198`	`1198`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -1298,7 +1298,7 @@ impl SockaddrLike for SockaddrIn6 {`
`1298`	`1298`	`return None;`
`1299`	`1299`	`}`
`1300`	`1300`	`}`
`1301`		`- if (*addr).sa_family as i32 != libc::AF_INET6 as i32 {`
	`1301`	`+ if (*addr).sa_family as i32 != libc::AF_INET6 {`
`1302`	`1302`	`return None;`
`1303`	`1303`	`}`
`1304`	`1304`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2185,7 +2185,7 @@ pub mod netlink {`
`2185`	`2185`	`return None;`
`2186`	`2186`	`}`
`2187`	`2187`	`}`
`2188`		`- if (*addr).sa_family as i32 != libc::AF_NETLINK as i32 {`
	`2188`	`+ if (*addr).sa_family as i32 != libc::AF_NETLINK {`
`2189`	`2189`	`return None;`
`2190`	`2190`	`}`
`2191`	`2191`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2229,7 +2229,7 @@ pub mod alg {`
`2229`	`2229`	`return None;`
`2230`	`2230`	`}`
`2231`	`2231`	`}`
`2232`		`- if (*addr).sa_family as i32 != libc::AF_ALG as i32 {`
	`2232`	`+ if (*addr).sa_family as i32 != libc::AF_ALG {`
`2233`	`2233`	`return None;`
`2234`	`2234`	`}`
`2235`	`2235`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2343,7 +2343,7 @@ pub mod sys_control {`
`2343`	`2343`	`return None;`
`2344`	`2344`	`}`
`2345`	`2345`	`}`
`2346`		`- if (*addr).sa_family as i32 != libc::AF_SYSTEM as i32 {`
	`2346`	`+ if (*addr).sa_family as i32 != libc::AF_SYSTEM {`
`2347`	`2347`	`return None;`
`2348`	`2348`	`}`
`2349`	`2349`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2450,12 +2450,12 @@ mod datalink {`
`2450`	`2450`	`// Returns an Option just for cross-platform compatibility`
`2451`	`2451`	`pub fn addr(&self) -> Option<[u8; 6]> {`
`2452`	`2452`	`Some([`
`2453`		`- self.0.sll_addr[0] as u8,`
`2454`		`- self.0.sll_addr[1] as u8,`
`2455`		`- self.0.sll_addr[2] as u8,`
`2456`		`- self.0.sll_addr[3] as u8,`
`2457`		`- self.0.sll_addr[4] as u8,`
`2458`		`- self.0.sll_addr[5] as u8,`
	`2453`	`+ self.0.sll_addr[0],`
	`2454`	`+ self.0.sll_addr[1],`
	`2455`	`+ self.0.sll_addr[2],`
	`2456`	`+ self.0.sll_addr[3],`
	`2457`	`+ self.0.sll_addr[4],`
	`2458`	`+ self.0.sll_addr[5],`
`2459`	`2459`	`])`
`2460`	`2460`	`}`
`2461`	`2461`	`}`
`@@ -2486,7 +2486,7 @@ mod datalink {`
`2486`	`2486`	`return None;`
`2487`	`2487`	`}`
`2488`	`2488`	`}`
`2489`		`- if (*addr).sa_family as i32 != libc::AF_PACKET as i32 {`
	`2489`	`+ if (*addr).sa_family as i32 != libc::AF_PACKET {`
`2490`	`2490`	`return None;`
`2491`	`2491`	`}`
`2492`	`2492`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2561,6 +2561,8 @@ mod datalink {`
`2561`	`2561`	`}`
`2562`	`2562`
`2563`	`2563`	`/// Physical-layer address (MAC)`
	`2564`	`+ // The cast is not unnecessary on all platforms.`
	`2565`	`+ #[allow(clippy::unnecessary_cast)]`
`2564`	`2566`	`pub fn addr(&self) -> Option<[u8; 6]> {`
`2565`	`2567`	`let nlen = self.nlen();`
`2566`	`2568`	`let data = self.0.sdl_data;`
`@@ -2606,7 +2608,7 @@ mod datalink {`
`2606`	`2608`	`return None;`
`2607`	`2609`	`}`
`2608`	`2610`	`}`
`2609`		`- if (*addr).sa_family as i32 != libc::AF_LINK as i32 {`
	`2611`	`+ if (*addr).sa_family as i32 != libc::AF_LINK {`
`2610`	`2612`	`return None;`
`2611`	`2613`	`}`
`2612`	`2614`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
`@@ -2650,7 +2652,7 @@ pub mod vsock {`
`2650`	`2652`	`return None;`
`2651`	`2653`	`}`
`2652`	`2654`	`}`
`2653`		`- if (*addr).sa_family as i32 != libc::AF_VSOCK as i32 {`
	`2655`	`+ if (*addr).sa_family as i32 != libc::AF_VSOCK {`
`2654`	`2656`	`return None;`
`2655`	`2657`	`}`
`2656`	`2658`	`Some(Self(ptr::read_unaligned(addr as *const _)))`
Original file line number	Diff line number	Diff line change
`@@ -863,7 +863,7 @@ struct SetU8 {`
`863`	`863`
`864`	`864`	`impl<'a> Set<'a, u8> for SetU8 {`
`865`	`865`	`fn new(val: &'a u8) -> SetU8 {`
`866`		`- SetU8 { val: *val as u8 }`
	`866`	`+ SetU8 { val: *val }`
`867`	`867`	`}`
`868`	`868`
`869`	`869`	`fn ffi_ptr(&self) -> *const c_void {`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,8 @@ impl SysInfo {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`/// Returns the time since system boot.`
	`33`	`+ // The cast is not unnecessary on all platforms.`
	`34`	`+ #[allow(clippy::unnecessary_cast)]`
`33`	`35`	`pub fn uptime(&self) -> Duration {`
`34`	`36`	`// Truncate negative values to 0`
`35`	`37`	`Duration::from_secs(cmp::max(self.0.uptime, 0) as u64)`
`@@ -64,6 +66,8 @@ impl SysInfo {`
`64`	`66`	`self.scale_mem(self.0.freeram)`
`65`	`67`	`}`
`66`	`68`
	`69`	`+ // The cast is not unnecessary on all platforms.`
	`70`	`+ #[allow(clippy::unnecessary_cast)]`
`67`	`71`	`fn scale_mem(&self, units: mem_blocks_t) -> u64 {`
`68`	`72`	`units as u64 * self.0.mem_unit as u64`
`69`	`73`	`}`