crate::io::Result → io::Result in most places

library/std/src/os/fd/owned.rs

@@ -91,7 +91,7 @@ impl OwnedFd {
     /// Creates a new `OwnedFd` instance that shares the same underlying file
     /// description as the existing `OwnedFd` instance.
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone(&self) -> crate::io::Result<Self> {
+    pub fn try_clone(&self) -> io::Result<Self> {
         self.as_fd().try_clone_to_owned()
     }
 }
@@ -106,7 +106,7 @@ impl BorrowedFd<'_> {
         target_os = "motor"
     )))]
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
+    pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
         // We want to atomically duplicate this file descriptor and set the
         // CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This
         // is a POSIX flag that was added to Linux in 2.6.24.
@@ -129,15 +129,15 @@ impl BorrowedFd<'_> {
     /// description as the existing `BorrowedFd` instance.
     #[cfg(any(target_arch = "wasm32", target_os = "hermit", target_os = "trusty"))]
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
-        Err(crate::io::Error::UNSUPPORTED_PLATFORM)
+    pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
+        Err(io::Error::UNSUPPORTED_PLATFORM)
     }
 
     /// Creates a new `OwnedFd` instance that shares the same underlying file
     /// description as the existing `BorrowedFd` instance.
     #[cfg(target_os = "motor")]
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
+    pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
         let fd = moto_rt::fs::duplicate(self.as_raw_fd()).map_err(crate::sys::map_motor_error)?;
         Ok(unsafe { OwnedFd::from_raw_fd(fd) })
     }
@@ -233,7 +233,7 @@ macro_rules! impl_is_terminal {
         impl crate::sealed::Sealed for $t {}
 
         #[stable(feature = "is_terminal", since = "1.70.0")]
-        impl crate::io::IsTerminal for $t {
+        impl io::IsTerminal for $t {
             #[inline]
             fn is_terminal(&self) -> bool {
                 crate::sys::io::is_terminal(self)

library/std/src/os/solid/io.rs

@@ -49,7 +49,7 @@
 use crate::marker::PhantomData;
 use crate::mem::ManuallyDrop;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
-use crate::{fmt, net, sys};
+use crate::{fmt, io, net, sys};
 
 /// Raw file descriptors.
 pub type RawFd = i32;
@@ -110,15 +110,15 @@ impl BorrowedFd<'_> {
 impl OwnedFd {
     /// Creates a new `OwnedFd` instance that shares the same underlying file
     /// description as the existing `OwnedFd` instance.
-    pub fn try_clone(&self) -> crate::io::Result<Self> {
+    pub fn try_clone(&self) -> io::Result<Self> {
         self.as_fd().try_clone_to_owned()
     }
 }
 
 impl BorrowedFd<'_> {
     /// Creates a new `OwnedFd` instance that shares the same underlying file
     /// description as the existing `BorrowedFd` instance.
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
+    pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
         let fd = sys::net::cvt(unsafe { crate::sys::abi::sockets::dup(self.as_raw_fd()) })?;
         Ok(unsafe { OwnedFd::from_raw_fd(fd) })
     }
@@ -184,7 +184,7 @@ macro_rules! impl_is_terminal {
         impl crate::sealed::Sealed for $t {}
 
         #[stable(feature = "is_terminal", since = "1.70.0")]
-        impl crate::io::IsTerminal for $t {
+        impl io::IsTerminal for $t {
             #[inline]
             fn is_terminal(&self) -> bool {
                 crate::sys::io::is_terminal(self)

library/std/src/os/unix/net/addr.rs

@@ -264,7 +264,7 @@ impl linux_ext::addr::SocketAddrExt for SocketAddr {
         if let AddressKind::Abstract(name) = self.address() { Some(name.as_bytes()) } else { None }
     }
 
-    fn from_abstract_name<N>(name: N) -> crate::io::Result<Self>
+    fn from_abstract_name<N>(name: N) -> io::Result<Self>
     where
         N: AsRef<[u8]>,
     {

library/std/src/os/windows/io/handle.rs

@@ -185,7 +185,7 @@ impl OwnedHandle {
     /// Creates a new `OwnedHandle` instance that shares the same underlying
     /// object as the existing `OwnedHandle` instance.
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone(&self) -> crate::io::Result<Self> {
+    pub fn try_clone(&self) -> io::Result<Self> {
         self.as_handle().try_clone_to_owned()
     }
 }
@@ -194,7 +194,7 @@ impl BorrowedHandle<'_> {
     /// Creates a new `OwnedHandle` instance that shares the same underlying
     /// object as the existing `BorrowedHandle` instance.
     #[stable(feature = "io_safety", since = "1.63.0")]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedHandle> {
+    pub fn try_clone_to_owned(&self) -> io::Result<OwnedHandle> {
         self.duplicate(0, false, sys::c::DUPLICATE_SAME_ACCESS)
     }
 
@@ -410,7 +410,7 @@ macro_rules! impl_is_terminal {
         impl crate::sealed::Sealed for $t {}
 
         #[stable(feature = "is_terminal", since = "1.70.0")]
-        impl crate::io::IsTerminal for $t {
+        impl io::IsTerminal for $t {
             #[inline]
             fn is_terminal(&self) -> bool {
                 crate::sys::io::is_terminal(self)
@@ -547,47 +547,47 @@ impl From<OwnedHandle> for fs::File {
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl AsHandle for crate::io::Stdin {
+impl AsHandle for io::Stdin {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl<'a> AsHandle for crate::io::StdinLock<'a> {
+impl<'a> AsHandle for io::StdinLock<'a> {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl AsHandle for crate::io::Stdout {
+impl AsHandle for io::Stdout {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl<'a> AsHandle for crate::io::StdoutLock<'a> {
+impl<'a> AsHandle for io::StdoutLock<'a> {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl AsHandle for crate::io::Stderr {
+impl AsHandle for io::Stderr {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
-impl<'a> AsHandle for crate::io::StderrLock<'a> {
+impl<'a> AsHandle for io::StderrLock<'a> {
     #[inline]
     fn as_handle(&self) -> BorrowedHandle<'_> {
         unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }

library/std/src/sys/pal/hermit/mod.rs

@@ -16,7 +16,7 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(missing_docs, nonstandard_style)]
 
-use crate::io::ErrorKind;
+use crate::io;
 use crate::os::hermit::hermit_abi;
 use crate::os::raw::c_char;
 use crate::sys::env;
@@ -27,15 +27,12 @@ pub mod os;
 pub mod pipe;
 pub mod time;
 
-pub fn unsupported<T>() -> crate::io::Result<T> {
+pub fn unsupported<T>() -> io::Result<T> {
     Err(unsupported_err())
 }
 
-pub fn unsupported_err() -> crate::io::Error {
-    crate::io::const_error!(
-        crate::io::ErrorKind::Unsupported,
-        "operation not supported on HermitCore yet",
-    )
+pub fn unsupported_err() -> io::Error {
+    io::const_error!(io::ErrorKind::Unsupported, "operation not supported on HermitCore yet")
 }
 
 pub fn abort_internal() -> ! {
@@ -85,24 +82,24 @@ pub(crate) fn is_interrupted(errno: i32) -> bool {
     errno == hermit_abi::errno::EINTR
 }
 
-pub fn decode_error_kind(errno: i32) -> ErrorKind {
+pub fn decode_error_kind(errno: i32) -> io::ErrorKind {
     match errno {
-        hermit_abi::errno::EACCES => ErrorKind::PermissionDenied,
-        hermit_abi::errno::EADDRINUSE => ErrorKind::AddrInUse,
-        hermit_abi::errno::EADDRNOTAVAIL => ErrorKind::AddrNotAvailable,
-        hermit_abi::errno::EAGAIN => ErrorKind::WouldBlock,
-        hermit_abi::errno::ECONNABORTED => ErrorKind::ConnectionAborted,
-        hermit_abi::errno::ECONNREFUSED => ErrorKind::ConnectionRefused,
-        hermit_abi::errno::ECONNRESET => ErrorKind::ConnectionReset,
-        hermit_abi::errno::EEXIST => ErrorKind::AlreadyExists,
-        hermit_abi::errno::EINTR => ErrorKind::Interrupted,
-        hermit_abi::errno::EINVAL => ErrorKind::InvalidInput,
-        hermit_abi::errno::ENOENT => ErrorKind::NotFound,
-        hermit_abi::errno::ENOTCONN => ErrorKind::NotConnected,
-        hermit_abi::errno::EPERM => ErrorKind::PermissionDenied,
-        hermit_abi::errno::EPIPE => ErrorKind::BrokenPipe,
-        hermit_abi::errno::ETIMEDOUT => ErrorKind::TimedOut,
-        _ => ErrorKind::Uncategorized,
+        hermit_abi::errno::EACCES => io::ErrorKind::PermissionDenied,
+        hermit_abi::errno::EADDRINUSE => io::ErrorKind::AddrInUse,
+        hermit_abi::errno::EADDRNOTAVAIL => io::ErrorKind::AddrNotAvailable,
+        hermit_abi::errno::EAGAIN => io::ErrorKind::WouldBlock,
+        hermit_abi::errno::ECONNABORTED => io::ErrorKind::ConnectionAborted,
+        hermit_abi::errno::ECONNREFUSED => io::ErrorKind::ConnectionRefused,
+        hermit_abi::errno::ECONNRESET => io::ErrorKind::ConnectionReset,
+        hermit_abi::errno::EEXIST => io::ErrorKind::AlreadyExists,
+        hermit_abi::errno::EINTR => io::ErrorKind::Interrupted,
+        hermit_abi::errno::EINVAL => io::ErrorKind::InvalidInput,
+        hermit_abi::errno::ENOENT => io::ErrorKind::NotFound,
+        hermit_abi::errno::ENOTCONN => io::ErrorKind::NotConnected,
+        hermit_abi::errno::EPERM => io::ErrorKind::PermissionDenied,
+        hermit_abi::errno::EPIPE => io::ErrorKind::BrokenPipe,
+        hermit_abi::errno::ETIMEDOUT => io::ErrorKind::TimedOut,
+        _ => io::ErrorKind::Uncategorized,
     }
 }
 
@@ -135,16 +132,16 @@ impl IsNegative for i32 {
 }
 impl_is_negative! { i8 i16 i64 isize }
 
-pub fn cvt<T: IsNegative>(t: T) -> crate::io::Result<T> {
+pub fn cvt<T: IsNegative>(t: T) -> io::Result<T> {
     if t.is_negative() {
         let e = decode_error_kind(t.negate());
-        Err(crate::io::Error::from(e))
+        Err(io::Error::from(e))
     } else {
         Ok(t)
     }
 }
 
-pub fn cvt_r<T, F>(mut f: F) -> crate::io::Result<T>
+pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
 where
     T: IsNegative,
     F: FnMut() -> T,

library/std/src/sys/pal/sgx/mod.rs

@@ -5,7 +5,7 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(fuzzy_provenance_casts)] // FIXME: this entire module systematically confuses pointers and integers
 
-use crate::io::ErrorKind;
+use crate::io;
 use crate::sync::atomic::{Atomic, AtomicBool, Ordering};
 
 pub mod abi;
@@ -31,24 +31,24 @@ pub unsafe fn cleanup() {}
 
 /// This function is used to implement functionality that simply doesn't exist.
 /// Programs relying on this functionality will need to deal with the error.
-pub fn unsupported<T>() -> crate::io::Result<T> {
+pub fn unsupported<T>() -> io::Result<T> {
     Err(unsupported_err())
 }
 
-pub fn unsupported_err() -> crate::io::Error {
-    crate::io::const_error!(ErrorKind::Unsupported, "operation not supported on SGX yet")
+pub fn unsupported_err() -> io::Error {
+    io::const_error!(io::ErrorKind::Unsupported, "operation not supported on SGX yet")
 }
 
 /// This function is used to implement various functions that doesn't exist,
 /// but the lack of which might not be reason for error. If no error is
 /// returned, the program might very well be able to function normally. This is
 /// what happens when `SGX_INEFFECTIVE_ERROR` is set to `true`. If it is
 /// `false`, the behavior is the same as `unsupported`.
-pub fn sgx_ineffective<T>(v: T) -> crate::io::Result<T> {
+pub fn sgx_ineffective<T>(v: T) -> io::Result<T> {
     static SGX_INEFFECTIVE_ERROR: Atomic<bool> = AtomicBool::new(false);
     if SGX_INEFFECTIVE_ERROR.load(Ordering::Relaxed) {
-        Err(crate::io::const_error!(
-            ErrorKind::Uncategorized,
+        Err(io::const_error!(
+            io::ErrorKind::Uncategorized,
             "operation can't be trusted to have any effect on SGX",
         ))
     } else {
@@ -66,43 +66,43 @@ pub fn decode_error_kind(code: i32) -> ErrorKind {
 
     // FIXME: not sure how to make sure all variants of Error are covered
     if code == Error::NotFound as _ {
-        ErrorKind::NotFound
+        io::ErrorKind::NotFound
     } else if code == Error::PermissionDenied as _ {
-        ErrorKind::PermissionDenied
+        io::ErrorKind::PermissionDenied
     } else if code == Error::ConnectionRefused as _ {
-        ErrorKind::ConnectionRefused
+        io::ErrorKind::ConnectionRefused
     } else if code == Error::ConnectionReset as _ {
-        ErrorKind::ConnectionReset
+        io::ErrorKind::ConnectionReset
     } else if code == Error::ConnectionAborted as _ {
-        ErrorKind::ConnectionAborted
+        io::ErrorKind::ConnectionAborted
     } else if code == Error::NotConnected as _ {
-        ErrorKind::NotConnected
+        io::ErrorKind::NotConnected
     } else if code == Error::AddrInUse as _ {
-        ErrorKind::AddrInUse
+        io::ErrorKind::AddrInUse
     } else if code == Error::AddrNotAvailable as _ {
-        ErrorKind::AddrNotAvailable
+        io::ErrorKind::AddrNotAvailable
     } else if code == Error::BrokenPipe as _ {
-        ErrorKind::BrokenPipe
+        io::ErrorKind::BrokenPipe
     } else if code == Error::AlreadyExists as _ {
-        ErrorKind::AlreadyExists
+        io::ErrorKind::AlreadyExists
     } else if code == Error::WouldBlock as _ {
-        ErrorKind::WouldBlock
+        io::ErrorKind::WouldBlock
     } else if code == Error::InvalidInput as _ {
-        ErrorKind::InvalidInput
+        io::ErrorKind::InvalidInput
     } else if code == Error::InvalidData as _ {
-        ErrorKind::InvalidData
+        io::ErrorKind::InvalidData
     } else if code == Error::TimedOut as _ {
-        ErrorKind::TimedOut
+        io::ErrorKind::TimedOut
     } else if code == Error::WriteZero as _ {
-        ErrorKind::WriteZero
+        io::ErrorKind::WriteZero
     } else if code == Error::Interrupted as _ {
-        ErrorKind::Interrupted
+        io::ErrorKind::Interrupted
     } else if code == Error::Other as _ {
-        ErrorKind::Uncategorized
+        io::ErrorKind::Uncategorized
     } else if code == Error::UnexpectedEof as _ {
-        ErrorKind::UnexpectedEof
+        io::ErrorKind::UnexpectedEof
     } else {
-        ErrorKind::Uncategorized
+        io::ErrorKind::Uncategorized
     }
 }
 

library/std/src/sys/pal/solid/mod.rs

@@ -2,6 +2,8 @@
 #![allow(missing_docs, nonstandard_style)]
 #![forbid(unsafe_op_in_unsafe_fn)]
 
+use crate::io;
+
 pub mod abi;
 
 #[path = "../itron"]
@@ -30,20 +32,20 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {}
 // SAFETY: must be called only once during runtime cleanup.
 pub unsafe fn cleanup() {}
 
-pub fn unsupported<T>() -> crate::io::Result<T> {
+pub fn unsupported<T>() -> io::Result<T> {
     Err(unsupported_err())
 }
 
-pub fn unsupported_err() -> crate::io::Error {
-    crate::io::Error::UNSUPPORTED_PLATFORM
+pub fn unsupported_err() -> io::Error {
+    io::Error::UNSUPPORTED_PLATFORM
 }
 
 #[inline]
 pub fn is_interrupted(code: i32) -> bool {
     crate::sys::net::is_interrupted(code)
 }
 
-pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind {
+pub fn decode_error_kind(code: i32) -> io::ErrorKind {
     error::decode_error_kind(code)
 }