Correcting overly restrictive lifetimes in vectored IO (#2484)

Co-authored-by: Taiki Endo <[email protected]>

Author: ejmount

futures-util/src/io/mod.rs

@@ -217,7 +217,10 @@ pub trait AsyncReadExt: AsyncRead {
     ///
     /// The returned future will resolve to the number of bytes read once the read
     /// operation is completed.
-    fn read_vectored<'a>(&'a mut self, bufs: &'a mut [IoSliceMut<'a>]) -> ReadVectored<'a, Self>
+    fn read_vectored<'a, 'b>(
+        &'a mut self,
+        bufs: &'a mut [IoSliceMut<'b>],
+    ) -> ReadVectored<'a, 'b, Self>
     where
         Self: Unpin,
     {
@@ -456,7 +459,7 @@ pub trait AsyncWriteExt: AsyncWrite {
     ///
     /// The returned future will resolve to the number of bytes written once the write
     /// operation is completed.
-    fn write_vectored<'a>(&'a mut self, bufs: &'a [IoSlice<'a>]) -> WriteVectored<'a, Self>
+    fn write_vectored<'a, 'b>(&'a mut self, bufs: &'a [IoSlice<'b>]) -> WriteVectored<'a, 'b, Self>
     where
         Self: Unpin,
     {
@@ -535,10 +538,10 @@ pub trait AsyncWriteExt: AsyncWrite {
     /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
     /// ```
     #[cfg(feature = "write-all-vectored")]
-    fn write_all_vectored<'a>(
+    fn write_all_vectored<'a, 'b>(
         &'a mut self,
-        bufs: &'a mut [IoSlice<'a>],
-    ) -> WriteAllVectored<'a, Self>
+        bufs: &'a mut [IoSlice<'b>],
+    ) -> WriteAllVectored<'a, 'b, Self>
     where
         Self: Unpin,
     {

futures-util/src/io/read_vectored.rs

@@ -7,20 +7,20 @@ use std::pin::Pin;
 /// Future for the [`read_vectored`](super::AsyncReadExt::read_vectored) method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct ReadVectored<'a, R: ?Sized> {
+pub struct ReadVectored<'a, 'b, R: ?Sized> {
     reader: &'a mut R,
-    bufs: &'a mut [IoSliceMut<'a>],
+    bufs: &'a mut [IoSliceMut<'b>],
 }
 
-impl<R: ?Sized + Unpin> Unpin for ReadVectored<'_, R> {}
+impl<R: ?Sized + Unpin> Unpin for ReadVectored<'_, '_, R> {}
 
-impl<'a, R: AsyncRead + ?Sized + Unpin> ReadVectored<'a, R> {
-    pub(super) fn new(reader: &'a mut R, bufs: &'a mut [IoSliceMut<'a>]) -> Self {
+impl<'a, 'b, R: AsyncRead + ?Sized + Unpin> ReadVectored<'a, 'b, R> {
+    pub(super) fn new(reader: &'a mut R, bufs: &'a mut [IoSliceMut<'b>]) -> Self {
         Self { reader, bufs }
     }
 }
 
-impl<R: AsyncRead + ?Sized + Unpin> Future for ReadVectored<'_, R> {
+impl<R: AsyncRead + ?Sized + Unpin> Future for ReadVectored<'_, '_, R> {
     type Output = io::Result<usize>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

futures-util/src/io/write_all_vectored.rs

@@ -10,21 +10,21 @@ use std::pin::Pin;
 /// [`write_all_vectored`](super::AsyncWriteExt::write_all_vectored) method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct WriteAllVectored<'a, W: ?Sized + Unpin> {
+pub struct WriteAllVectored<'a, 'b, W: ?Sized + Unpin> {
     writer: &'a mut W,
-    bufs: &'a mut [IoSlice<'a>],
+    bufs: &'a mut [IoSlice<'b>],
 }
 
-impl<W: ?Sized + Unpin> Unpin for WriteAllVectored<'_, W> {}
+impl<W: ?Sized + Unpin> Unpin for WriteAllVectored<'_, '_, W> {}
 
-impl<'a, W: AsyncWrite + ?Sized + Unpin> WriteAllVectored<'a, W> {
-    pub(super) fn new(writer: &'a mut W, mut bufs: &'a mut [IoSlice<'a>]) -> Self {
+impl<'a, 'b, W: AsyncWrite + ?Sized + Unpin> WriteAllVectored<'a, 'b, W> {
+    pub(super) fn new(writer: &'a mut W, mut bufs: &'a mut [IoSlice<'b>]) -> Self {
         IoSlice::advance_slices(&mut bufs, 0);
         Self { writer, bufs }
     }
 }
 
-impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteAllVectored<'_, W> {
+impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteAllVectored<'_, '_, W> {
     type Output = io::Result<()>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
@@ -190,4 +190,30 @@ mod tests {
             assert_eq!(&*dst.written, &*wanted);
         }
     }
+
+    #[test]
+    fn test_write_all_vectored_distinct_lifetimes() {
+        struct WrapVec<T>(Vec<T>);
+        impl<T> Drop for WrapVec<T> {
+            fn drop(&mut self) {}
+        }
+
+        let waker = noop_waker();
+        let mut cx = Context::from_waker(&waker);
+        let mut dst = test_writer(2, 2);
+
+        {
+            // Force the lifetimes of the underlying data and IOSlice to be unequal
+            let data = vec![1, 2, 3, 4];
+            {
+                let mut slices = WrapVec(data.chunks(2).map(IoSlice::new).collect());
+                let mut future = dst.write_all_vectored(&mut *slices.0);
+                match Pin::new(&mut future).poll(&mut cx) {
+                    Poll::Ready(Ok(())) => {}
+                    other => panic!("unexpected result polling future: {:?}", other),
+                }
+            }
+            assert_eq!(&*dst.written, &*data);
+        }
+    }
 }

futures-util/src/io/write_vectored.rs

@@ -7,20 +7,20 @@ use std::pin::Pin;
 /// Future for the [`write_vectored`](super::AsyncWriteExt::write_vectored) method.
 #[derive(Debug)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct WriteVectored<'a, W: ?Sized> {
+pub struct WriteVectored<'a, 'b, W: ?Sized> {
     writer: &'a mut W,
-    bufs: &'a [IoSlice<'a>],
+    bufs: &'a [IoSlice<'b>],
 }
 
-impl<W: ?Sized + Unpin> Unpin for WriteVectored<'_, W> {}
+impl<W: ?Sized + Unpin> Unpin for WriteVectored<'_, '_, W> {}
 
-impl<'a, W: AsyncWrite + ?Sized + Unpin> WriteVectored<'a, W> {
-    pub(super) fn new(writer: &'a mut W, bufs: &'a [IoSlice<'a>]) -> Self {
+impl<'a, 'b, W: AsyncWrite + ?Sized + Unpin> WriteVectored<'a, 'b, W> {
+    pub(super) fn new(writer: &'a mut W, bufs: &'a [IoSlice<'b>]) -> Self {
         Self { writer, bufs }
     }
 }
 
-impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteVectored<'_, W> {
+impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteVectored<'_, '_, W> {
     type Output = io::Result<usize>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

futures/tests/auto_traits.rs

@@ -793,12 +793,12 @@ pub mod io {
     assert_impl!(ReadUntil<'_, ()>: Unpin);
     assert_not_impl!(ReadUntil<'_, PhantomPinned>: Unpin);
 
-    assert_impl!(ReadVectored<'_, ()>: Send);
-    assert_not_impl!(ReadVectored<'_, *const ()>: Send);
-    assert_impl!(ReadVectored<'_, ()>: Sync);
-    assert_not_impl!(ReadVectored<'_, *const ()>: Sync);
-    assert_impl!(ReadVectored<'_, ()>: Unpin);
-    assert_not_impl!(ReadVectored<'_, PhantomPinned>: Unpin);
+    assert_impl!(ReadVectored<'_, '_, ()>: Send);
+    assert_not_impl!(ReadVectored<'_, '_, *const ()>: Send);
+    assert_impl!(ReadVectored<'_, '_, ()>: Sync);
+    assert_not_impl!(ReadVectored<'_, '_, *const ()>: Sync);
+    assert_impl!(ReadVectored<'_, '_, ()>: Unpin);
+    assert_not_impl!(ReadVectored<'_, '_, PhantomPinned>: Unpin);
 
     assert_impl!(Repeat: Send);
     assert_impl!(Repeat: Sync);
@@ -856,15 +856,15 @@ pub mod io {
     assert_not_impl!(WriteAll<'_, PhantomPinned>: Unpin);
 
     #[cfg(feature = "write-all-vectored")]
-    assert_impl!(WriteAllVectored<'_, ()>: Send);
+    assert_impl!(WriteAllVectored<'_, '_, ()>: Send);
     #[cfg(feature = "write-all-vectored")]
-    assert_not_impl!(WriteAllVectored<'_, *const ()>: Send);
+    assert_not_impl!(WriteAllVectored<'_, '_, *const ()>: Send);
     #[cfg(feature = "write-all-vectored")]
-    assert_impl!(WriteAllVectored<'_, ()>: Sync);
+    assert_impl!(WriteAllVectored<'_, '_, ()>: Sync);
     #[cfg(feature = "write-all-vectored")]
-    assert_not_impl!(WriteAllVectored<'_, *const ()>: Sync);
+    assert_not_impl!(WriteAllVectored<'_, '_, *const ()>: Sync);
     #[cfg(feature = "write-all-vectored")]
-    assert_impl!(WriteAllVectored<'_, ()>: Unpin);
+    assert_impl!(WriteAllVectored<'_, '_, ()>: Unpin);
     // WriteAllVectored requires `W: Unpin`
     // #[cfg(feature = "write-all-vectored")]
     // assert_not_impl!(WriteAllVectored<'_, PhantomPinned>: Unpin);
@@ -875,12 +875,12 @@ pub mod io {
     assert_not_impl!(WriteHalf<*const ()>: Sync);
     assert_impl!(WriteHalf<PhantomPinned>: Unpin);
 
-    assert_impl!(WriteVectored<'_, ()>: Send);
-    assert_not_impl!(WriteVectored<'_, *const ()>: Send);
-    assert_impl!(WriteVectored<'_, ()>: Sync);
-    assert_not_impl!(WriteVectored<'_, *const ()>: Sync);
-    assert_impl!(WriteVectored<'_, ()>: Unpin);
-    assert_not_impl!(WriteVectored<'_, PhantomPinned>: Unpin);
+    assert_impl!(WriteVectored<'_, '_, ()>: Send);
+    assert_not_impl!(WriteVectored<'_, '_, *const ()>: Send);
+    assert_impl!(WriteVectored<'_, '_, ()>: Sync);
+    assert_not_impl!(WriteVectored<'_, '_, *const ()>: Sync);
+    assert_impl!(WriteVectored<'_, '_, ()>: Unpin);
+    assert_not_impl!(WriteVectored<'_, '_, PhantomPinned>: Unpin);
 }
 
 /// Assert Send/Sync/Unpin for all public types in `futures::lock`.