Change copy_into/copy_buf_into back to taking writer by reference

Author: Nemo157

futures-util/src/io/copy_buf_into.rs

@@ -7,34 +7,36 @@ use std::pin::Pin;
 /// Future for the [`copy_buf_into`](super::AsyncBufReadExt::copy_buf_into) method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct CopyBufInto<R, W> {
+pub struct CopyBufInto<'a, R, W> {
     reader: R,
-    writer: W,
+    writer: &'a mut W,
     amt: u64,
 }
 
-impl<R: Unpin, W: Unpin> Unpin for CopyBufInto<R, W> {}
+impl<R: Unpin, W> Unpin for CopyBufInto<'_, R, W> {}
 
-impl<R, W> CopyBufInto<R, W> {
-    pub(super) fn new(reader: R, writer: W) -> Self {
+impl<R, W> CopyBufInto<'_, R, W> {
+    pub(super) fn new(reader: R, writer: &mut W) -> CopyBufInto<'_, R, W> {
         CopyBufInto {
             reader,
             writer,
             amt: 0,
         }
     }
+}
 
-    fn project<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut R>, Pin<&'a mut W>, &'a mut u64) {
+impl<R, W: Unpin> CopyBufInto<'_, R, W> {
+    fn project<'b>(self: Pin<&'b mut Self>) -> (Pin<&'b mut R>, Pin<&'b mut W>, &'b mut u64) {
         unsafe {
             let this = self.get_unchecked_mut();
-            (Pin::new_unchecked(&mut this.reader), Pin::new_unchecked(&mut this.writer), &mut this.amt)
+            (Pin::new_unchecked(&mut this.reader), Pin::new(&mut *this.writer), &mut this.amt)
         }
     }
 }
 
-impl<R, W> Future for CopyBufInto<R, W>
+impl<R, W> Future for CopyBufInto<'_, R, W>
     where R: AsyncBufRead,
-          W: AsyncWrite,
+          W: AsyncWrite + Unpin,
 {
     type Output = io::Result<u64>;
 

futures-util/src/io/copy_into.rs

@@ -9,23 +9,23 @@ use pin_utils::unsafe_pinned;
 /// Future for the [`copy_into`](super::AsyncReadExt::copy_into) method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct CopyInto<R: AsyncRead, W> {
-    inner: CopyBufInto<BufReader<R>, W>,
+pub struct CopyInto<'a, R: AsyncRead, W> {
+    inner: CopyBufInto<'a, BufReader<R>, W>,
 }
 
-impl<R: AsyncRead, W> Unpin for CopyInto<R, W> where CopyBufInto<BufReader<R>, W>: Unpin {}
+impl<'a, R: AsyncRead, W> Unpin for CopyInto<'a, R, W> where CopyBufInto<'a, BufReader<R>, W>: Unpin {}
 
-impl<R: AsyncRead, W> CopyInto<R, W> {
-    unsafe_pinned!(inner: CopyBufInto<BufReader<R>, W>);
+impl<'a, R: AsyncRead, W> CopyInto<'a, R, W> {
+    unsafe_pinned!(inner: CopyBufInto<'a, BufReader<R>, W>);
 
-    pub(super) fn new(reader: R, writer: W) -> Self {
+    pub(super) fn new(reader: R, writer: &mut W) -> CopyInto<'_, R, W> {
         CopyInto {
             inner: CopyBufInto::new(BufReader::new(reader), writer),
         }
     }
 }
 
-impl<R: AsyncRead, W: AsyncWrite> Future for CopyInto<R, W> {
+impl<R: AsyncRead, W: AsyncWrite + Unpin> Future for CopyInto<'_, R, W> {
     type Output = io::Result<u64>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

futures-util/src/io/mod.rs

@@ -93,9 +93,6 @@ pub trait AsyncReadExt: AsyncRead {
     ///
     /// On success the number of bytes is returned.
     ///
-    /// Note that this method consumes `writer` but does not close it, you will likely want to pass
-    /// it by reference as shown in the example.
-    ///
     /// # Examples
     ///
     /// ```
@@ -114,7 +111,7 @@ pub trait AsyncReadExt: AsyncRead {
     /// assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
     /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
     /// ```
-    fn copy_into<W: AsyncWrite>(self, writer: W) -> CopyInto<Self, W> where Self: Sized {
+    fn copy_into<W: AsyncWrite + Unpin>(self, writer: &mut W) -> CopyInto<'_, Self, W> where Self: Sized {
         CopyInto::new(self, writer)
     }
 
@@ -452,9 +449,6 @@ pub trait AsyncBufReadExt: AsyncBufRead {
     ///
     /// On success the number of bytes is returned.
     ///
-    /// Note that this method consumes `writer` but does not close it, you will likely want to pass
-    /// it by reference as shown in the example.
-    ///
     /// # Examples
     ///
     /// ```
@@ -473,7 +467,7 @@ pub trait AsyncBufReadExt: AsyncBufRead {
     /// assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
     /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
     /// ```
-    fn copy_buf_into<W: AsyncWrite>(self, writer: W) -> CopyBufInto<Self, W> where Self: Sized {
+    fn copy_buf_into<W: AsyncWrite + Unpin>(self, writer: &mut W) -> CopyBufInto<'_, Self, W> where Self: Sized {
         CopyBufInto::new(self, writer)
     }