Replace TryFrom<Owned*> with From

NobodyXu · NobodyXu · commit 4547b30b4a27 · 2024-07-11T00:08:34.000+10:00
Signed-off-by: Jiahao XU &lt;Jiahao_XU@outlook.com&gt;
diff --git a/library/std/src/sys/anonymous_pipe/tests.rs b/library/std/src/sys/anonymous_pipe/tests.rs
@@ -27,102 +27,3 @@ fn pipe_try_clone_and_rw() {
     rx.read_to_string(&mut s).unwrap();
     assert_eq!(s, "45");
 }
-
-#[cfg(unix)]
-mod unix_specific {
-    use super::*;
-
-    use crate::{
-        fs::File,
-        io,
-        os::fd::{AsRawFd, OwnedFd},
-    };
-
-    #[test]
-    fn pipe_owned_fd_round_trip_conversion() {
-        let (rx, tx) = pipe().unwrap();
-        let raw_fds = (rx.as_raw_fd(), tx.as_raw_fd());
-        let (rx_owned_fd, tx_owned_fd) = (OwnedFd::from(rx), OwnedFd::from(tx));
-
-        let rx = PipeReader::try_from(rx_owned_fd).unwrap();
-        let tx = PipeWriter::try_from(tx_owned_fd).unwrap();
-        assert_eq!(raw_fds, (rx.as_raw_fd(), tx.as_raw_fd()));
-    }
-
-    #[test]
-    fn convert_from_non_pipe_to_pipe_reader_shall_fail() {
-        let file = File::open("/dev/zero").unwrap();
-        let err = PipeReader::try_from(OwnedFd::from(file)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), "Not a pipe");
-    }
-
-    #[test]
-    fn convert_from_non_pipe_to_pipe_writer_shall_fail() {
-        let file = File::options().write(true).open("/dev/null").unwrap();
-        let err = PipeWriter::try_from(OwnedFd::from(file)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), "Not a pipe");
-    }
-
-    #[test]
-    fn convert_pipe_writer_to_pipe_reader_shall_fail() {
-        let (_, tx) = pipe().unwrap();
-        let fd = tx.as_raw_fd();
-        let err = PipeReader::try_from(OwnedFd::from(tx)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), format!("Pipe {fd} is not readable"));
-    }
-
-    #[test]
-    fn convert_pipe_reader_to_pipe_writer_shall_fail() {
-        let (rx, _) = pipe().unwrap();
-        let fd = rx.as_raw_fd();
-        let err = PipeWriter::try_from(OwnedFd::from(rx)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), format!("Pipe {fd} is not writable"));
-    }
-}
-
-#[cfg(windows)]
-mod windows_specific {
-    use super::*;
-
-    use crate::{
-        io,
-        os::windows::io::{AsHandle, AsRawHandle, OwnedHandle},
-    };
-
-    #[test]
-    fn pipe_owned_handle_round_trip_conversion() {
-        let (rx, tx) = pipe().unwrap();
-        let raw_handles = (rx.as_raw_handle(), tx.as_raw_handle());
-        let (rx_owned_handle, tx_owned_handle) = (OwnedHandle::from(rx), OwnedHandle::from(tx));
-
-        let rx = PipeReader::try_from(rx_owned_handle).unwrap();
-        let tx = PipeWriter::try_from(tx_owned_handle).unwrap();
-        assert_eq!(raw_handles, (rx.as_raw_handle(), tx.as_raw_handle()));
-    }
-
-    #[test]
-    fn convert_from_non_pipe_to_pipe_reader_shall_fail() {
-        let file = io::stdin().as_handle().try_clone_to_owned().unwrap();
-        let err = PipeReader::try_from(OwnedHandle::from(file)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), "Not a pipe");
-    }
-
-    #[test]
-    fn convert_from_non_pipe_to_pipe_writer_shall_fail() {
-        let file = io::stdout().as_handle().try_clone_to_owned().unwrap();
-        let err = PipeWriter::try_from(OwnedHandle::from(file)).unwrap_err();
-
-        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
-        assert_eq!(format!("{}", err.get_ref().unwrap()), "Not a pipe");
-    }
-}
diff --git a/library/std/src/sys/anonymous_pipe/unix.rs b/library/std/src/sys/anonymous_pipe/unix.rs
@@ -1,11 +1,7 @@
 use super::*;
 
 use crate::{
-    fs::File,
-    os::{
-        fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
-        unix::fs::FileTypeExt,
-    },
+    os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
     sys::{
         fd::FileDesc,
         pipe::{anon_pipe, AnonPipe},
@@ -92,51 +88,20 @@ impl From<PipeWriter> for Stdio {
     }
 }
 
-fn convert_to_pipe(owned_fd: OwnedFd) -> io::Result<AnonPipe> {
-    let file = File::from(owned_fd);
-    if file.metadata()?.file_type().is_fifo() {
-        Ok(AnonPipe::from_inner(FileDesc::from_inner(OwnedFd::from(file))))
-    } else {
-        Err(io::Error::new(io::ErrorKind::InvalidInput, "Not a pipe"))
-    }
+fn convert_to_pipe(owned_fd: OwnedFd) -> AnonPipe {
+    AnonPipe::from_inner(FileDesc::from_inner(OwnedFd::from(owned_fd)))
 }
 
 #[unstable(feature = "anonymous_pipe", issue = "127154")]
-impl TryFrom<OwnedFd> for PipeReader {
-    type Error = io::Error;
-
-    fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
-        convert_to_pipe(owned_fd)
-            .and_then(|pipe| {
-                if pipe.as_file_desc().get_access_mode()?.is_readable() {
-                    Ok(pipe)
-                } else {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Pipe {} is not readable", pipe.as_raw_fd()),
-                    ))
-                }
-            })
-            .map(Self)
+impl From<OwnedFd> for PipeReader {
+    fn from(owned_fd: OwnedFd) -> Self {
+        Self(convert_to_pipe(owned_fd))
     }
 }
 
 #[unstable(feature = "anonymous_pipe", issue = "127154")]
-impl TryFrom<OwnedFd> for PipeWriter {
-    type Error = io::Error;
-
-    fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
-        convert_to_pipe(owned_fd)
-            .and_then(|pipe| {
-                if pipe.as_file_desc().get_access_mode()?.is_writable() {
-                    Ok(pipe)
-                } else {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("Pipe {} is not writable", pipe.as_raw_fd()),
-                    ))
-                }
-            })
-            .map(Self)
+impl From<OwnedFd> for PipeWriter {
+    fn from(owned_fd: OwnedFd) -> Self {
+        Self(convert_to_pipe(owned_fd))
     }
 }
diff --git a/library/std/src/sys/anonymous_pipe/windows.rs b/library/std/src/sys/anonymous_pipe/windows.rs
@@ -5,7 +5,6 @@ use crate::{
         AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, IntoRawHandle, OwnedHandle, RawHandle,
     },
     sys::{
-        c::{GetFileType, FILE_TYPE_PIPE},
         handle::Handle,
         pipe::{anon_pipe, AnonPipe, Pipes},
     },
@@ -95,28 +94,20 @@ impl From<PipeWriter> for Stdio {
     }
 }
 
-fn convert_to_pipe(owned_handle: OwnedHandle) -> io::Result<AnonPipe> {
-    if unsafe { GetFileType(owned_handle.as_raw_handle()) } == FILE_TYPE_PIPE {
-        Ok(AnonPipe::from_inner(Handle::from_inner(owned_handle)))
-    } else {
-        Err(io::Error::new(io::ErrorKind::InvalidInput, "Not a pipe"))
-    }
+fn convert_to_pipe(owned_handle: OwnedHandle) -> AnonPipe {
+    AnonPipe::from_inner(Handle::from_inner(owned_handle))
 }
 
 #[unstable(feature = "anonymous_pipe", issue = "127154")]
-impl TryFrom<OwnedHandle> for PipeReader {
-    type Error = io::Error;
-
-    fn try_from(owned_handle: OwnedHandle) -> Result<Self, Self::Error> {
-        convert_to_pipe(owned_handle).map(Self)
+impl From<OwnedHandle> for PipeReader {
+    fn from(owned_handle: OwnedHandle) -> Self {
+        Self(convert_to_pipe(owned_handle))
     }
 }
 
 #[unstable(feature = "anonymous_pipe", issue = "127154")]
-impl TryFrom<OwnedHandle> for PipeWriter {
-    type Error = io::Error;
-
-    fn try_from(owned_handle: OwnedHandle) -> Result<Self, Self::Error> {
-        convert_to_pipe(owned_handle).map(Self)
+impl From<OwnedHandle> for PipeWriter {
+    fn from(owned_handle: OwnedHandle) -> Self {
+        Self(convert_to_pipe(owned_handle))
     }
 }
diff --git a/library/std/src/sys/pal/unix/fd.rs b/library/std/src/sys/pal/unix/fd.rs
@@ -26,24 +26,6 @@ use libc::off64_t;
 )))]
 use libc::off_t as off64_t;
 
-#[derive(Copy, Clone)]
-pub enum AccessMode {
-    ReadOnly,
-    WriteOnly,
-    ReadWrite,
-    None,
-}
-
-impl AccessMode {
-    pub fn is_readable(self) -> bool {
-        matches!(self, AccessMode::ReadOnly | AccessMode::ReadWrite)
-    }
-
-    pub fn is_writable(self) -> bool {
-        matches!(self, AccessMode::WriteOnly | AccessMode::ReadWrite)
-    }
-}
-
 #[derive(Debug)]
 pub struct FileDesc(OwnedFd);
 
@@ -536,30 +518,20 @@ impl FileDesc {
         }
     }
 
-    fn get_flags(&self) -> io::Result<libc::c_int> {
-        unsafe { cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFL)) }
-    }
-
-    pub fn get_access_mode(&self) -> io::Result<AccessMode> {
-        let access_mode = self.get_flags()? & libc::O_ACCMODE;
-        Ok(match access_mode {
-            libc::O_RDWR => AccessMode::ReadWrite,
-            libc::O_RDONLY => AccessMode::ReadOnly,
-            libc::O_WRONLY => AccessMode::WriteOnly,
-
-            _ => AccessMode::None,
-        })
-    }
-
     #[cfg(not(target_os = "linux"))]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
-        let previous = self.get_flags()?;
-        let new =
-            if nonblocking { previous | libc::O_NONBLOCK } else { previous & !libc::O_NONBLOCK };
-        if new != previous {
-            unsafe { cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFL, new)) }?;
+        unsafe {
+            let previous = cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFL))?;
+            let new = if nonblocking {
+                previous | libc::O_NONBLOCK
+            } else {
+                previous & !libc::O_NONBLOCK
+            };
+            if new != previous {
+                cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFL, new))?;
+            }
+            Ok(())
         }
-        Ok(())
     }
 
     #[inline]
