io: change AsyncRead to use a ReadBuf (#2758)

Works towards #2716. Changes the argument to `AsyncRead::poll_read` to
take a `ReadBuf` struct that safely manages writes to uninitialized memory.

tokio/tests/io_async_read.rs

@@ -1,14 +1,12 @@
-#![allow(clippy::transmute_ptr_to_ptr)]
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::AsyncRead;
+use tokio::io::{AsyncRead, ReadBuf};
 use tokio_test::task;
 use tokio_test::{assert_ready_err, assert_ready_ok};
 
-use bytes::{BufMut, BytesMut};
+use bytes::BytesMut;
 use std::io;
-use std::mem::MaybeUninit;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -26,10 +24,10 @@ fn read_buf_success() {
         fn poll_read(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
-            buf[0..11].copy_from_slice(b"hello world");
-            Poll::Ready(Ok(11))
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            buf.append(b"hello world");
+            Poll::Ready(Ok(()))
         }
     }
 
@@ -51,8 +49,8 @@ fn read_buf_error() {
         fn poll_read(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            _buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
+            _buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
             let err = io::ErrorKind::Other.into();
             Poll::Ready(Err(err))
         }
@@ -74,8 +72,8 @@ fn read_buf_no_capacity() {
         fn poll_read(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            _buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
+            _buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
             unimplemented!();
         }
     }
@@ -88,59 +86,26 @@ fn read_buf_no_capacity() {
     });
 }
 
-#[test]
-fn read_buf_no_uninitialized() {
-    struct Rd;
-
-    impl AsyncRead for Rd {
-        fn poll_read(
-            self: Pin<&mut Self>,
-            _cx: &mut Context<'_>,
-            buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
-            for b in buf {
-                assert_eq!(0, *b);
-            }
-
-            Poll::Ready(Ok(0))
-        }
-    }
-
-    let mut buf = BytesMut::with_capacity(64);
-
-    task::spawn(Rd).enter(|cx, rd| {
-        let n = assert_ready_ok!(rd.poll_read_buf(cx, &mut buf));
-        assert_eq!(0, n);
-    });
-}
-
 #[test]
 fn read_buf_uninitialized_ok() {
     struct Rd;
 
     impl AsyncRead for Rd {
-        unsafe fn prepare_uninitialized_buffer(&self, _: &mut [MaybeUninit<u8>]) -> bool {
-            false
-        }
-
         fn poll_read(
             self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
-            assert_eq!(buf[0..11], b"hello world"[..]);
-            Poll::Ready(Ok(0))
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            assert_eq!(buf.remaining(), 64);
+            assert_eq!(buf.filled().len(), 0);
+            assert_eq!(buf.initialized().len(), 0);
+            Poll::Ready(Ok(()))
         }
     }
 
     // Can't create BytesMut w/ zero capacity, so fill it up
     let mut buf = BytesMut::with_capacity(64);
 
-    unsafe {
-        let b: &mut [u8] = std::mem::transmute(buf.bytes_mut());
-        b[0..11].copy_from_slice(b"hello world");
-    }
-
     task::spawn(Rd).enter(|cx, rd| {
         let n = assert_ready_ok!(rd.poll_read_buf(cx, &mut buf));
         assert_eq!(0, n);

tokio/tests/io_copy.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::{self, AsyncRead};
+use tokio::io::{self, AsyncRead, ReadBuf};
 use tokio_test::assert_ok;
 
 use std::pin::Pin;
@@ -15,14 +15,14 @@ async fn copy() {
         fn poll_read(
             mut self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
             if self.0 {
-                buf[0..11].copy_from_slice(b"hello world");
+                buf.append(b"hello world");
                 self.0 = false;
-                Poll::Ready(Ok(11))
+                Poll::Ready(Ok(()))
             } else {
-                Poll::Ready(Ok(0))
+                Poll::Ready(Ok(()))
             }
         }
     }

tokio/tests/io_read.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::{AsyncRead, AsyncReadExt};
+use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
 use tokio_test::assert_ok;
 
 use std::io;
@@ -19,13 +19,13 @@ async fn read() {
         fn poll_read(
             mut self: Pin<&mut Self>,
             _cx: &mut Context<'_>,
-            buf: &mut [u8],
-        ) -> Poll<io::Result<usize>> {
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
             assert_eq!(0, self.poll_cnt);
             self.poll_cnt += 1;
 
-            buf[0..11].copy_from_slice(b"hello world");
-            Poll::Ready(Ok(11))
+            buf.append(b"hello world");
+            Poll::Ready(Ok(()))
         }
     }
 
@@ -36,25 +36,3 @@ async fn read() {
     assert_eq!(n, 11);
     assert_eq!(buf[..], b"hello world"[..]);
 }
-
-struct BadAsyncRead;
-
-impl AsyncRead for BadAsyncRead {
-    fn poll_read(
-        self: Pin<&mut Self>,
-        _cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        for b in &mut *buf {
-            *b = b'a';
-        }
-        Poll::Ready(Ok(buf.len() * 2))
-    }
-}
-
-#[tokio::test]
-#[should_panic]
-async fn read_buf_bad_async_read() {
-    let mut buf = Vec::with_capacity(10);
-    BadAsyncRead.read_buf(&mut buf).await.unwrap();
-}

tokio/tests/io_split.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::{split, AsyncRead, AsyncWrite, ReadHalf, WriteHalf};
+use tokio::io::{split, AsyncRead, AsyncWrite, ReadBuf, ReadHalf, WriteHalf};
 
 use std::io;
 use std::pin::Pin;
@@ -13,9 +13,10 @@ impl AsyncRead for RW {
     fn poll_read(
         self: Pin<&mut Self>,
         _cx: &mut Context<'_>,
-        _buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        Poll::Ready(Ok(1))
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        buf.append(&[b'z']);
+        Poll::Ready(Ok(()))
     }
 }