diff --git a/library/std/src/os/fd/owned.rs b/library/std/src/os/fd/owned.rs
index 6a0e7a640028b..406675fc543b5 100644
--- a/library/std/src/os/fd/owned.rs
+++ b/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)
diff --git a/library/std/src/os/solid/io.rs b/library/std/src/os/solid/io.rs
index c23d842b238b8..5f0c74a061976 100644
--- a/library/std/src/os/solid/io.rs
+++ b/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,7 +110,7 @@ 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()
     }
 }
@@ -118,7 +118,7 @@ impl OwnedFd {
 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)
diff --git a/library/std/src/os/unix/net/addr.rs b/library/std/src/os/unix/net/addr.rs
index 25b95014e08b2..0748f6984a825 100644
--- a/library/std/src/os/unix/net/addr.rs
+++ b/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]>,
     {
diff --git a/library/std/src/os/windows/io/handle.rs b/library/std/src/os/windows/io/handle.rs
index 4fc04b79315f9..fc26638afccd8 100644
--- a/library/std/src/os/windows/io/handle.rs
+++ b/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,7 +547,7 @@ 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()) }
@@ -555,7 +555,7 @@ impl AsHandle for crate::io::Stdin {
 }
 
 #[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()) }
@@ -563,7 +563,7 @@ impl<'a> AsHandle for crate::io::StdinLock<'a> {
 }
 
 #[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()) }
@@ -571,7 +571,7 @@ impl AsHandle for crate::io::Stdout {
 }
 
 #[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()) }
@@ -579,7 +579,7 @@ impl<'a> AsHandle for crate::io::StdoutLock<'a> {
 }
 
 #[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()) }
@@ -587,7 +587,7 @@ impl AsHandle for crate::io::Stderr {
 }
 
 #[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()) }
diff --git a/library/std/src/sys/pal/hermit/mod.rs b/library/std/src/sys/pal/hermit/mod.rs
index 3ddf6e5acb02e..867558c199130 100644
--- a/library/std/src/sys/pal/hermit/mod.rs
+++ b/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,
diff --git a/library/std/src/sys/pal/sgx/mod.rs b/library/std/src/sys/pal/sgx/mod.rs
index 9a33873af581f..c349e72a1ea19 100644
--- a/library/std/src/sys/pal/sgx/mod.rs
+++ b/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,12 +31,12 @@ 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,
@@ -44,11 +44,11 @@ pub fn unsupported_err() -> crate::io::Error {
 /// 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
     }
 }
 
diff --git a/library/std/src/sys/pal/solid/mod.rs b/library/std/src/sys/pal/solid/mod.rs
index 9ca6dc581183d..c3c8e61075746 100644
--- a/library/std/src/sys/pal/solid/mod.rs
+++ b/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,12 +32,12 @@ 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]
@@ -43,7 +45,7 @@ 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)
 }
 
diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index dd0155265da63..0fbe53555eabf 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -21,7 +21,7 @@ pub mod sync {
     pub use mutex::Mutex;
 }
 
-use crate::io::ErrorKind;
+use crate::io;
 
 pub fn abort_internal() -> ! {
     unsafe { libc::abort() }
@@ -46,8 +46,8 @@ pub(crate) fn is_interrupted(errno: i32) -> bool {
 }
 
 // Note: code below is 1:1 copied from unix/mod.rs
-pub fn decode_error_kind(errno: i32) -> ErrorKind {
-    use ErrorKind::*;
+pub fn decode_error_kind(errno: i32) -> io::ErrorKind {
+    use io::ErrorKind::*;
     match errno as libc::c_int {
         libc::E2BIG => ArgumentListTooLong,
         libc::EADDRINUSE => AddrInUse,
@@ -110,32 +110,31 @@ macro_rules! impl_is_minus_one {
 
 impl_is_minus_one! { i8 i16 i32 i64 isize }
 
-pub fn cvt<T: IsMinusOne>(t: T) -> crate::io::Result<T> {
-    if t.is_minus_one() { Err(crate::io::Error::last_os_error()) } else { Ok(t) }
+pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
+    if t.is_minus_one() { Err(io::Error::last_os_error()) } 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: IsMinusOne,
     F: FnMut() -> T,
 {
     loop {
         match cvt(f()) {
-            Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
+            Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
             other => return other,
         }
     }
 }
 
-pub fn cvt_nz(error: libc::c_int) -> crate::io::Result<()> {
-    if error == 0 { Ok(()) } else { Err(crate::io::Error::from_raw_os_error(error)) }
+pub fn cvt_nz(error: libc::c_int) -> io::Result<()> {
+    if error == 0 { Ok(()) } else { Err(io::Error::from_raw_os_error(error)) }
 }
 
-use crate::io as std_io;
-pub fn unsupported<T>() -> std_io::Result<T> {
+pub fn unsupported<T>() -> io::Result<T> {
     Err(unsupported_err())
 }
 
-pub fn unsupported_err() -> std_io::Error {
-    std_io::Error::UNSUPPORTED_PLATFORM
+pub fn unsupported_err() -> io::Error {
+    io::Error::UNSUPPORTED_PLATFORM
 }
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index 81533d593131b..287632abd5648 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -1,6 +1,6 @@
 #![allow(missing_docs, nonstandard_style)]
 
-use crate::io::ErrorKind;
+use crate::io;
 
 #[cfg(target_os = "fuchsia")]
 pub mod fuchsia;
@@ -230,8 +230,8 @@ pub(crate) fn is_interrupted(errno: i32) -> bool {
     errno == libc::EINTR
 }
 
-pub fn decode_error_kind(errno: i32) -> ErrorKind {
-    use ErrorKind::*;
+pub fn decode_error_kind(errno: i32) -> io::ErrorKind {
+    use io::ErrorKind::*;
     match errno as libc::c_int {
         libc::E2BIG => ArgumentListTooLong,
         libc::EADDRINUSE => AddrInUse,
@@ -299,12 +299,12 @@ impl_is_minus_one! { i8 i16 i32 i64 isize }
 
 /// Converts native return values to Result using the *-1 means error is in `errno`*  convention.
 /// Non-error values are `Ok`-wrapped.
-pub fn cvt<T: IsMinusOne>(t: T) -> crate::io::Result<T> {
-    if t.is_minus_one() { Err(crate::io::Error::last_os_error()) } else { Ok(t) }
+pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
+    if t.is_minus_one() { Err(io::Error::last_os_error()) } else { Ok(t) }
 }
 
 /// `-1` → look at `errno` → retry on `EINTR`. Otherwise `Ok()`-wrap the closure return value.
-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: IsMinusOne,
     F: FnMut() -> T,
@@ -319,8 +319,8 @@ where
 
 #[allow(dead_code)] // Not used on all platforms.
 /// Zero means `Ok()`, all other values are treated as raw OS errors. Does not look at `errno`.
-pub fn cvt_nz(error: libc::c_int) -> crate::io::Result<()> {
-    if error == 0 { Ok(()) } else { Err(crate::io::Error::from_raw_os_error(error)) }
+pub fn cvt_nz(error: libc::c_int) -> io::Result<()> {
+    if error == 0 { Ok(()) } else { Err(io::Error::from_raw_os_error(error)) }
 }
 
 // libc::abort() will run the SIGABRT handler.  That's fine because anyone who
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasi/os.rs
index 367c63dfc59e7..a3bb329c2c4f9 100644
--- a/library/std/src/sys/pal/wasi/os.rs
+++ b/library/std/src/sys/pal/wasi/os.rs
@@ -157,7 +157,7 @@ pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
     if t.is_minus_one() { Err(io::Error::last_os_error()) } 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: IsMinusOne,
     F: FnMut() -> T,
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index a5f060080130f..d8c70b7af9469 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -2,7 +2,7 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
 use crate::ffi::{OsStr, OsString};
-use crate::io::ErrorKind;
+use crate::io;
 use crate::mem::MaybeUninit;
 use crate::os::windows::ffi::{OsStrExt, OsStringExt};
 use crate::path::PathBuf;
@@ -33,13 +33,13 @@ cfg_select! {
 }
 pub mod winsock;
 
-/// Map a [`Result<T, WinError>`] to [`io::Result<T>`](crate::io::Result<T>).
+/// Map a [`Result<T, WinError>`] to [`io::Result<T>`].
 pub trait IoResult<T> {
-    fn io_result(self) -> crate::io::Result<T>;
+    fn io_result(self) -> io::Result<T>;
 }
 impl<T> IoResult<T> for Result<T, api::WinError> {
-    fn io_result(self) -> crate::io::Result<T> {
-        self.map_err(|e| crate::io::Error::from_raw_os_error(e.code as i32))
+    fn io_result(self) -> io::Result<T> {
+        self.map_err(|e| io::Error::from_raw_os_error(e.code as i32))
     }
 }
 
@@ -66,8 +66,8 @@ pub fn is_interrupted(_errno: i32) -> bool {
     false
 }
 
-pub fn decode_error_kind(errno: i32) -> ErrorKind {
-    use ErrorKind::*;
+pub fn decode_error_kind(errno: i32) -> io::ErrorKind {
+    use io::ErrorKind::*;
 
     match errno as u32 {
         c::ERROR_ACCESS_DENIED => return PermissionDenied,
@@ -168,8 +168,8 @@ pub fn unrolled_find_u16s(needle: u16, haystack: &[u16]) -> Option<usize> {
     None
 }
 
-pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> crate::io::Result<Vec<u16>> {
-    fn inner(s: &OsStr) -> crate::io::Result<Vec<u16>> {
+pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> io::Result<Vec<u16>> {
+    fn inner(s: &OsStr) -> io::Result<Vec<u16>> {
         // Most paths are ASCII, so reserve capacity for as much as there are bytes
         // in the OsStr plus one for the null-terminating character. We are not
         // wasting bytes here as paths created by this function are primarily used
@@ -178,8 +178,8 @@ pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> crate::io::Result<Vec<u16>> {
         maybe_result.extend(s.encode_wide());
 
         if unrolled_find_u16s(0, &maybe_result).is_some() {
-            return Err(crate::io::const_error!(
-                ErrorKind::InvalidInput,
+            return Err(io::const_error!(
+                io::ErrorKind::InvalidInput,
                 "strings passed to WinAPI cannot contain NULs",
             ));
         }
@@ -210,7 +210,7 @@ pub fn to_u16s<S: AsRef<OsStr>>(s: S) -> crate::io::Result<Vec<u16>> {
 // Once the syscall has completed (errors bail out early) the second closure is
 // passed the data which has been read from the syscall. The return value
 // from this closure is then the return value of the function.
-pub fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> crate::io::Result<T>
+pub fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> io::Result<T>
 where
     F1: FnMut(*mut u16, u32) -> u32,
     F2: FnOnce(&[u16]) -> T,
@@ -252,7 +252,7 @@ where
             c::SetLastError(0);
             let k = match f1(buf.as_mut_ptr().cast::<u16>(), n as u32) {
                 0 if api::get_last_error().code == 0 => 0,
-                0 => return Err(crate::io::Error::last_os_error()),
+                0 => return Err(io::Error::last_os_error()),
                 n => n,
             } as usize;
             if k == n && api::get_last_error().code == c::ERROR_INSUFFICIENT_BUFFER {
@@ -286,9 +286,9 @@ pub fn truncate_utf16_at_nul(v: &[u16]) -> &[u16] {
     }
 }
 
-pub fn ensure_no_nuls<T: AsRef<OsStr>>(s: T) -> crate::io::Result<T> {
+pub fn ensure_no_nuls<T: AsRef<OsStr>>(s: T) -> io::Result<T> {
     if s.as_ref().encode_wide().any(|b| b == 0) {
-        Err(crate::io::const_error!(ErrorKind::InvalidInput, "nul byte found in provided data"))
+        Err(io::const_error!(io::ErrorKind::InvalidInput, "nul byte found in provided data"))
     } else {
         Ok(s)
     }
@@ -308,8 +308,8 @@ macro_rules! impl_is_zero {
 
 impl_is_zero! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }
 
-pub fn cvt<I: IsZero>(i: I) -> crate::io::Result<I> {
-    if i.is_zero() { Err(crate::io::Error::last_os_error()) } else { Ok(i) }
+pub fn cvt<I: IsZero>(i: I) -> io::Result<I> {
+    if i.is_zero() { Err(io::Error::last_os_error()) } else { Ok(i) }
 }
 
 pub fn dur2timeout(dur: Duration) -> u32 {
diff --git a/library/std/src/thread/builder.rs b/library/std/src/thread/builder.rs
index f4abe074ab9d7..baec8c905d802 100644
--- a/library/std/src/thread/builder.rs
+++ b/library/std/src/thread/builder.rs
@@ -40,7 +40,6 @@ use crate::io;
 /// [`name`]: Builder::name
 /// [`spawn`]: Builder::spawn
 /// [`thread::spawn`]: super::spawn
-/// [`io::Result`]: crate::io::Result
 /// [`unwrap`]: crate::result::Result::unwrap
 /// [naming-threads]: ./index.html#naming-threads
 /// [stack-size]: ./index.html#stack-size
@@ -161,8 +160,6 @@ impl Builder {
     /// [`io::Result`] to capture any failure to create the thread at
     /// the OS level.
     ///
-    /// [`io::Result`]: crate::io::Result
-    ///
     /// # Panics
     ///
     /// Panics if a thread name was set and it contained null bytes.
@@ -250,7 +247,6 @@ impl Builder {
     /// handler.join().unwrap();
     /// ```
     ///
-    /// [`io::Result`]: crate::io::Result
     /// [`thread::spawn`]: super::spawn
     /// [`spawn`]: super::spawn
     #[stable(feature = "thread_spawn_unchecked", since = "1.82.0")]
diff --git a/library/std/src/thread/scoped.rs b/library/std/src/thread/scoped.rs
index 301f5e949cac3..3ac9956336d7b 100644
--- a/library/std/src/thread/scoped.rs
+++ b/library/std/src/thread/scoped.rs
@@ -210,8 +210,6 @@ impl Builder {
     /// Unlike [`Scope::spawn`], this method yields an [`io::Result`] to
     /// capture any failure to create the thread at the OS level.
     ///
-    /// [`io::Result`]: crate::io::Result
-    ///
     /// # Panics
     ///
     /// Panics if a thread name was set and it contained null bytes.