Use std::os::fd instead of std::os::unix::io

tokio-util/src/compat.rs

@@ -366,8 +366,8 @@ impl<T: futures_io::AsyncSeek> tokio::io::AsyncSeek for Compat<T> {
 }
 
 #[cfg(unix)]
-impl<T: std::os::unix::io::AsRawFd> std::os::unix::io::AsRawFd for Compat<T> {
-    fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
+impl<T: std::os::fd::AsRawFd> std::os::fd::AsRawFd for Compat<T> {
+    fn as_raw_fd(&self) -> std::os::fd::RawFd {
         self.inner.as_raw_fd()
     }
 }

tokio/src/fs/file.rs

@@ -899,24 +899,22 @@ impl fmt::Debug for File {
 }
 
 #[cfg(unix)]
-impl std::os::unix::io::AsRawFd for File {
-    fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
+impl std::os::fd::AsRawFd for File {
+    fn as_raw_fd(&self) -> std::os::fd::RawFd {
         self.std.as_raw_fd()
     }
 }
 
 #[cfg(unix)]
-impl std::os::unix::io::AsFd for File {
-    fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> {
-        unsafe {
-            std::os::unix::io::BorrowedFd::borrow_raw(std::os::unix::io::AsRawFd::as_raw_fd(self))
-        }
+impl std::os::fd::AsFd for File {
+    fn as_fd(&self) -> std::os::fd::BorrowedFd<'_> {
+        unsafe { std::os::fd::BorrowedFd::borrow_raw(std::os::fd::AsRawFd::as_raw_fd(self)) }
     }
 }
 
 #[cfg(unix)]
-impl std::os::unix::io::FromRawFd for File {
-    unsafe fn from_raw_fd(fd: std::os::unix::io::RawFd) -> Self {
+impl std::os::fd::FromRawFd for File {
+    unsafe fn from_raw_fd(fd: std::os::fd::RawFd) -> Self {
         StdFile::from_raw_fd(fd).into()
     }
 }

tokio/src/fs/mocks.rs

@@ -44,13 +44,13 @@ mock! {
         unsafe fn from_raw_handle(h: std::os::windows::io::RawHandle) -> Self;
     }
     #[cfg(unix)]
-    impl std::os::unix::io::AsRawFd for File {
-        fn as_raw_fd(&self) -> std::os::unix::io::RawFd;
+    impl std::os::fd::AsRawFd for File {
+        fn as_raw_fd(&self) -> std::os::fd::RawFd;
     }
 
     #[cfg(unix)]
-    impl std::os::unix::io::FromRawFd for File {
-        unsafe fn from_raw_fd(h: std::os::unix::io::RawFd) -> Self;
+    impl std::os::fd::FromRawFd for File {
+        unsafe fn from_raw_fd(h: std::os::fd::RawFd) -> Self;
     }
 }
 

tokio/src/io/async_fd.rs

@@ -6,7 +6,7 @@ use mio::unix::SourceFd;
 use std::error::Error;
 use std::fmt;
 use std::io;
-use std::os::unix::io::{AsRawFd, RawFd};
+use std::os::fd::{AsRawFd, RawFd};
 use std::task::{ready, Context, Poll};
 
 /// Associates an IO object backed by a Unix file descriptor with the tokio
@@ -930,9 +930,9 @@ impl<T: AsRawFd> AsRawFd for AsyncFd<T> {
     }
 }
 
-impl<T: AsRawFd> std::os::unix::io::AsFd for AsyncFd<T> {
-    fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> {
-        unsafe { std::os::unix::io::BorrowedFd::borrow_raw(self.as_raw_fd()) }
+impl<T: AsRawFd> std::os::fd::AsFd for AsyncFd<T> {
+    fn as_fd(&self) -> std::os::fd::BorrowedFd<'_> {
+        unsafe { std::os::fd::BorrowedFd::borrow_raw(self.as_raw_fd()) }
     }
 }
 

tokio/src/io/bsd/poll_aio.rs

@@ -9,7 +9,7 @@ use mio::Token;
 use std::fmt;
 use std::io;
 use std::ops::{Deref, DerefMut};
-use std::os::unix::io::AsRawFd;
+use std::os::fd::AsRawFd;
 use std::os::unix::prelude::RawFd;
 use std::task::{ready, Context, Poll};
 

tokio/src/io/stderr.rs

@@ -79,7 +79,7 @@ cfg_io_std! {
 
 #[cfg(unix)]
 mod sys {
-    use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+    use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};
 
     use super::Stderr;
 

tokio/src/io/stdin.rs

@@ -54,7 +54,7 @@ cfg_io_std! {
 
 #[cfg(unix)]
 mod sys {
-    use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+    use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};
 
     use super::Stdin;
 

tokio/src/io/stdout.rs

@@ -128,7 +128,7 @@ cfg_io_std! {
 
 #[cfg(unix)]
 mod sys {
-    use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+    use std::os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd};
 
     use super::Stdout;
 

tokio/src/net/tcp/listener.rs

@@ -274,7 +274,7 @@ impl TcpListener {
     pub fn into_std(self) -> io::Result<std::net::TcpListener> {
         #[cfg(unix)]
         {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
             self.io
                 .into_inner()
                 .map(IntoRawFd::into_raw_fd)

tokio/src/net/tcp/socket.rs

@@ -5,7 +5,7 @@ use std::io;
 use std::net::SocketAddr;
 
 #[cfg(unix)]
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use std::time::Duration;
 
 cfg_windows! {
@@ -670,7 +670,7 @@ impl TcpSocket {
         }
         #[cfg(unix)]
         let mio = {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = self.inner.into_raw_fd();
             unsafe { mio::net::TcpStream::from_raw_fd(raw_fd) }
@@ -726,7 +726,7 @@ impl TcpSocket {
         self.inner.listen(backlog as i32)?;
         #[cfg(unix)]
         let mio = {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = self.inner.into_raw_fd();
             unsafe { mio::net::TcpListener::from_raw_fd(raw_fd) }
@@ -780,7 +780,7 @@ impl TcpSocket {
     pub fn from_std_stream(std_stream: std::net::TcpStream) -> TcpSocket {
         #[cfg(unix)]
         {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = std_stream.into_raw_fd();
             unsafe { TcpSocket::from_raw_fd(raw_fd) }

tokio/src/net/tcp/stream.rs

@@ -254,7 +254,7 @@ impl TcpStream {
     pub fn into_std(self) -> io::Result<std::net::TcpStream> {
         #[cfg(unix)]
         {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
             self.io
                 .into_inner()
                 .map(IntoRawFd::into_raw_fd)

tokio/src/net/udp.rs

@@ -256,7 +256,7 @@ impl UdpSocket {
     pub fn into_std(self) -> io::Result<std::net::UdpSocket> {
         #[cfg(unix)]
         {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
             self.io
                 .into_inner()
                 .map(IntoRawFd::into_raw_fd)

tokio/src/net/unix/datagram/socket.rs

@@ -5,7 +5,7 @@ use crate::util::check_socket_for_blocking;
 use std::fmt;
 use std::io;
 use std::net::Shutdown;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net;
 use std::path::Path;
 use std::task::{ready, Context, Poll};

tokio/src/net/unix/listener.rs

@@ -6,11 +6,11 @@ use std::fmt;
 use std::io;
 #[cfg(target_os = "android")]
 use std::os::android::net::SocketAddrExt;
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 #[cfg(target_os = "linux")]
 use std::os::linux::net::SocketAddrExt;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::unix::ffi::OsStrExt;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net::{self, SocketAddr as StdSocketAddr};
 use std::path::Path;
 use std::task::{ready, Context, Poll};

tokio/src/net/unix/pipe.rs

@@ -6,8 +6,8 @@ use crate::io::{AsyncRead, AsyncWrite, PollEvented, ReadBuf, Ready};
 use mio::unix::pipe as mio_pipe;
 use std::fs::File;
 use std::io::{self, Read, Write};
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 use std::os::unix::fs::OpenOptionsExt;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 use std::path::Path;
 use std::pin::Pin;
 use std::task::{Context, Poll};

tokio/src/net/unix/socket.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::path::Path;
 
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 
 use crate::net::{UnixDatagram, UnixListener, UnixStream};
 
@@ -178,7 +178,7 @@ impl UnixSocket {
 
         self.inner.listen(backlog as i32)?;
         let mio = {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = self.inner.into_raw_fd();
             unsafe { mio::net::UnixListener::from_raw_fd(raw_fd) }
@@ -213,7 +213,7 @@ impl UnixSocket {
             }
         }
         let mio = {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = self.inner.into_raw_fd();
             unsafe { mio::net::UnixStream::from_raw_fd(raw_fd) }
@@ -235,7 +235,7 @@ impl UnixSocket {
             ));
         }
         let mio = {
-            use std::os::unix::io::{FromRawFd, IntoRawFd};
+            use std::os::fd::{FromRawFd, IntoRawFd};
 
             let raw_fd = self.inner.into_raw_fd();
             unsafe { mio::net::UnixDatagram::from_raw_fd(raw_fd) }

tokio/src/net/unix/stream.rs

@@ -11,11 +11,11 @@ use std::io::{self, Read, Write};
 use std::net::Shutdown;
 #[cfg(target_os = "android")]
 use std::os::android::net::SocketAddrExt;
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 #[cfg(target_os = "linux")]
 use std::os::linux::net::SocketAddrExt;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::unix::ffi::OsStrExt;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net::{self, SocketAddr as StdSocketAddr};
 use std::path::Path;
 use std::pin::Pin;

tokio/src/net/unix/ucred.rs

@@ -91,7 +91,7 @@ pub(crate) mod impl_linux {
     use libc::ucred;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
-        use std::os::unix::io::AsRawFd;
+        use std::os::fd::AsRawFd;
 
         unsafe {
             let raw_fd = sock.as_raw_fd();
@@ -137,7 +137,7 @@ pub(crate) mod impl_netbsd {
     use libc::{c_void, getsockopt, socklen_t, unpcbid, LOCAL_PEEREID, SOL_SOCKET};
     use std::io;
     use std::mem::size_of;
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
         unsafe {
@@ -179,7 +179,7 @@ pub(crate) mod impl_bsd {
     use libc::getpeereid;
     use std::io;
     use std::mem::MaybeUninit;
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
         unsafe {
@@ -217,7 +217,7 @@ pub(crate) mod impl_macos {
     use std::io;
     use std::mem::size_of;
     use std::mem::MaybeUninit;
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
         unsafe {
@@ -260,7 +260,7 @@ pub(crate) mod impl_macos {
 pub(crate) mod impl_solaris {
     use crate::net::unix::{self, UnixStream};
     use std::io;
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
     use std::ptr;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
@@ -293,7 +293,7 @@ pub(crate) mod impl_solaris {
 pub(crate) mod impl_aix {
     use crate::net::unix::UnixStream;
     use std::io;
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
 
     pub(crate) fn get_peer_cred(sock: &UnixStream) -> io::Result<super::UCred> {
         unsafe {

tokio/src/process/unix/mod.rs

@@ -42,7 +42,7 @@ use std::fmt;
 use std::fs::File;
 use std::future::Future;
 use std::io;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 use std::pin::Pin;
 use std::process::{Child as StdChild, ExitStatus, Stdio};
 use std::task::Context;

tokio/src/runtime/signal/mod.rs

@@ -42,7 +42,7 @@ impl Driver {
     /// Creates a new signal `Driver` instance that delegates wakeups to `park`.
     pub(crate) fn new(io: io::Driver, io_handle: &io::Handle) -> std_io::Result<Self> {
         use std::mem::ManuallyDrop;
-        use std::os::unix::io::{AsRawFd, FromRawFd};
+        use std::os::fd::{AsRawFd, FromRawFd};
 
         // NB: We give each driver a "fresh" receiver file descriptor to avoid
         // the issues described in alexcrichton/tokio-process#42.

tokio/tests/async_send_sync.rs

@@ -739,8 +739,8 @@ mod unix_asyncfd {
     struct ImplsFd<T> {
         _t: T,
     }
-    impl<T> std::os::unix::io::AsRawFd for ImplsFd<T> {
-        fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
+    impl<T> std::os::fd::AsRawFd for ImplsFd<T> {
+        fn as_raw_fd(&self) -> std::os::fd::RawFd {
             unreachable!()
         }
     }

tokio/tests/fs_file.rs

@@ -251,7 +251,7 @@ async fn file_debug_fmt() {
 #[tokio::test]
 #[cfg(unix)]
 async fn unix_fd_is_valid() {
-    use std::os::unix::io::AsRawFd;
+    use std::os::fd::AsRawFd;
     let tempfile = tempfile();
 
     let file = File::create(tempfile.path()).await.unwrap();
@@ -261,7 +261,7 @@ async fn unix_fd_is_valid() {
 #[tokio::test]
 #[cfg(unix)]
 async fn read_file_from_unix_fd() {
-    use std::os::unix::io::{FromRawFd, IntoRawFd};
+    use std::os::fd::{FromRawFd, IntoRawFd};
 
     let mut tempfile = tempfile();
     tempfile.write_all(HELLO).unwrap();

tokio/tests/io_async_fd.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 #![cfg(all(unix, feature = "full"))]
 
-use std::os::unix::io::{AsRawFd, RawFd};
+use std::os::fd::{AsRawFd, RawFd};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,

tokio/tests/net_unix_pipe.rs

@@ -8,8 +8,8 @@ use tokio_test::{assert_err, assert_ok, assert_pending, assert_ready_ok};
 
 use std::fs::File;
 use std::io;
+use std::os::fd::AsRawFd;
 use std::os::unix::fs::OpenOptionsExt;
-use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
 
 /// Helper struct which will clean up temporary files once dropped.