Fix future clippy lints (#15519)

- suggestions for tersity using helpers

crates/nu-command/src/filesystem/rm.rs

@@ -10,11 +10,7 @@ use nu_protocol::{
 };
 #[cfg(unix)]
 use std::os::unix::prelude::FileTypeExt;
-use std::{
-    collections::HashMap,
-    io::{Error, ErrorKind},
-    path::PathBuf,
-};
+use std::{collections::HashMap, io::Error, path::PathBuf};
 
 const TRASH_SUPPORTED: bool = cfg!(all(
     feature = "trash-support",
@@ -379,7 +375,7 @@ fn rm(
                 );
 
                 let result = if let Err(e) = interaction {
-                    Err(Error::new(ErrorKind::Other, &*e.to_string()))
+                    Err(Error::other(&*e.to_string()))
                 } else if interactive && !confirmed {
                     Ok(())
                 } else if TRASH_SUPPORTED && (trash || (rm_always_trash && !permanent)) {
@@ -389,7 +385,7 @@ fn rm(
                     ))]
                     {
                         trash::delete(&f).map_err(|e: trash::Error| {
-                            Error::new(ErrorKind::Other, format!("{e:?}\nTry '--permanent' flag"))
+                            Error::other(format!("{e:?}\nTry '--permanent' flag"))
                         })
                     }
 

crates/nu-command/src/filters/tee.rs

@@ -394,7 +394,7 @@ impl<R: Read> Read for IoTee<R> {
         if let Some(thread) = self.thread.take() {
             if thread.is_finished() {
                 if let Err(err) = thread.join().unwrap_or_else(|_| Err(panic_error())) {
-                    return Err(io::Error::new(io::ErrorKind::Other, err));
+                    return Err(io::Error::other(err));
                 }
             } else {
                 self.thread = Some(thread)
@@ -405,7 +405,7 @@ impl<R: Read> Read for IoTee<R> {
             self.sender = None;
             if let Some(thread) = self.thread.take() {
                 if let Err(err) = thread.join().unwrap_or_else(|_| Err(panic_error())) {
-                    return Err(io::Error::new(io::ErrorKind::Other, err));
+                    return Err(io::Error::other(err));
                 }
             }
         } else if let Some(sender) = self.sender.as_mut() {

crates/nu-json/src/value.rs

@@ -437,7 +437,7 @@ impl io::Write for WriterFormatter<'_, '_> {
         fn io_error<E>(_: E) -> io::Error {
             // Value does not matter because fmt::Debug and fmt::Display impls
             // below just map it to fmt::Error
-            io::Error::new(io::ErrorKind::Other, "fmt error")
+            io::Error::other("fmt error")
         }
         let s = str::from_utf8(buf).map_err(io_error)?;
         self.inner.write_str(s).map_err(io_error)?;

crates/nu-protocol/src/engine/stack_out_dest.rs

@@ -91,12 +91,12 @@ impl StackOutDest {
 
     fn push_stdout(&mut self, stdout: OutDest) -> Option<OutDest> {
         let stdout = mem::replace(&mut self.stdout, stdout);
-        mem::replace(&mut self.parent_stdout, Some(stdout))
+        self.parent_stdout.replace(stdout)
     }
 
     fn push_stderr(&mut self, stderr: OutDest) -> Option<OutDest> {
         let stderr = mem::replace(&mut self.stderr, stderr);
-        mem::replace(&mut self.parent_stderr, Some(stderr))
+        self.parent_stderr.replace(stderr)
     }
 }
 
@@ -118,13 +118,13 @@ impl<'a> StackIoGuard<'a> {
 
         let (old_pipe_stdout, old_parent_stdout) = match stdout {
             Some(Redirection::Pipe(stdout)) => {
-                let old = mem::replace(&mut out_dest.pipe_stdout, Some(stdout));
+                let old = out_dest.pipe_stdout.replace(stdout);
                 (old, out_dest.parent_stdout.take())
             }
             Some(Redirection::File(file)) => {
                 let file = OutDest::from(file);
                 (
-                    mem::replace(&mut out_dest.pipe_stdout, Some(file.clone())),
+                    out_dest.pipe_stdout.replace(file.clone()),
                     out_dest.push_stdout(file),
                 )
             }
@@ -133,7 +133,7 @@ impl<'a> StackIoGuard<'a> {
 
         let (old_pipe_stderr, old_parent_stderr) = match stderr {
             Some(Redirection::Pipe(stderr)) => {
-                let old = mem::replace(&mut out_dest.pipe_stderr, Some(stderr));
+                let old = out_dest.pipe_stderr.replace(stderr);
                 (old, out_dest.parent_stderr.take())
             }
             Some(Redirection::File(file)) => (
@@ -192,7 +192,7 @@ pub struct StackCollectValueGuard<'a> {
 
 impl<'a> StackCollectValueGuard<'a> {
     pub(crate) fn new(stack: &'a mut Stack) -> Self {
-        let old_pipe_stdout = mem::replace(&mut stack.out_dest.pipe_stdout, Some(OutDest::Value));
+        let old_pipe_stdout = stack.out_dest.pipe_stdout.replace(OutDest::Value);
         let old_pipe_stderr = stack.out_dest.pipe_stderr.take();
         Self {
             stack,
@@ -233,7 +233,7 @@ pub struct StackCallArgGuard<'a> {
 
 impl<'a> StackCallArgGuard<'a> {
     pub(crate) fn new(stack: &'a mut Stack) -> Self {
-        let old_pipe_stdout = mem::replace(&mut stack.out_dest.pipe_stdout, Some(OutDest::Value));
+        let old_pipe_stdout = stack.out_dest.pipe_stdout.replace(OutDest::Value);
         let old_pipe_stderr = stack.out_dest.pipe_stderr.take();
 
         let old_stdout = stack

crates/nu-system/src/util.rs

@@ -8,10 +8,7 @@ pub fn kill_by_pid(pid: i64) -> io::Result<()> {
     let output = cmd.output()?;
 
     if !output.status.success() {
-        return Err(io::Error::new(
-            io::ErrorKind::Other,
-            "failed to kill process",
-        ));
+        return Err(io::Error::other("failed to kill process"));
     }
 
     Ok(())