Improve several Read implementations

Author: a1phyr

library/std/src/io/cursor.rs

@@ -355,6 +355,28 @@ where
         self.pos += n as u64;
         Ok(())
     }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        let content = self.remaining_slice();
+        let len = content.len();
+        buf.try_reserve(len)?;
+        buf.extend_from_slice(content);
+        self.pos = self.inner.as_ref().len() as u64;
+
+        Ok(len)
+    }
+
+    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+        let content = crate::str::from_utf8(self.remaining_slice()).map_err(|_| {
+            io::const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
+        })?;
+        let len = content.len();
+        buf.try_reserve(len)?;
+        buf.push_str(content);
+        self.pos = self.inner.as_ref().len() as u64;
+
+        Ok(len)
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

library/std/src/io/impls.rs

@@ -315,8 +315,9 @@ impl Read for &[u8] {
         let content = str::from_utf8(self).map_err(|_| {
             io::const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
         })?;
-        buf.push_str(content);
         let len = self.len();
+        buf.try_reserve(len)?;
+        buf.push_str(content);
         *self = &self[len..];
         Ok(len)
     }
@@ -470,6 +471,7 @@ impl<A: Allocator> Read for VecDeque<u8, A> {
         let string = str::from_utf8(content).map_err(|_| {
             io::const_io_error!(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
         })?;
+        buf.try_reserve(len)?;
         buf.push_str(string);
         self.clear();
         Ok(len)

library/std/src/io/mod.rs

@@ -2924,6 +2924,22 @@ impl<T: Read> Read for Take<T> {
         Ok(n)
     }
 
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
+        // Don't call into inner reader at all at EOF because it may still block
+        if self.limit == 0 {
+            return Ok(());
+        }
+
+        let len = buf.len() as u64;
+        if self.limit > len {
+            self.inner.read_exact(buf)?;
+            self.limit += len;
+            Ok(())
+        } else {
+            Err(error::const_io_error!(ErrorKind::UnexpectedEof, "failed to fill whole buffer"))
+        }
+    }
+
     fn read_buf(&mut self, mut buf: BorrowedCursor<'_>) -> Result<()> {
         // Don't call into inner reader at all at EOF because it may still block
         if self.limit == 0 {
@@ -2970,6 +2986,22 @@ impl<T: Read> Read for Take<T> {
 
         Ok(())
     }
+
+    fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<()> {
+        // Don't call into inner reader at all at EOF because it may still block
+        if self.limit == 0 {
+            return Ok(());
+        }
+
+        let cap = cursor.capacity() as u64;
+        if self.limit > cap {
+            self.inner.read_buf_exact(cursor)?;
+            self.limit += cap;
+            Ok(())
+        } else {
+            Err(error::const_io_error!(ErrorKind::UnexpectedEof, "failed to fill whole buffer"))
+        }
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

library/std/src/os/unix/net/stream.rs

@@ -578,6 +578,10 @@ impl io::Read for UnixStream {
         io::Read::read(&mut &*self, buf)
     }
 
+    fn read_buf(&mut self, buf: io::BorrowedCursor<'_>) -> io::Result<()> {
+        io::Read::read_buf(&mut &*self, buf)
+    }
+
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
         io::Read::read_vectored(&mut &*self, bufs)
     }
@@ -594,6 +598,10 @@ impl<'a> io::Read for &'a UnixStream {
         self.0.read(buf)
     }
 
+    fn read_buf(&mut self, buf: io::BorrowedCursor<'_>) -> io::Result<()> {
+        self.0.read_buf(buf)
+    }
+
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
         self.0.read_vectored(bufs)
     }

library/std/src/process.rs

@@ -439,6 +439,10 @@ impl Read for ChildStderr {
     fn is_read_vectored(&self) -> bool {
         self.inner.is_read_vectored()
     }
+
+    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+        self.inner.read_to_end(buf)
+    }
 }
 
 impl AsInner<AnonPipe> for ChildStderr {