Clippy cleanup

Clippy found some const-correctness issues in internal APIs, but nothing
user-facing.

Author: asomers

.cirrus.yml

@@ -5,6 +5,7 @@ cargo_cache:
 env:
   # Build by default; don't just check
   BUILD: build
+  CLIPPYFLAGS: -D warnings -A unknown-lints
   RUSTFLAGS: -D warnings
   RUSTDOCFLAGS: -D warnings
   TOOL: cargo
@@ -19,7 +20,7 @@ build: &BUILD
     - rustc -Vv
     - $TOOL $BUILD $ZFLAGS --target $TARGET --all-targets
     - $TOOL doc $ZFLAGS --no-deps --target $TARGET
-    - $TOOL clippy $ZFLAGS --target $TARGET --all-targets -- -D warnings
+    - $TOOL clippy $ZFLAGS --target $TARGET --all-targets -- $CLIPPYFLAGS
     - if [ -z "$NOHACK" ]; then mkdir -p $HOME/.cargo/bin; export PATH=$HOME/.cargo/bin:$PATH; fi
     - if [ -z "$NOHACK" ]; then curl -LsSf https://github.com/taiki-e/cargo-hack/releases/latest/download/cargo-hack-${HOST:-$TARGET}.tar.gz | tar xzf - -C ~/.cargo/bin; fi
     - if [ -z "$NOHACK" ]; then $TOOL hack $ZFLAGS check --target $TARGET --each-feature; fi
@@ -253,6 +254,7 @@ task:
   env:
     HOST: x86_64-unknown-linux-gnu
     TARGET: x86_64-unknown-redox
+    CLIPPYFLAGS: -D warnings
   setup_script:
     - rustup target add $TARGET
     - rustup component add clippy
@@ -267,6 +269,7 @@ task:
     BUILD: check
     HOST: x86_64-unknown-linux-gnu
     ZFLAGS: -Zbuild-std
+    CLIPPYFLAGS: -D warnings
   matrix:
     - name: DragonFly BSD x86_64
       env:

src/dir.rs

@@ -101,6 +101,9 @@ impl Drop for Dir {
     }
 }
 
+// The pass by mut is technically needless only because the inner NonNull is
+// Copy.  But philosophically we're mutating the Dir, so we pass by mut.
+#[allow(clippy::needless_pass_by_ref_mut)]
 fn next(dir: &mut Dir) -> Option<Result<Entry>> {
     unsafe {
         // Note: POSIX specifies that portable applications should dynamically allocate a

src/sys/socket/mod.rs

@@ -1619,18 +1619,18 @@ impl<S> MultiHeaders<S> {
 
         // we'll need a cmsg_buffer for each slice, we preallocate a vector and split
         // it into "slices" parts
-        let cmsg_buffers =
+        let mut cmsg_buffers =
             cmsg_buffer.map(|v| vec![0u8; v.capacity() * num_slices].into_boxed_slice());
 
         let items = addresses
             .iter_mut()
             .enumerate()
             .map(|(ix, address)| {
-                let (ptr, cap) = match &cmsg_buffers {
-                    Some(v) => ((&v[ix * msg_controllen] as *const u8), msg_controllen),
-                    None => (std::ptr::null(), 0),
+                let (ptr, cap) = match &mut cmsg_buffers {
+                    Some(v) => ((&mut v[ix * msg_controllen] as *mut u8), msg_controllen),
+                    None => (std::ptr::null_mut(), 0),
                 };
-                let msg_hdr = unsafe { pack_mhdr_to_receive(std::ptr::null(), 0, ptr, cap, address.as_mut_ptr()) };
+                let msg_hdr = unsafe { pack_mhdr_to_receive(std::ptr::null_mut(), 0, ptr, cap, address.as_mut_ptr()) };
                 libc::mmsghdr {
                     msg_hdr,
                     msg_len: 0,
@@ -1961,9 +1961,9 @@ unsafe fn read_mhdr<'a, 'i, S>(
 ///
 /// Buffers must remain valid for the whole lifetime of msghdr
 unsafe fn pack_mhdr_to_receive<S>(
-    iov_buffer: *const IoSliceMut,
+    iov_buffer: *mut IoSliceMut,
     iov_buffer_len: usize,
-    cmsg_buffer: *const u8,
+    cmsg_buffer: *mut u8,
     cmsg_capacity: usize,
     address: *mut S,
 ) -> msghdr
@@ -1999,7 +1999,7 @@ fn pack_mhdr_to_send<'a, I, C, S>(
 
     // The message header must be initialized before the individual cmsgs.
     let cmsg_ptr = if capacity > 0 {
-        cmsg_buffer.as_ptr() as *mut c_void
+        cmsg_buffer.as_mut_ptr() as *mut c_void
     } else {
         ptr::null_mut()
     };
@@ -2063,7 +2063,7 @@ pub fn recvmsg<'a, 'outer, 'inner, S>(fd: RawFd, iov: &'outer mut [IoSliceMut<'i
         .map(|v| (v.as_mut_ptr(), v.capacity()))
         .unwrap_or((ptr::null_mut(), 0));
     let mut mhdr = unsafe {
-        pack_mhdr_to_receive(iov.as_ref().as_ptr(), iov.len(), msg_control, msg_controllen, address.as_mut_ptr())
+        pack_mhdr_to_receive(iov.as_mut().as_mut_ptr(), iov.len(), msg_control, msg_controllen, address.as_mut_ptr())
     };
 
     let ret = unsafe { libc::recvmsg(fd, &mut mhdr, flags.bits()) };
@@ -2209,7 +2209,7 @@ pub fn recv(sockfd: RawFd, buf: &mut [u8], flags: MsgFlags) -> Result<usize> {
     unsafe {
         let ret = libc::recv(
             sockfd,
-            buf.as_ptr() as *mut c_void,
+            buf.as_mut_ptr() as *mut c_void,
             buf.len() as size_t,
             flags.bits(),
         );
@@ -2233,7 +2233,7 @@ pub fn recvfrom<T: SockaddrLike>(
 
         let ret = Errno::result(libc::recvfrom(
             sockfd,
-            buf.as_ptr() as *mut c_void,
+            buf.as_mut_ptr() as *mut c_void,
             buf.len() as size_t,
             0,
             addr.as_mut_ptr() as *mut sockaddr,

src/sys/uio.rs

@@ -27,6 +27,9 @@ pub fn writev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>]) -> Result<usize> {
 /// Low-level vectored read from a raw file descriptor
 ///
 /// See also [readv(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/readv.html)
+// Clippy doesn't know that we need to pass iov mutably only because the
+// mutation happens after converting iov to a pointer
+#[allow(clippy::needless_pass_by_ref_mut)]
 pub fn readv<Fd: AsFd>(fd: Fd, iov: &mut [IoSliceMut<'_>]) -> Result<usize> {
     // SAFETY: same as in writev(), IoSliceMut is ABI-compatible with iovec
     let res = unsafe {
@@ -70,6 +73,9 @@ pub fn pwritev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>], offset: off_t) -> Result<u
 /// See also: [`readv`](fn.readv.html) and [`pread`](fn.pread.html)
 #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
+// Clippy doesn't know that we need to pass iov mutably only because the
+// mutation happens after converting iov to a pointer
+#[allow(clippy::needless_pass_by_ref_mut)]
 pub fn preadv<Fd: AsFd>(
     fd: Fd,
     iov: &mut [IoSliceMut<'_>],