refactor: avoid std::io::Error imports

xtqqczze · xtqqczze · commit e47184073e11 · 2026-04-29T16:02:11.000+01:00
diff --git a/src/uu/chroot/src/chroot.rs b/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())
     }
 }
 
diff --git a/src/uu/chroot/src/error.rs b/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 {
diff --git a/src/uu/env/src/env.rs b/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))]
diff --git a/src/uu/kill/src/kill.rs b/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) })
             );
         }
diff --git a/src/uu/nohup/src/nohup.rs b/src/uu/nohup/src/nohup.rs
@@ -11,7 +11,7 @@ use clap::{Arg, ArgAction, Command};
 use libc::{SIG_IGN, SIGHUP, dup2, signal};
 use std::env;
 use std::fs::{File, OpenOptions};
-use std::io::{Error, ErrorKind, IsTerminal};
+use std::io::{ErrorKind, IsTerminal};
 use std::os::unix::prelude::*;
 use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
@@ -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 {
@@ -118,7 +118,7 @@ fn replace_fds() -> UResult<()> {
         let new_stdin = File::open(Path::new("/dev/null"))
             .map_err(|e| NohupError::CannotReplace("STDIN", e))?;
         if unsafe { dup2(new_stdin.as_raw_fd(), 0) } != 0 {
-            return Err(NohupError::CannotReplace("STDIN", Error::last_os_error()).into());
+            return Err(NohupError::CannotReplace("STDIN", std::io::Error::last_os_error()).into());
         }
     }
 
@@ -127,12 +127,14 @@ fn replace_fds() -> UResult<()> {
         let fd = new_stdout.as_raw_fd();
 
         if unsafe { dup2(fd, 1) } != 1 {
-            return Err(NohupError::CannotReplace("STDOUT", Error::last_os_error()).into());
+            return Err(
+                NohupError::CannotReplace("STDOUT", std::io::Error::last_os_error()).into(),
+            );
         }
     }
 
     if std::io::stderr().is_terminal() && unsafe { dup2(1, 2) } != 2 {
-        return Err(NohupError::CannotReplace("STDERR", Error::last_os_error()).into());
+        return Err(NohupError::CannotReplace("STDERR", std::io::Error::last_os_error()).into());
     }
     Ok(())
 }
diff --git a/src/uu/numfmt/src/numfmt.rs b/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"))
         }
     }
 
diff --git a/src/uu/od/src/mockstream.rs b/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))
         }
     }
 }
diff --git a/src/uu/split/src/platform/unix.rs b/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()
                         ))
diff --git a/src/uu/split/src/platform/windows.rs b/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()),
                 )
             })?
diff --git a/src/uu/tee/src/tee.rs b/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(())
     }
@@ -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<()> {
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
@@ -26,7 +26,7 @@ use std::ffi::{OsStr, OsString};
 #[cfg(unix)]
 use std::fs::OpenOptions;
 use std::fs::{self, File};
-use std::io::{Error, ErrorKind};
+use std::io::ErrorKind;
 #[cfg(unix)]
 use std::os::unix::fs::OpenOptionsExt;
 use std::path::{Path, PathBuf};
@@ -497,7 +497,8 @@ fn touch_file(
                 false
             };
             if is_directory {
-                let custom_err = Error::other(translate!("touch-error-no-such-file-or-directory"));
+                let custom_err =
+                    std::io::Error::other(translate!("touch-error-no-such-file-or-directory"));
                 return Err(custom_err.map_err_context(
                     || translate!("touch-error-cannot-touch", "filename" => filename.quote()),
                 ));
@@ -628,7 +629,7 @@ fn try_futimens_via_write_fd(path: &Path, atime: FileTime, mtime: FileTime) -> s
         },
     };
 
-    futimens(&file, &timestamps).map_err(|e| Error::from_raw_os_error(e.raw_os_error()))
+    futimens(&file, &timestamps).map_err(|e| std::io::Error::from_raw_os_error(e.raw_os_error()))
 }
 
 /// Get metadata of the provided path
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
@@ -39,7 +39,6 @@ use libc::{getgrgid, getgrnam, getgroups};
 use libc::{getpwnam, getpwuid, group, passwd};
 
 use std::ffi::{CStr, CString};
-use std::io::Error as IOError;
 use std::io::ErrorKind;
 use std::io::Result as IOResult;
 use std::ptr;
@@ -68,7 +67,7 @@ pub fn get_groups() -> IOResult<Vec<gid_t>> {
     let mut groups = Vec::new();
     loop {
         let ngroups = match unsafe { getgroups(0, ptr::null_mut()) } {
-            -1 => return Err(IOError::last_os_error()),
+            -1 => return Err(std::io::Error::last_os_error()),
             // Not just optimization; 0 would mess up the next call
             0 => return Ok(Vec::new()),
             n => n,
@@ -79,7 +78,7 @@ pub fn get_groups() -> IOResult<Vec<gid_t>> {
         groups.resize(ngroups.try_into().unwrap(), 0);
         let res = unsafe { getgroups(ngroups, groups.as_mut_ptr()) };
         if res == -1 {
-            let err = IOError::last_os_error();
+            let err = std::io::Error::last_os_error();
             if err.raw_os_error() == Some(libc::EINVAL) {
                 // Number of groups has increased, retry
             } else {
@@ -299,7 +298,7 @@ macro_rules! f {
                         // errno must be set to zero before the call. We can
                         // use libc::__errno_location() on some platforms.
                         // The same applies for the two cases below.
-                        Err(IOError::new(
+                        Err(std::io::Error::new(
                             ErrorKind::NotFound,
                             format!("No such id: {k}"),
                         ))
@@ -326,13 +325,16 @@ macro_rules! f {
                         if !data.is_null() {
                             Ok($st::from_raw(ptr::read(data.cast_const())))
                         } else {
-                            Err(IOError::new(
+                            Err(std::io::Error::new(
                                 ErrorKind::NotFound,
                                 format!("No such id: {id}"),
                             ))
                         }
                     } else {
-                        Err(IOError::new(ErrorKind::NotFound, format!("Not found: {k}")))
+                        Err(std::io::Error::new(
+                            ErrorKind::NotFound,
+                            format!("Not found: {k}"),
+                        ))
                     }
                 }
             }
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs
diff --git a/src/uucore/src/lib/features/smack.rs b/src/uucore/src/lib/features/smack.rs
diff --git a/src/uucore/src/lib/features/systemd_logind.rs b/src/uucore/src/lib/features/systemd_logind.rs
diff --git a/tests/by-util/test_cat.rs b/tests/by-util/test_cat.rs

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ mod error;`
`9`	`9`	`use crate::error::ChrootError;`
`10`	`10`	`use clap::{Arg, ArgAction, Command};`
`11`	`11`	`use std::ffi::OsStr;`
`12`		`-use std::io::{Error, ErrorKind};`
	`12`	`+use std::io::ErrorKind;`
`13`	`13`	`use std::os::unix::process::CommandExt;`
`14`	`14`	`use std::path::{Path, PathBuf};`
`15`	`15`	`use std::process;`
`@@ -317,7 +317,7 @@ fn set_supplemental_gids(gids: &[libc::gid_t]) -> std::io::Result<()> {`
`317`	`317`	`if err == 0 {`
`318`	`318`	`Ok(())`
`319`	`319`	`} else {`
`320`		`- Err(Error::last_os_error())`
	`320`	`+ Err(std::io::Error::last_os_error())`
`321`	`321`	`}`
`322`	`322`	`}`
`323`	`323`
`@@ -327,7 +327,7 @@ fn set_gid(gid: libc::gid_t) -> std::io::Result<()> {`
`327`	`327`	`if err == 0 {`
`328`	`328`	`Ok(())`
`329`	`329`	`} else {`
`330`		`- Err(Error::last_os_error())`
	`330`	`+ Err(std::io::Error::last_os_error())`
`331`	`331`	`}`
`332`	`332`	`}`
`333`	`333`
`@@ -337,7 +337,7 @@ fn set_uid(uid: libc::uid_t) -> std::io::Result<()> {`
`337`	`337`	`if err == 0 {`
`338`	`338`	`Ok(())`
`339`	`339`	`} else {`
`340`		`- Err(Error::last_os_error())`
	`340`	`+ Err(std::io::Error::last_os_error())`
`341`	`341`	`}`
`342`	`342`	`}`
`343`	`343`
Original file line number	Diff line number	Diff line change
`@@ -575,12 +575,12 @@ mod tests {`
`575`	`575`	`FormatOptions, InvalidModes, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit,`
`576`	`576`	`handle_args, handle_buffer, parse_unit_size, parse_unit_size_suffix,`
`577`	`577`	`};`
`578`		`- use std::io::{BufReader, Error, ErrorKind, Read};`
	`578`	`+ use std::io::{BufReader, ErrorKind, Read};`
`579`	`579`	`struct MockBuffer {}`
`580`	`580`
`581`	`581`	`impl Read for MockBuffer {`
`582`		`- fn read(&mut self, _: &mut [u8]) -> Result<usize, Error> {`
`583`		`- Err(Error::new(ErrorKind::BrokenPipe, "broken pipe"))`
	`582`	`+ fn read(&mut self, _: &mut [u8]) -> Result<usize, std::io::Error> {`
	`583`	`+ Err(std::io::Error::new(ErrorKind::BrokenPipe, "broken pipe"))`
`584`	`584`	`}`
`585`	`585`	`}`
`586`	`586`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`// file that was distributed with this source code.`
`5`	`5`	`// https://github.com/lazy-bitfield/rust-mockstream/pull/2`
`6`	`6`
`7`		`-use std::io::{Cursor, Error, ErrorKind, Read, Result};`
	`7`	`+use std::io::{Cursor, ErrorKind, Read, Result};`
`8`	`8`
`9`	`9`	/// `FailingMockStream` mocks a stream which will fail upon read or write
`10`	`10`	`///`
`@@ -73,7 +73,7 @@ impl FailingMockStream {`
`73`	`73`	`if self.repeat_count > 0 {`
`74`	`74`	`self.repeat_count -= 1;`
`75`	`75`	`}`
`76`		`- Err(Error::new(self.kind, self.message))`
	`76`	`+ Err(std::io::Error::new(self.kind, self.message))`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`	`}`