refactor: clarify variable names

Author: xtqqczze

fuzz/uufuzz/src/lib.rs

@@ -92,7 +92,7 @@ where
     };
 
     println!("Running test {:?}", &args[0..]);
-    let (read_pipe_stdout, write_pipe_stdout) = match pipe() {
+    let (stdout_pipe_reader, stdout_pipe_writer) = match pipe() {
         Ok(fds) => fds,
         Err(_) => {
             return CommandResult {
@@ -102,7 +102,7 @@ where
             };
         }
     };
-    let (read_pipe_stderr, write_pipe_stderr) = match pipe() {
+    let (stderr_pipe_reader, stderr_pipe_writer) = match pipe() {
         Ok(fds) => fds,
         Err(_) => {
             return CommandResult {
@@ -114,7 +114,7 @@ where
     };
 
     // Redirect stdout and stderr to their respective pipes
-    if dup2_stdout(&write_pipe_stdout).is_err() || dup2_stderr(&write_pipe_stderr).is_err() {
+    if dup2_stdout(&stdout_pipe_writer).is_err() || dup2_stderr(&stderr_pipe_writer).is_err() {
         return CommandResult {
             stdout: "".to_string(),
             stderr: "Failed to redirect STDOUT_FILENO or STDERR_FILENO".to_string(),
@@ -156,8 +156,8 @@ where
     };
 
     let (uumain_exit_status, captured_stdout, captured_stderr) = thread::scope(|s| {
-        let out = s.spawn(|| read_from_fd(read_pipe_stdout));
-        let err = s.spawn(|| read_from_fd(read_pipe_stderr));
+        let out = s.spawn(|| read_from_fd(stdout_pipe_reader));
+        let err = s.spawn(|| read_from_fd(stderr_pipe_reader));
         #[allow(clippy::unnecessary_to_owned)]
         // TODO: clippy wants us to use args.iter().cloned() ?
         let status = uumain_function(args.to_owned().into_iter());
@@ -167,8 +167,8 @@ where
         io::stdout().flush().unwrap();
         io::stderr().flush().unwrap();
         // Drop write ends to close them, allowing readers to get EOF
-        drop(write_pipe_stdout);
-        drop(write_pipe_stderr);
+        drop(stdout_pipe_writer);
+        drop(stderr_pipe_writer);
         // Restore stdout/stderr
         let _ = dup2_stdout(&original_stdout_fd_owned);
         let _ = dup2_stderr(&original_stderr_fd_owned);

src/uu/wc/src/count_fast.rs

@@ -55,13 +55,14 @@ fn count_bytes_using_splice(fd: &impl AsFd) -> Result<usize, usize> {
         }
     } else {
         // input is not pipe. needs broker to use splice() with additional cost
-        let (pipe_rd, pipe_wr) = pipe::<false>(MAX_ROOTLESS_PIPE_SIZE).map_err(|_| 0_usize)?;
+        let (pipe_reader, pipe_writer) =
+            pipe::<false>(MAX_ROOTLESS_PIPE_SIZE).map_err(|_| 0_usize)?;
         loop {
-            match splice(fd, &pipe_wr, MAX_ROOTLESS_PIPE_SIZE) {
+            match splice(fd, &pipe_writer, MAX_ROOTLESS_PIPE_SIZE) {
                 Ok(0) => return Ok(byte_count),
                 Ok(res) => {
                     byte_count += res;
-                    splice_exact(&pipe_rd, &null_file, res).map_err(|_| byte_count)?;
+                    splice_exact(&pipe_reader, &null_file, res).map_err(|_| byte_count)?;
                 }
                 Err(_) => return Err(byte_count),
             }

src/uu/yes/src/yes.rs

@@ -117,18 +117,19 @@ pub fn exec(mut bytes: Vec<u8>) -> io::Result<()> {
     // improve throughput
     let _ = rustix::pipe::fcntl_setpipe_size(&stdout, MAX_ROOTLESS_PIPE_SIZE);
     // don't show any error from fast-path and fallback to write for proper message
-    if let Ok((p_read, mut p_write)) = pipe::<true>(MAX_ROOTLESS_PIPE_SIZE)
-        && p_write.write_all(bytes).is_ok()
+    if let Ok((source_reader, mut source_writer)) = pipe::<true>(MAX_ROOTLESS_PIPE_SIZE)
+        && source_writer.write_all(bytes).is_ok()
     {
-        if aligned && tee(&p_read, &stdout, MAX_ROOTLESS_PIPE_SIZE).is_ok() {
-            while let Ok(1..) = tee(&p_read, &stdout, MAX_ROOTLESS_PIPE_SIZE) {}
-        } else if let Ok((broker_read, broker_write)) = pipe::<true>(MAX_ROOTLESS_PIPE_SIZE) {
+        if aligned && tee(&source_reader, &stdout, MAX_ROOTLESS_PIPE_SIZE).is_ok() {
+            while let Ok(1..) = tee(&source_reader, &stdout, MAX_ROOTLESS_PIPE_SIZE) {}
+        } else if let Ok((broker_reader, broker_writer)) = pipe::<true>(MAX_ROOTLESS_PIPE_SIZE) {
             // tee() cannot control offset and write to non-pipe
-            'hybrid: while let Ok(mut remain) = tee(&p_read, &broker_write, MAX_ROOTLESS_PIPE_SIZE)
+            'hybrid: while let Ok(mut remain) =
+                tee(&source_reader, &broker_writer, MAX_ROOTLESS_PIPE_SIZE)
             {
                 debug_assert!(remain == bytes.len(), "splice() should cleanup pipe");
                 while remain > 0 {
-                    if let Ok(s) = splice(&broker_read, &stdout, remain) {
+                    if let Ok(s) = splice(&broker_reader, &stdout, remain) {
                         remain -= s;
                     } else {
                         // avoid output breakage with reduced remain even if it would not happen

src/uucore/src/lib/features/buf_copy.rs

@@ -51,12 +51,12 @@ mod tests {
     fn test_copy_stream() {
         let mut dest_file = new_temp_file();
 
-        let (mut pipe_read, mut pipe_write) = std::io::pipe().unwrap();
+        let (mut pipe_reader, mut pipe_writer) = std::io::pipe().unwrap();
         let data = b"Hello, world!";
         let thread = thread::spawn(move || {
-            pipe_write.write_all(data).unwrap();
+            pipe_writer.write_all(data).unwrap();
         });
-        copy_stream(&mut pipe_read, &mut dest_file).unwrap();
+        copy_stream(&mut pipe_reader, &mut dest_file).unwrap();
         thread.join().unwrap();
 
         // We would have been at the end already, so seek again to the start.

src/uucore/src/lib/features/pipes.rs

@@ -30,16 +30,16 @@ const KERNEL_DEFAULT_PIPE_SIZE: usize = 64 * 1024;
 pub fn pipe<const SIZE_REQUIRED: bool>(
     s: usize,
 ) -> std::io::Result<(std::io::PipeReader, std::io::PipeWriter)> {
-    let (read, write) = std::io::pipe()?;
+    let (pipe_reader, pipe_writer) = std::io::pipe()?;
     // guard unnecessary syscall
     if s > KERNEL_DEFAULT_PIPE_SIZE {
-        let r = fcntl_setpipe_size(&read, s);
+        let r = fcntl_setpipe_size(&pipe_reader, s);
         if SIZE_REQUIRED {
             r?;
         }
     }
 
-    Ok((read, write))
+    Ok((pipe_reader, pipe_writer))
 }
 
 /// Less noisy wrapper around [`rustix::pipe::splice`].
@@ -120,7 +120,7 @@ where
 {
     static PIPE_CACHE: OnceLock<Option<(std::io::PipeReader, std::io::PipeWriter)>> =
         OnceLock::new();
-    let Some((pipe_rd, pipe_wr)) = PIPE_CACHE
+    let Some((pipe_reader, pipe_writer)) = PIPE_CACHE
         .get_or_init(|| pipe::<false>(MAX_ROOTLESS_PIPE_SIZE).ok())
         .as_ref()
     else {
@@ -133,18 +133,18 @@ where
     let _ = fcntl_setpipe_size(&mut *dest, MAX_ROOTLESS_PIPE_SIZE);
 
     loop {
-        match splice(&source, &pipe_wr, MAX_ROOTLESS_PIPE_SIZE) {
+        match splice(&source, &pipe_writer, MAX_ROOTLESS_PIPE_SIZE) {
             Ok(0) => return Ok(false),
             Ok(n) => {
-                if splice_exact(&pipe_rd, dest, n).is_err() {
+                if splice_exact(&pipe_reader, dest, n).is_err() {
                     // If the first splice manages to copy to the intermediate
                     // pipe, but the second splice to stdout fails for some reason
                     // we can recover by copying the data that we have from the
                     // intermediate pipe to stdout using unbuffered read/write. Then
                     // we tell the caller to fall back.
                     debug_assert!(n <= MAX_ROOTLESS_PIPE_SIZE, "unexpected RAM usage");
                     let mut drain = Vec::with_capacity(n);
-                    pipe_rd.take(n as u64).read_to_end(&mut drain)?;
+                    pipe_reader.take(n as u64).read_to_end(&mut drain)?;
                     crate::io::RawWriter(&dest).write_all(&drain)?;
                     return Ok(true);
                 }

tests/by-util/test_cat.rs

@@ -23,14 +23,14 @@ use uutests::util_name;
 #[test]
 fn test_cat_broken_pipe_nonzero_and_message() {
     use uutests::new_ucmd;
-    let (read, write) = std::io::pipe().expect("Failed to create pipe");
+    let (pipe_reader, pipe_writer) = std::io::pipe().expect("Failed to create pipe");
     // Close the read end to simulate a broken pipe on stdout
-    drop(read);
+    drop(pipe_reader);
     let content = (0..10000).map(|_| "x").collect::<String>();
 
     // On Unix, SIGPIPE should lead to a non-zero exit; ensure process exits and fails
     new_ucmd!()
-        .set_stdout(write)
+        .set_stdout(pipe_writer)
         .pipe_in(content.as_bytes())
         .fails();
 }

tests/by-util/test_tee.rs

@@ -262,19 +262,19 @@ mod linux_only {
     use uutests::new_ucmd;
 
     fn make_broken_pipe() -> std::io::PipeWriter {
-        let (read, write) = std::io::pipe().expect("Failed to create pipe");
+        let (reader, writer) = std::io::pipe().expect("Failed to create pipe");
         // Drop the read end of the pipe
-        drop(read);
+        drop(reader);
         // Return the write end of the pipe
-        write
+        writer
     }
 
     fn make_hanging_read() -> std::io::PipeReader {
-        let (read, write) = std::io::pipe().expect("Failed to create pipe");
+        let (reader, writer) = std::io::pipe().expect("Failed to create pipe");
         // PURPOSELY leak the write end of the pipe, so the read end hangs.
-        std::mem::forget(write);
+        std::mem::forget(writer);
         // Return the read end of the pipe
-        read
+        reader
     }
 
     fn run_tee(proc: &mut UCommand) -> (String, CmdResult) {
@@ -725,13 +725,13 @@ fn test_output_error_flag_without_value_defaults_warn_nopipe() {
 #[cfg(all(unix, not(target_os = "freebsd")))]
 #[test]
 fn test_output_error_presence_only_broken_pipe_unix() {
-    let (read, write) = std::io::pipe().expect("Failed to create pipe");
+    let (reader, writer) = std::io::pipe().expect("Failed to create pipe");
     // Close the read end to simulate a broken pipe on stdout
-    drop(read);
+    drop(reader);
     let content = (0..10_000).map(|_| "x").collect::<String>();
     let result = new_ucmd!()
         .arg("--output-error") // presence-only flag
-        .set_stdout(write)
+        .set_stdout(writer)
         .pipe_in(content.as_bytes())
         .run();
 
@@ -743,13 +743,13 @@ fn test_output_error_presence_only_broken_pipe_unix() {
 #[cfg(all(unix, not(target_os = "freebsd")))]
 #[test]
 fn test_broken_pipe_early_termination_stdout_only() {
-    let (read, write) = std::io::pipe().expect("Failed to create pipe");
+    let (reader, writer) = std::io::pipe().expect("Failed to create pipe");
     // Create a broken stdout
-    drop(read);
+    drop(reader);
     let content = (0..10_000).map(|_| "x").collect::<String>();
     let mut proc = new_ucmd!();
     let result = proc
-        .set_stdout(write)
+        .set_stdout(writer)
         .ignore_stdin_write_error()
         .pipe_in(content.as_bytes())
         .run();