refactor: avoid std::io::Error imports

Author: xtqqczze

src/uu/chroot/src/chroot.rs

@@ -9,7 +9,7 @@ mod error;
 use crate::error::ChrootError;
 use clap::{Arg, ArgAction, Command};
 use std::ffi::OsStr;
-use std::io::{Error, ErrorKind};
+use std::io::ErrorKind;
 use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process;
@@ -317,7 +317,7 @@ fn set_supplemental_gids(gids: &[libc::gid_t]) -> std::io::Result<()> {
     if err == 0 {
         Ok(())
     } else {
-        Err(Error::last_os_error())
+        Err(std::io::Error::last_os_error())
     }
 }
 
@@ -327,7 +327,7 @@ fn set_gid(gid: libc::gid_t) -> std::io::Result<()> {
     if err == 0 {
         Ok(())
     } else {
-        Err(Error::last_os_error())
+        Err(std::io::Error::last_os_error())
     }
 }
 
@@ -337,7 +337,7 @@ fn set_uid(uid: libc::uid_t) -> std::io::Result<()> {
     if err == 0 {
         Ok(())
     } else {
-        Err(Error::last_os_error())
+        Err(std::io::Error::last_os_error())
     }
 }
 

src/uu/chroot/src/error.rs

@@ -5,7 +5,6 @@
 // spell-checker:ignore NEWROOT Userspec userspec
 //! Errors returned by chroot.
 use std::ffi::OsString;
-use std::io::Error;
 use std::path::PathBuf;
 use uucore::display::Quotable;
 use uucore::error::UError;
@@ -17,15 +16,15 @@ use uucore::translate;
 pub enum ChrootError {
     /// Failed to enter the specified directory.
     #[error("{}", translate!("chroot-error-cannot-enter", "dir" => _0.quote(), "err" => _1))]
-    CannotEnter(PathBuf, #[source] Error),
+    CannotEnter(PathBuf, #[source] std::io::Error),
 
     /// Failed to execute the specified command.
     #[error("{}", translate!("chroot-error-command-failed", "cmd" => _0.quote(), "err" => _1))]
-    CommandFailed(OsString, #[source] Error),
+    CommandFailed(OsString, #[source] std::io::Error),
 
     /// Failed to find the specified command.
     #[error("{}", translate!("chroot-error-command-not-found", "cmd" => _0.quote(), "err" => _1))]
-    CommandNotFound(OsString, #[source] Error),
+    CommandNotFound(OsString, #[source] std::io::Error),
 
     #[error("{}", translate!("chroot-error-groups-parsing-failed"))]
     GroupsParsingFailed,
@@ -57,15 +56,15 @@ pub enum ChrootError {
 
     /// The call to `setgid()` failed.
     #[error("{}", translate!("chroot-error-set-gid-failed", "gid" => _0, "err" => _1))]
-    SetGidFailed(String, #[source] Error),
+    SetGidFailed(String, #[source] std::io::Error),
 
     /// The call to `setgroups()` failed.
     #[error("{}", translate!("chroot-error-set-groups-failed", "err" => _0))]
-    SetGroupsFailed(Error),
+    SetGroupsFailed(std::io::Error),
 
     /// The call to `setuid()` failed.
     #[error("{}", translate!("chroot-error-set-user-failed", "user" => _0.maybe_quote(), "err" => _1))]
-    SetUserFailed(String, #[source] Error),
+    SetUserFailed(String, #[source] std::io::Error),
 }
 
 impl UError for ChrootError {

src/uu/env/src/env.rs

@@ -47,7 +47,6 @@ use uucore::signals::{signal_by_name_or_value, signal_name_by_value, signal_numb
 use uucore::translate;
 use uucore::{format_usage, show_warning};
 
-
 #[derive(Debug, PartialEq, thiserror::Error)]
 pub enum EnvError {
     #[error("{}", translate!("env-error-missing-closing-quote", "position" => .0, "quote" => .1))]

src/uu/kill/src/kill.rs

@@ -8,7 +8,6 @@
 use clap::{Arg, ArgAction, Command};
 use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
-use std::io::Error;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::translate;
@@ -76,7 +75,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             } else {
                 let sig = (sig as i32)
                     .try_into()
-                    .map_err(|e| Error::from_raw_os_error(e as i32))?;
+                    .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
                 Some(sig)
             };
 
@@ -254,7 +253,7 @@ fn kill(sig: Option<Signal>, pids: &[i32]) {
     for &pid in pids {
         if let Err(e) = signal::kill(Pid::from_raw(pid), sig) {
             show!(
-                Error::from_raw_os_error(e as i32)
+                std::io::Error::from_raw_os_error(e as i32)
                     .map_err_context(|| { translate!("kill-error-sending-signal", "pid" => pid) })
             );
         }

src/uu/nohup/src/nohup.rs

@@ -11,7 +11,7 @@ use clap::{Arg, ArgAction, Command};
 use rustix::stdio::{dup2_stderr, dup2_stdin, dup2_stdout, stdout};
 use std::env;
 use std::fs::{File, OpenOptions};
-use std::io::{Error, ErrorKind, IsTerminal};
+use std::io::{ErrorKind, IsTerminal};
 use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process;
@@ -39,13 +39,13 @@ enum NohupError {
     CannotDetach,
 
     #[error("{}", translate!("nohup-error-cannot-replace", "name" => (*_0), "err" => _1))]
-    CannotReplace(&'static str, #[source] Error),
+    CannotReplace(&'static str, #[source] std::io::Error),
 
     #[error("{}", translate!("nohup-error-open-failed", "path" => NOHUP_OUT.quote(), "err" => _1))]
-    OpenFailed(i32, #[source] Error),
+    OpenFailed(i32, #[source] std::io::Error),
 
     #[error("{}", translate!("nohup-error-open-failed-both", "first_path" => NOHUP_OUT.quote(), "first_err" => _1, "second_path" => _2.quote(), "second_err" => _3))]
-    OpenFailed2(i32, #[source] Error, String, Error),
+    OpenFailed2(i32, #[source] std::io::Error, String, std::io::Error),
 }
 
 impl UError for NohupError {
@@ -119,18 +119,20 @@ fn replace_fds() -> UResult<()> {
     if std::io::stdin().is_terminal() {
         let new_stdin = File::open(Path::new("/dev/null"))
             .map_err(|e| NohupError::CannotReplace("STDIN", e))?;
-        dup2_stdin(&new_stdin).map_err(|e| NohupError::CannotReplace("STDIN", Error::from(e)))?;
+        dup2_stdin(&new_stdin)
+            .map_err(|e| NohupError::CannotReplace("STDIN", std::io::Error::from(e)))?;
     }
 
     if std::io::stdout().is_terminal() {
         let new_stdout = find_stdout()?;
 
         dup2_stdout(&new_stdout)
-            .map_err(|e| NohupError::CannotReplace("STDOUT", Error::from(e)))?;
+            .map_err(|e| NohupError::CannotReplace("STDOUT", std::io::Error::from(e)))?;
     }
 
     if std::io::stderr().is_terminal() {
-        dup2_stderr(stdout()).map_err(|e| NohupError::CannotReplace("STDERR", Error::from(e)))?;
+        dup2_stderr(stdout())
+            .map_err(|e| NohupError::CannotReplace("STDERR", std::io::Error::from(e)))?;
     }
     Ok(())
 }

src/uu/numfmt/src/numfmt.rs

@@ -575,12 +575,12 @@ mod tests {
         FormatOptions, InvalidModes, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit,
         handle_args, handle_buffer, parse_unit_size, parse_unit_size_suffix,
     };
-    use std::io::{BufReader, Error, ErrorKind, Read};
+    use std::io::{BufReader, ErrorKind, Read};
     struct MockBuffer {}
 
     impl Read for MockBuffer {
-        fn read(&mut self, _: &mut [u8]) -> Result<usize, Error> {
-            Err(Error::new(ErrorKind::BrokenPipe, "broken pipe"))
+        fn read(&mut self, _: &mut [u8]) -> Result<usize, std::io::Error> {
+            Err(std::io::Error::new(ErrorKind::BrokenPipe, "broken pipe"))
         }
     }
 

src/uu/od/src/mockstream.rs

@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 // https://github.com/lazy-bitfield/rust-mockstream/pull/2
 
-use std::io::{Cursor, Error, ErrorKind, Read, Result};
+use std::io::{Cursor, ErrorKind, Read, Result};
 
 /// `FailingMockStream` mocks a stream which will fail upon read or write
 ///
@@ -73,7 +73,7 @@ impl FailingMockStream {
             if self.repeat_count > 0 {
                 self.repeat_count -= 1;
             }
-            Err(Error::new(self.kind, self.message))
+            Err(std::io::Error::new(self.kind, self.message))
         }
     }
 }

src/uu/split/src/platform/unix.rs

@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 use std::env;
 use std::ffi::{OsStr, OsString};
-use std::io::{BufWriter, Error, Result};
+use std::io::{BufWriter, Result};
 use std::io::{ErrorKind, Write};
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
@@ -141,10 +141,10 @@ pub fn instantiate_current_writer(
                     .truncate(true)
                     .open(Path::new(filename))
                     .map_err(|e| match e.kind() {
-                        ErrorKind::IsADirectory => Error::other(
+                        ErrorKind::IsADirectory => std::io::Error::other(
                             translate!("split-error-is-a-directory", "dir" => filename.quote()),
                         ),
-                        _ => Error::other(
+                        _ => std::io::Error::other(
                             translate!("split-error-unable-to-open-file", "file" => filename.quote()),
                         ),
                     })?
@@ -154,7 +154,7 @@ pub fn instantiate_current_writer(
                     .append(true)
                     .open(Path::new(filename))
                     .map_err(|_| {
-                        Error::other(translate!(
+                        std::io::Error::other(translate!(
                             "split-error-unable-to-reopen-file",
                             "file" => filename.quote()
                         ))

src/uu/split/src/platform/windows.rs

@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use std::ffi::OsStr;
-use std::io::{BufWriter, Error, Result};
+use std::io::{BufWriter, Result};
 use std::io::{ErrorKind, Write};
 use std::path::Path;
 use uucore::display::Quotable;
@@ -27,10 +27,10 @@ pub fn instantiate_current_writer(
             .truncate(true)
             .open(Path::new(filename))
             .map_err(|e| match e.kind() {
-                ErrorKind::IsADirectory => Error::other(
+                ErrorKind::IsADirectory => std::io::Error::other(
                     translate!("split-error-is-a-directory", "dir" => filename.quote()),
                 ),
-                _ => Error::other(
+                _ => std::io::Error::other(
                     translate!("split-error-unable-to-open-file", "file" => filename.quote()),
                 ),
             })?
@@ -40,7 +40,7 @@ pub fn instantiate_current_writer(
             .append(true)
             .open(Path::new(filename))
             .map_err(|_| {
-                Error::other(
+                std::io::Error::other(
                     translate!("split-error-unable-to-reopen-file", "file" => filename.quote()),
                 )
             })?

src/uu/tee/src/tee.rs

@@ -7,7 +7,7 @@
 
 use std::ffi::OsString;
 use std::fs::OpenOptions;
-use std::io::{Error, ErrorKind, Read, Result, Write, stderr, stdin, stdout};
+use std::io::{ErrorKind, Read, Result, Write, stderr, stdin, stdout};
 use std::path::PathBuf;
 use uucore::display::Quotable;
 use uucore::error::{UResult, strip_errno};
@@ -63,10 +63,10 @@ fn tee(options: &Options) -> Result<()> {
         // This is therefore just a clever way to stop all writers
 
         if options.ignore_interrupts {
-            ignore_interrupts().map_err(|_| Error::from(ErrorKind::Other))?;
+            ignore_interrupts().map_err(|_| std::io::Error::from(ErrorKind::Other))?;
         }
         if options.output_error.is_some() {
-            disable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
+            disable_pipe_errors().map_err(|_| std::io::Error::from(ErrorKind::Other))?;
         }
     }
     let mut writers: Vec<NamedWriter> = options
@@ -104,7 +104,7 @@ fn tee(options: &Options) -> Result<()> {
     };
 
     if had_open_errors || res.is_err() || output.error_occurred() {
-        Err(Error::from(ErrorKind::Other))
+        Err(std::io::Error::from(ErrorKind::Other))
     } else {
         Ok(())
     }
@@ -144,7 +144,7 @@ struct MultiWriter {
     writers: Vec<NamedWriter>,
     output_error_mode: Option<OutputErrorMode>,
     ignored_errors: usize,
-    aborted: Option<Error>,
+    aborted: Option<std::io::Error>,
 }
 
 impl MultiWriter {
@@ -217,7 +217,7 @@ impl MultiWriter {
                 // This error kind will never be raised by the standard
                 // library, so we can use it for early termination of
                 // `copy`
-                Err(Error::from(ErrorKind::Other))
+                Err(std::io::Error::from(ErrorKind::Other))
             } else {
                 Ok(())
             },
@@ -228,7 +228,7 @@ impl MultiWriter {
 
 fn process_error(
     mode: Option<OutputErrorMode>,
-    e: Error,
+    e: std::io::Error,
     writer: &NamedWriter,
     ignored_errors: &mut usize,
 ) -> Result<()> {