Refactor

Author: Stjepan Glavina

src/fs/dir_builder.rs

@@ -1,10 +1,10 @@
 use std::fs;
-use std::io;
 use std::path::Path;
 
 use cfg_if::cfg_if;
 
 use crate::future::Future;
+use crate::io;
 use crate::task::blocking;
 
 /// A builder for creating directories in various manners.

src/fs/dir_entry.rs

@@ -1,6 +1,5 @@
 use std::ffi::OsString;
 use std::fs;
-use std::io;
 use std::path::PathBuf;
 use std::pin::Pin;
 use std::sync::Mutex;
@@ -9,6 +8,7 @@ use cfg_if::cfg_if;
 use futures::future::{self, FutureExt, TryFutureExt};
 
 use crate::future::Future;
+use crate::io;
 use crate::task::{blocking, Poll};
 
 /// An entry inside a directory.

src/fs/file.rs

@@ -1,7 +1,7 @@
 //! Types for working with files.
 
 use std::fs;
-use std::io::{self, SeekFrom};
+use std::io::{Read as _, Seek, SeekFrom, Write as _};
 use std::path::Path;
 use std::pin::Pin;
 use std::sync::Mutex;
@@ -11,6 +11,7 @@ use futures::future::{self, FutureExt, TryFutureExt};
 use futures::io::{AsyncSeek, Initializer};
 
 use crate::future::Future;
+use crate::io;
 use crate::task::{blocking, Context, Poll};
 
 /// A reference to a file on the filesystem.
@@ -543,10 +544,10 @@ impl futures::io::AsyncRead for &File {
                     *state = State::Busy(blocking::spawn(async move {
                         if offset > 0 {
                             let pos = SeekFrom::Current(-(offset as i64));
-                            let _ = io::Seek::seek(&mut inner.file, pos);
+                            let _ = Seek::seek(&mut inner.file, pos);
                         }
 
-                        let res = io::Read::read(&mut inner.file, &mut inner.buf);
+                        let res = inner.file.read(&mut inner.buf);
                         inner.last_op = Some(Operation::Read(res));
                         State::Idle(Some(inner))
                     }));
@@ -621,7 +622,7 @@ impl futures::io::AsyncWrite for &File {
 
                         // Start the operation asynchronously.
                         *state = State::Busy(blocking::spawn(async move {
-                            let res = io::Write::write(&mut inner.file, &mut inner.buf);
+                            let res = inner.file.write(&mut inner.buf);
                             inner.last_op = Some(Operation::Write(res));
                             State::Idle(Some(inner))
                         }));
@@ -654,7 +655,7 @@ impl futures::io::AsyncWrite for &File {
 
                         // Start the operation asynchronously.
                         *state = State::Busy(blocking::spawn(async move {
-                            let res = io::Write::flush(&mut inner.file);
+                            let res = inner.file.flush();
                             inner.last_op = Some(Operation::Flush(res));
                             State::Idle(Some(inner))
                         }));
@@ -725,7 +726,7 @@ impl AsyncSeek for &File {
 
                         // Start the operation asynchronously.
                         *state = State::Busy(blocking::spawn(async move {
-                            let res = io::Seek::seek(&mut inner.file, pos);
+                            let res = inner.file.seek(pos);
                             inner.last_op = Some(Operation::Seek(res));
                             State::Idle(Some(inner))
                         }));

src/fs/mod.rs

@@ -22,10 +22,10 @@
 //! ```
 
 use std::fs;
-use std::io;
 use std::path::{Path, PathBuf};
 
 use crate::task::blocking;
+use std::io;
 
 pub use dir_builder::DirBuilder;
 pub use dir_entry::DirEntry;

src/fs/read_dir.rs

@@ -1,11 +1,11 @@
 use std::fs;
-use std::io;
 
 use std::pin::Pin;
 use std::sync::Mutex;
 
 use super::DirEntry;
 use crate::future::Future;
+use crate::io;
 use crate::task::{blocking, Context, Poll};
 
 /// A stream over entries in a directory.

src/io/buf_reader.rs

@@ -1,9 +1,10 @@
-use std::io::{self, IoSliceMut, Read as _, SeekFrom};
+use std::io::{IoSliceMut, Read as _, SeekFrom};
 use std::pin::Pin;
 use std::{cmp, fmt};
 
 use futures::io::{AsyncBufRead, AsyncRead, AsyncSeek, Initializer};
 
+use crate::io;
 use crate::task::{Context, Poll};
 
 const DEFAULT_CAPACITY: usize = 8 * 1024;
@@ -22,7 +23,10 @@ const DEFAULT_CAPACITY: usize = 8 * 1024;
 /// When the `BufReader` is dropped, the contents of its buffer will be discarded. Creating
 /// multiple instances of a `BufReader` on the same stream can cause data loss.
 ///
+/// This type is an async version of [`std::io::BufReader`].
+///
 /// [`Read`]: trait.Read.html
+/// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html
 ///
 /// # Examples
 ///

src/io/copy.rs

@@ -1,7 +1,7 @@
-use std::io;
-
 use futures::io::{AsyncRead, AsyncReadExt, AsyncWrite};
 
+use crate::io;
+
 /// Copies the entire contents of a reader into a writer.
 ///
 /// This function will continuously read data from `reader` and then

src/io/read.rs

@@ -1,4 +1,4 @@
-use std::io::{self, IoSliceMut};
+use std::io::IoSliceMut;
 use std::mem;
 use std::pin::Pin;
 use std::str;
@@ -7,6 +7,7 @@ use cfg_if::cfg_if;
 use futures::io::AsyncRead;
 
 use crate::future::Future;
+use crate::io;
 use crate::task::{Context, Poll};
 
 cfg_if! {

src/io/seek.rs

@@ -1,10 +1,11 @@
-use std::io::{self, SeekFrom};
+use std::io::SeekFrom;
 use std::pin::Pin;
 
 use cfg_if::cfg_if;
 use futures::io::AsyncSeek;
 
 use crate::future::Future;
+use crate::io;
 use crate::task::{Context, Poll};
 
 cfg_if! {

src/io/write.rs

@@ -1,11 +1,12 @@
-use std::io::{self, IoSlice};
+use std::io::IoSlice;
 use std::mem;
 use std::pin::Pin;
 
 use cfg_if::cfg_if;
 use futures::io::AsyncWrite;
 
 use crate::future::Future;
+use crate::io;
 use crate::task::{Context, Poll};
 
 cfg_if! {

src/net/driver.rs renamed to src/net/driver/mod.rs

@@ -1,5 +1,5 @@
 use std::fmt;
-use std::io::{self, prelude::*};
+use std::io::{Read as _, Write as _};
 use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
@@ -9,6 +9,7 @@ use lazy_static::lazy_static;
 use mio::{self, Evented};
 use slab::Slab;
 
+use crate::io;
 use crate::task::{Context, Poll, Waker};
 use crate::utils::abort_on_panic;
 
@@ -296,7 +297,7 @@ impl<T: Evented + fmt::Debug> fmt::Debug for IoHandle<T> {
     }
 }
 
-impl<T: Evented + Unpin + Read> AsyncRead for IoHandle<T> {
+impl<T: Evented + std::io::Read + Unpin> AsyncRead for IoHandle<T> {
     fn poll_read(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -316,7 +317,7 @@ impl<T: Evented + Unpin + Read> AsyncRead for IoHandle<T> {
 
 impl<'a, T: Evented + Unpin> AsyncRead for &'a IoHandle<T>
 where
-    &'a T: Read,
+    &'a T: std::io::Read,
 {
     fn poll_read(
         mut self: Pin<&mut Self>,
@@ -335,7 +336,7 @@ where
     }
 }
 
-impl<T: Evented + Unpin + Write> AsyncWrite for IoHandle<T> {
+impl<T: Evented + std::io::Write + Unpin> AsyncWrite for IoHandle<T> {
     fn poll_write(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -371,7 +372,7 @@ impl<T: Evented + Unpin + Write> AsyncWrite for IoHandle<T> {
 
 impl<'a, T: Evented + Unpin> AsyncWrite for &'a IoHandle<T>
 where
-    &'a T: Write,
+    &'a T: std::io::Write,
 {
     fn poll_write(
         self: Pin<&mut Self>,