Miscellaneous cleanups. (#652)

- Wrap some code comments at 79 columns, for consistency with the rest
   of the codebase.
 - Remove some redundant `use`s.
 - Fix some broken doc links.

Author: sunfishcode

src/backend/libc/fs/inotify.rs

@@ -113,7 +113,8 @@ pub fn inotify_add_watch<P: crate::path::Arg>(
 /// by [`inotify_add_watch`] and not previously have been removed.
 #[doc(alias = "inotify_rm_watch")]
 pub fn inotify_remove_watch(inot: BorrowedFd<'_>, wd: i32) -> io::Result<()> {
-    // Android's `inotify_rm_watch` takes u32 despite `inotify_add_watch` is i32.
+    // Android's `inotify_rm_watch` takes `u32` despite that
+    // `inotify_add_watch` expects a `i32`.
     #[cfg(target_os = "android")]
     let wd = wd as u32;
     // SAFETY: The fd is valid and closing an arbitrary wd is valid.

src/backend/libc/mod.rs

@@ -93,8 +93,8 @@ pub(crate) mod time;
 #[cfg(all(unix, target_env = "gnu"))]
 pub(crate) fn if_glibc_is_less_than_2_25() -> bool {
     // This is also defined inside `weak_or_syscall!` in
-    // backend/libc/rand/syscalls.rs, but it's not convenient to re-export the weak
-    // symbol from that macro, so we duplicate it at a small cost here.
+    // backend/libc/rand/syscalls.rs, but it's not convenient to re-export the
+    // weak symbol from that macro, so we duplicate it at a small cost here.
     weak! { fn getrandom(*mut c::c_void, c::size_t, c::c_uint) -> c::ssize_t }
 
     // glibc 2.25 has `getrandom`, which is how we satisfy the API contract of

src/backend/libc/net/addr.rs

@@ -97,8 +97,9 @@ impl SocketAddrUnix {
         if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char {
             let end = len as usize - offsetof_sun_path();
             let bytes = &self.unix.sun_path[..end];
-            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And
-            // `from_bytes_with_nul_unchecked` since the string is NUL-terminated.
+            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
+            // And `from_bytes_with_nul_unchecked` since the string is
+            // NUL-terminated.
             unsafe {
                 Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
                     bytes.as_ptr().cast(),

src/backend/libc/process/syscalls.rs

@@ -503,8 +503,8 @@ unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidS
     // `si_pid` is supposedly the better way to check that the struct has been
     // filled, e.g. the Linux manpage says about the `WNOHANG` case “zero out
     // the si_pid field before the call and check for a nonzero value”.
-    // But e.g. NetBSD/OpenBSD don't have it exposed in the libc crate for now, and
-    // some platforms don't have it at all. For simplicity, always check
+    // But e.g. NetBSD/OpenBSD don't have it exposed in the libc crate for now,
+    // and some platforms don't have it at all. For simplicity, always check
     // `si_signo`. We have zero-initialized the whole struct, and all kernels
     // should set `SIGCHLD` here.
     if status.si_signo == 0 {

src/backend/libc/thread/syscalls.rs

@@ -50,8 +50,8 @@ pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> Nanos
     let mut remain = MaybeUninit::<LibcTimespec>::uninit();
     let flags = 0;
 
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
+    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe
+    // by default.
     #[cfg(all(
         any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
         target_env = "gnu",
@@ -142,8 +142,8 @@ unsafe fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> Nanos
 pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::Result<()> {
     let flags = c::TIMER_ABSTIME;
 
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
+    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe
+    // by default.
     #[cfg(all(
         any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
         target_env = "gnu",

src/backend/linux_raw/conv.rs

@@ -143,9 +143,9 @@ impl<'a, Num: ArgNumber> From<Option<&'a CStr>> for ArgReg<'a, Num> {
 impl<'a, Num: ArgNumber> From<BorrowedFd<'a>> for ArgReg<'a, Num> {
     #[inline]
     fn from(fd: BorrowedFd<'a>) -> Self {
-        // SAFETY: `BorrowedFd` ensures that the file descriptor is valid, and the
-        // lifetime parameter on the resulting `ArgReg` ensures that the result is
-        // bounded by the `BorrowedFd`'s lifetime.
+        // SAFETY: `BorrowedFd` ensures that the file descriptor is valid, and
+        // the lifetime parameter on the resulting `ArgReg` ensures that the
+        // result is bounded by the `BorrowedFd`'s lifetime.
         unsafe { raw_fd(fd.as_raw_fd()) }
     }
 }

src/backend/linux_raw/io/errno.rs

@@ -62,8 +62,8 @@ impl Errno {
 
     /// Convert from a C `errno` value (which is positive) to an `Errno`.
     const fn from_errno(raw: u32) -> Self {
-        // We store error values in negated form, so that we don't have to negate
-        // them after every syscall.
+        // We store error values in negated form, so that we don't have to
+        // negate them after every syscall.
         let encoded = raw.wrapping_neg() as u16;
 
         // TODO: Use Range::contains, once that's `const`.

src/backend/linux_raw/net/addr.rs

@@ -74,8 +74,9 @@ impl SocketAddrUnix {
         if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char {
             let end = len as usize - offsetof_sun_path();
             let bytes = &self.unix.sun_path[..end];
-            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And
-            // `from_bytes_with_nul_unchecked` since the string is NUL-terminated.
+            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
+            // And `from_bytes_with_nul_unchecked` since the string is
+            // NUL-terminated.
             unsafe {
                 Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
                     bytes.as_ptr().cast(),

src/backend/linux_raw/vdso_wrappers.rs

@@ -376,8 +376,8 @@ fn init() {
             assert!(!ptr.is_null());
 
             // SAFETY: Store the computed function addresses in static storage
-            // so that we don't need to compute it again (but if we do, it doesn't
-            // hurt anything).
+            // so that we don't need to compute it again (but if we do, it
+            // doesn't hurt anything).
             unsafe {
                 CLOCK_GETTIME.store(ptr.cast(), Relaxed);
             }

src/cstr.rs

@@ -40,9 +40,9 @@ macro_rules! cstr {
 
         #[allow(unsafe_code, unused_unsafe)]
         {
-            // Now that we know the string doesn't have embedded NULs, we can call
-            // `from_bytes_with_nul_unchecked`, which as of this writing is defined
-            // as `#[inline]` and completely optimizes away.
+            // Now that we know the string doesn't have embedded NULs, we can
+            // call `from_bytes_with_nul_unchecked`, which as of this writing
+            // is defined as `#[inline]` and completely optimizes away.
             //
             // SAFETY: We have manually checked that the string does not contain
             // embedded NULs above, and we append or own NUL terminator here.