Make std::io::copy take Read and Write by value instead of by reference

The traits are also implemented on mutable references of types implementing that trait.

Author: est31

library/std/src/io/copy.rs

@@ -50,7 +50,7 @@ use crate::mem::MaybeUninit;
 ///
 /// [changes]: crate::io#platform-specific-behavior
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64>
+pub fn copy<R, W>(reader: R, writer: W) -> Result<u64>
 where
     R: Read,
     W: Write,
@@ -66,7 +66,7 @@ where
 
 /// The userspace read-write-loop implementation of `io::copy` that is used when
 /// OS-specific specializations for copy offloading are not available or not applicable.
-pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64>
+pub(crate) fn generic_copy<R, W>(reader: R, writer: W) -> Result<u64>
 where
     R: Read,
     W: Write,
@@ -77,17 +77,23 @@ where
 /// Specialization of the read-write loop that either uses a stack buffer
 /// or reuses the internal buffer of a BufWriter
 trait BufferedCopySpec: Write {
-    fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64>;
+    fn copy_to<R: Read>(reader: R, writer: Self) -> Result<u64>;
 }
 
-impl<W: Write + ?Sized> BufferedCopySpec for W {
-    default fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> {
+impl<W: Write> BufferedCopySpec for W {
+    default fn copy_to<R: Read>(reader: R, writer: Self) -> Result<u64> {
         stack_buffer_copy(reader, writer)
     }
 }
 
 impl<I: Write> BufferedCopySpec for BufWriter<I> {
-    fn copy_to<R: Read + ?Sized>(reader: &mut R, writer: &mut Self) -> Result<u64> {
+    fn copy_to<R: Read>(reader: R, mut writer: Self) -> Result<u64> {
+        BufferedCopySpec::copy_to(reader, &mut writer)
+    }
+}
+
+impl<I: Write> BufferedCopySpec for &mut BufWriter<I> {
+    fn copy_to<R: Read>(mut reader: R, writer: Self) -> Result<u64> {
         if writer.capacity() < DEFAULT_BUF_SIZE {
             return stack_buffer_copy(reader, writer);
         }
@@ -134,10 +140,7 @@ impl<I: Write> BufferedCopySpec for BufWriter<I> {
     }
 }
 
-fn stack_buffer_copy<R: Read + ?Sized, W: Write + ?Sized>(
-    reader: &mut R,
-    writer: &mut W,
-) -> Result<u64> {
+fn stack_buffer_copy<R: Read, W: Write>(mut reader: R, mut writer: W) -> Result<u64> {
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); DEFAULT_BUF_SIZE];
     let mut buf: BorrowedBuf<'_> = buf.into();
 

library/std/src/sys/unix/kernel_copy.rs

@@ -68,10 +68,7 @@ use libc::{EBADF, EINVAL, ENOSYS, EOPNOTSUPP, EOVERFLOW, EPERM, EXDEV};
 #[cfg(test)]
 mod tests;
 
-pub(crate) fn copy_spec<R: Read + ?Sized, W: Write + ?Sized>(
-    read: &mut R,
-    write: &mut W,
-) -> Result<u64> {
+pub(crate) fn copy_spec<R: Read, W: Write>(read: R, write: W) -> Result<u64> {
     let copier = Copier { read, write };
     SpecCopy::copy(copier)
 }
@@ -160,30 +157,30 @@ fn safe_kernel_copy(source: &FdMeta, sink: &FdMeta) -> bool {
 
 struct CopyParams(FdMeta, Option<RawFd>);
 
-struct Copier<'a, 'b, R: Read + ?Sized, W: Write + ?Sized> {
-    read: &'a mut R,
-    write: &'b mut W,
+struct Copier<R: Read, W: Write> {
+    read: R,
+    write: W,
 }
 
 trait SpecCopy {
     fn copy(self) -> Result<u64>;
 }
 
-impl<R: Read + ?Sized, W: Write + ?Sized> SpecCopy for Copier<'_, '_, R, W> {
+impl<R: Read, W: Write> SpecCopy for Copier<R, W> {
     default fn copy(self) -> Result<u64> {
         generic_copy(self.read, self.write)
     }
 }
 
-impl<R: CopyRead, W: CopyWrite> SpecCopy for Copier<'_, '_, R, W> {
+impl<R: CopyRead, W: CopyWrite> SpecCopy for Copier<R, W> {
     fn copy(self) -> Result<u64> {
-        let (reader, writer) = (self.read, self.write);
+        let Copier { read: mut reader, write: mut writer } = self;
         let r_cfg = reader.properties();
         let w_cfg = writer.properties();
 
         // before direct operations on file descriptors ensure that all source and sink buffers are empty
         let mut flush = || -> crate::io::Result<u64> {
-            let bytes = reader.drain_to(writer, u64::MAX)?;
+            let bytes = reader.drain_to(&mut writer, u64::MAX)?;
             // BufWriter buffered bytes have already been accounted for in earlier write() calls
             writer.flush()?;
             Ok(bytes)
@@ -199,7 +196,7 @@ impl<R: CopyRead, W: CopyWrite> SpecCopy for Copier<'_, '_, R, W> {
 
             if input_meta.copy_file_range_candidate() && output_meta.copy_file_range_candidate() {
                 let result = copy_regular_files(readfd, writefd, max_write);
-                result.update_take(reader);
+                result.update_take(&mut reader);
 
                 match result {
                     CopyResult::Ended(bytes_copied) => return Ok(bytes_copied + written),
@@ -216,7 +213,7 @@ impl<R: CopyRead, W: CopyWrite> SpecCopy for Copier<'_, '_, R, W> {
             if input_meta.potential_sendfile_source() && safe_kernel_copy(&input_meta, &output_meta)
             {
                 let result = sendfile_splice(SpliceMode::Sendfile, readfd, writefd, max_write);
-                result.update_take(reader);
+                result.update_take(&mut reader);
 
                 match result {
                     CopyResult::Ended(bytes_copied) => return Ok(bytes_copied + written),
@@ -229,7 +226,7 @@ impl<R: CopyRead, W: CopyWrite> SpecCopy for Copier<'_, '_, R, W> {
                 && safe_kernel_copy(&input_meta, &output_meta)
             {
                 let result = sendfile_splice(SpliceMode::Splice, readfd, writefd, max_write);
-                result.update_take(reader);
+                result.update_take(&mut reader);
 
                 match result {
                     CopyResult::Ended(bytes_copied) => return Ok(bytes_copied + written),