Move trait impls for Pipe{Reader,Writer} to std::io::pipe

Also get rid of the now mostly-empty `std::sys::anonymous_pipe` module.
It basically just unwrapped the `AnonPipe` abstraction from
`std::sys::pipe`.

Author: tbu-

library/std/src/io/pipe.rs

@@ -1,5 +1,6 @@
 use crate::io;
-use crate::sys::anonymous_pipe::{AnonPipe, pipe as pipe_inner};
+use crate::sys::pipe::{AnonPipe, anon_pipe};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 
 /// Create an anonymous pipe.
 ///
@@ -66,18 +67,23 @@ use crate::sys::anonymous_pipe::{AnonPipe, pipe as pipe_inner};
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 #[inline]
 pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
-    pipe_inner().map(|(reader, writer)| (PipeReader(reader), PipeWriter(writer)))
+    anon_pipe()
+        .map(|(reader, writer)| (PipeReader::from_inner(reader), PipeWriter::from_inner(writer)))
 }
 
 /// Read end of an anonymous pipe.
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 #[derive(Debug)]
-pub struct PipeReader(pub(crate) AnonPipe);
+pub struct PipeReader {
+    inner: AnonPipe,
+}
 
 /// Write end of an anonymous pipe.
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 #[derive(Debug)]
-pub struct PipeWriter(pub(crate) AnonPipe);
+pub struct PipeWriter {
+    inner: AnonPipe,
+}
 
 impl PipeReader {
     /// Create a new [`PipeReader`] instance that shares the same underlying file description.
@@ -131,7 +137,7 @@ impl PipeReader {
     /// ```
     #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
     pub fn try_clone(&self) -> io::Result<Self> {
-        self.0.try_clone().map(Self)
+        self.as_inner().try_clone().map(Self::from_inner)
     }
 }
 
@@ -167,82 +173,116 @@ impl PipeWriter {
     /// ```
     #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
     pub fn try_clone(&self) -> io::Result<Self> {
-        self.0.try_clone().map(Self)
+        self.as_inner().try_clone().map(Self::from_inner)
+    }
+}
+
+impl AsInner<AnonPipe> for PipeReader {
+    #[inline]
+    fn as_inner(&self) -> &AnonPipe {
+        &self.inner
+    }
+}
+impl FromInner<AnonPipe> for PipeReader {
+    fn from_inner(pipe: AnonPipe) -> PipeReader {
+        PipeReader { inner: pipe }
+    }
+}
+impl IntoInner<AnonPipe> for PipeReader {
+    fn into_inner(self) -> AnonPipe {
+        self.inner
+    }
+}
+
+impl AsInner<AnonPipe> for PipeWriter {
+    #[inline]
+    fn as_inner(&self) -> &AnonPipe {
+        &self.inner
+    }
+}
+impl FromInner<AnonPipe> for PipeWriter {
+    fn from_inner(pipe: AnonPipe) -> PipeWriter {
+        PipeWriter { inner: pipe }
+    }
+}
+impl IntoInner<AnonPipe> for PipeWriter {
+    fn into_inner(self) -> AnonPipe {
+        self.inner
     }
 }
 
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 impl io::Read for &PipeReader {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.read(buf)
+        self.as_inner().read(buf)
     }
     fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0.read_vectored(bufs)
+        self.as_inner().read_vectored(bufs)
     }
     #[inline]
     fn is_read_vectored(&self) -> bool {
-        self.0.is_read_vectored()
+        self.as_inner().is_read_vectored()
     }
     fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        self.0.read_to_end(buf)
+        self.as_inner().read_to_end(buf)
     }
     fn read_buf(&mut self, buf: io::BorrowedCursor<'_>) -> io::Result<()> {
-        self.0.read_buf(buf)
+        self.as_inner().read_buf(buf)
     }
 }
 
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 impl io::Read for PipeReader {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.read(buf)
+        self.as_inner().read(buf)
     }
     fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> {
-        self.0.read_vectored(bufs)
+        self.as_inner().read_vectored(bufs)
     }
     #[inline]
     fn is_read_vectored(&self) -> bool {
-        self.0.is_read_vectored()
+        self.as_inner().is_read_vectored()
     }
     fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        self.0.read_to_end(buf)
+        self.as_inner().read_to_end(buf)
     }
     fn read_buf(&mut self, buf: io::BorrowedCursor<'_>) -> io::Result<()> {
-        self.0.read_buf(buf)
+        self.as_inner().read_buf(buf)
     }
 }
 
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 impl io::Write for &PipeWriter {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.write(buf)
+        self.as_inner().write(buf)
     }
     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
     fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
-        self.0.write_vectored(bufs)
+        self.as_inner().write_vectored(bufs)
     }
     #[inline]
     fn is_write_vectored(&self) -> bool {
-        self.0.is_write_vectored()
+        self.as_inner().is_write_vectored()
     }
 }
 
 #[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
 impl io::Write for PipeWriter {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.write(buf)
+        self.as_inner().write(buf)
     }
     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
     }
     fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
-        self.0.write_vectored(bufs)
+        self.as_inner().write_vectored(bufs)
     }
     #[inline]
     fn is_write_vectored(&self) -> bool {
-        self.0.is_write_vectored()
+        self.as_inner().is_write_vectored()
     }
 }

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

@@ -310,6 +310,44 @@ impl From<OwnedFd> for fs::File {
     }
 }
 
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsFd for io::PipeReader {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.as_inner().as_fd()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<io::PipeReader> for OwnedFd {
+    fn from(pipe: io::PipeReader) -> OwnedFd {
+        pipe.into_inner().into_inner().into_inner()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<OwnedFd> for io::PipeReader {
+    fn from(owned_fd: OwnedFd) -> io::PipeReader {
+        Self::from_inner(FromInner::from_inner(FromInner::from_inner(owned_fd)))
+    }
+}
+
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsFd for io::PipeWriter {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.as_inner().as_fd()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<io::PipeWriter> for OwnedFd {
+    fn from(pipe: io::PipeWriter) -> OwnedFd {
+        pipe.into_inner().into_inner().into_inner()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<OwnedFd> for io::PipeWriter {
+    fn from(owned_fd: OwnedFd) -> io::PipeWriter {
+        Self::from_inner(FromInner::from_inner(FromInner::from_inner(owned_fd)))
+    }
+}
+
 #[stable(feature = "io_safety", since = "1.63.0")]
 impl AsFd for crate::net::TcpStream {
     #[inline]

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

@@ -15,7 +15,7 @@ use crate::os::unix::io::AsFd;
 use crate::os::unix::io::OwnedFd;
 #[cfg(target_os = "wasi")]
 use crate::os::wasi::io::OwnedFd;
-use crate::sys_common::{AsInner, IntoInner};
+use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::{fs, io};
 
 /// Raw file descriptors.
@@ -182,6 +182,43 @@ impl IntoRawFd for fs::File {
     }
 }
 
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsRawFd for io::PipeReader {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().as_raw_fd()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl FromRawFd for io::PipeReader {
+    unsafe fn from_raw_fd(raw_fd: RawFd) -> io::PipeReader {
+        unsafe { io::PipeReader::from_inner(FromRawFd::from_raw_fd(raw_fd)) }
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl IntoRawFd for io::PipeReader {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().into_raw_fd()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsRawFd for io::PipeWriter {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_inner().as_raw_fd()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl FromRawFd for io::PipeWriter {
+    unsafe fn from_raw_fd(raw_fd: RawFd) -> io::PipeWriter {
+        unsafe { io::PipeWriter::from_inner(FromRawFd::from_raw_fd(raw_fd)) }
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl IntoRawFd for io::PipeWriter {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_inner().into_raw_fd()
+    }
+}
+
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawFd for io::Stdin {
     #[inline]

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)
@@ -546,48 +546,86 @@ impl From<OwnedHandle> for fs::File {
     }
 }
 
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsHandle for io::PipeReader {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        self.as_inner().as_handle()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<io::PipeReader> for OwnedHandle {
+    fn from(pipe: io::PipeReader) -> OwnedHandle {
+        pipe.into_inner().into_inner().into_inner()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<OwnedHandle> for io::PipeReader {
+    fn from(owned: OwnedHandle) -> io::PipeReader {
+        io::PipeReader::from_inner(FromInner::from_inner(FromInner::from_inner(owned)))
+    }
+}
+
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl AsHandle for io::PipeWriter {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        self.as_inner().as_handle()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<io::PipeWriter> for OwnedHandle {
+    fn from(pipe: io::PipeWriter) -> OwnedHandle {
+        pipe.into_inner().into_inner().into_inner()
+    }
+}
+#[stable(feature = "anonymous_pipe", since = "CURRENT_RUSTC_VERSION")]
+impl From<OwnedHandle> for io::PipeWriter {
+    fn from(owned: OwnedHandle) -> io::PipeWriter {
+        io::PipeWriter::from_inner(FromInner::from_inner(FromInner::from_inner(owned)))
+    }
+}
+
 #[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()) }