impl traits for more pinned pointers and ?Sized types

Author: taiki-e

futures-core/src/future/mod.rs

@@ -1,5 +1,6 @@
 //! Futures.
 
+use core::ops::DerefMut;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
@@ -21,40 +22,19 @@ pub trait FusedFuture {
     fn is_terminated(&self) -> bool;
 }
 
-impl<F: FusedFuture> FusedFuture for Pin<&mut F> {
-    fn is_terminated(&self) -> bool {
-        <F as FusedFuture>::is_terminated(&**self)
-    }
-}
-
 impl<F: FusedFuture + ?Sized> FusedFuture for &mut F {
     fn is_terminated(&self) -> bool {
         <F as FusedFuture>::is_terminated(&**self)
     }
 }
 
-#[cfg(feature = "alloc")]
-mod if_alloc {
-    use alloc::boxed::Box;
-    use super::*;
-
-    impl<F: FusedFuture + ?Sized> FusedFuture for Box<F> {
-        fn is_terminated(&self) -> bool {
-            <F as FusedFuture>::is_terminated(&**self)
-        }
-    }
-
-    impl<F: FusedFuture + ?Sized> FusedFuture for Pin<Box<F>> {
-        fn is_terminated(&self) -> bool {
-            <F as FusedFuture>::is_terminated(&**self)
-        }
-    }
-
-    #[cfg(feature = "std")]
-    impl<F: FusedFuture> FusedFuture for std::panic::AssertUnwindSafe<F> {
-        fn is_terminated(&self) -> bool {
-            <F as FusedFuture>::is_terminated(&**self)
-        }
+impl<P> FusedFuture for Pin<P>
+where
+    P: DerefMut + Unpin,
+    P::Target: FusedFuture,
+{
+    fn is_terminated(&self) -> bool {
+        <P::Target as FusedFuture>::is_terminated(&**self)
     }
 }
 
@@ -79,7 +59,7 @@ pub trait TryFuture {
 }
 
 impl<F, T, E> TryFuture for F
-    where F: Future<Output = Result<T, E>>
+    where F: ?Sized + Future<Output = Result<T, E>>
 {
     type Ok = T;
     type Error = E;
@@ -89,3 +69,22 @@ impl<F, T, E> TryFuture for F
         self.poll(cx)
     }
 }
+
+#[cfg(feature = "alloc")]
+mod if_alloc {
+    use alloc::boxed::Box;
+    use super::*;
+
+    impl<F: FusedFuture + ?Sized> FusedFuture for Box<F> {
+        fn is_terminated(&self) -> bool {
+            <F as FusedFuture>::is_terminated(&**self)
+        }
+    }
+
+    #[cfg(feature = "std")]
+    impl<F: FusedFuture> FusedFuture for std::panic::AssertUnwindSafe<F> {
+        fn is_terminated(&self) -> bool {
+            <F as FusedFuture>::is_terminated(&**self)
+        }
+    }
+}

futures-core/src/stream/mod.rs

@@ -1,6 +1,6 @@
 //! Asynchronous streams.
 
-use core::ops;
+use core::ops::DerefMut;
 use core::pin::Pin;
 use core::task::{Context, Poll};
 
@@ -68,7 +68,7 @@ impl<S: ?Sized + Stream + Unpin> Stream for &mut S {
 
 impl<P> Stream for Pin<P>
 where
-    P: ops::DerefMut + Unpin,
+    P: DerefMut + Unpin,
     P::Target: Stream,
 {
     type Item = <P::Target as Stream>::Item;
@@ -94,6 +94,22 @@ pub trait FusedStream {
     fn is_terminated(&self) -> bool;
 }
 
+impl<F: ?Sized + FusedStream> FusedStream for &mut F {
+    fn is_terminated(&self) -> bool {
+        <F as FusedStream>::is_terminated(&**self)
+    }
+}
+
+impl<P> FusedStream for Pin<P>
+where
+    P: DerefMut + Unpin,
+    P::Target: FusedStream,
+{
+    fn is_terminated(&self) -> bool {
+        <P::Target as FusedStream>::is_terminated(&**self)
+    }
+}
+
 /// A convenience for streams that return `Result` values that includes
 /// a variety of adapters tailored to such futures.
 pub trait TryStream {
@@ -113,7 +129,7 @@ pub trait TryStream {
 }
 
 impl<S, T, E> TryStream for S
-    where S: Stream<Item = Result<T, E>>
+    where S: ?Sized + Stream<Item = Result<T, E>>
 {
     type Ok = T;
     type Error = E;
@@ -163,4 +179,10 @@ mod if_alloc {
             Poll::Ready(self.pop_front())
         }
     }
+
+    impl<S: ?Sized + FusedStream> FusedStream for Box<S> {
+        fn is_terminated(&self) -> bool {
+            <S as FusedStream>::is_terminated(&**self)
+        }
+    }
 }

futures-core/src/task/spawn.rs

@@ -78,6 +78,28 @@ impl SpawnError {
     }
 }
 
+impl<Sp: ?Sized + Spawn> Spawn for &mut Sp {
+    fn spawn_obj(&mut self, future: FutureObj<'static, ()>)
+    -> Result<(), SpawnError> {
+        Sp::spawn_obj(self, future)
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        Sp::status(self)
+    }
+}
+
+impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &mut Sp {
+    fn spawn_local_obj(&mut self, future: LocalFutureObj<'static, ()>)
+    -> Result<(), SpawnError> {
+        Sp::spawn_local_obj(self, future)
+    }
+
+    fn status_local(&self) -> Result<(), SpawnError> {
+        Sp::status_local(self)
+    }
+}
+
 #[cfg(feature = "alloc")]
 mod if_alloc {
     use alloc::boxed::Box;

futures-io/src/lib.rs

@@ -18,6 +18,7 @@ mod if_std {
     use std::boxed::Box;
     use std::cmp;
     use std::io as StdIo;
+    use std::ops::DerefMut;
     use std::pin::Pin;
     use std::ptr;
 
@@ -270,21 +271,25 @@ mod if_std {
         deref_async_read!();
     }
 
-    impl<T: ?Sized + AsyncRead> AsyncRead for Pin<&mut T> {
+    impl<P> AsyncRead for Pin<P>
+    where
+        P: DerefMut + Unpin,
+        P::Target: AsyncRead,
+    {
         unsafe fn initializer(&self) -> Initializer {
             (**self).initializer()
         }
 
-        fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8])
+        fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8])
             -> Poll<Result<usize>>
         {
-            T::poll_read((*self).as_mut(), cx, buf)
+            Pin::get_mut(self).as_mut().poll_read(cx, buf)
         }
 
-        fn poll_vectored_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
+        fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
             -> Poll<Result<usize>>
         {
-            T::poll_vectored_read((*self).as_mut(), cx, vec)
+            Pin::get_mut(self).as_mut().poll_vectored_read(cx, vec)
         }
     }
 
@@ -348,25 +353,29 @@ mod if_std {
         deref_async_write!();
     }
 
-    impl<T: ?Sized + AsyncWrite> AsyncWrite for Pin<&mut T> {
-        fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])
+    impl<P> AsyncWrite for Pin<P>
+    where
+        P: DerefMut + Unpin,
+        P::Target: AsyncWrite,
+    {
+        fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])
             -> Poll<Result<usize>>
         {
-            T::poll_write((*self).as_mut(), cx, buf)
+            Pin::get_mut(self).as_mut().poll_write(cx, buf)
         }
 
-        fn poll_vectored_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
+        fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
             -> Poll<Result<usize>>
         {
-            T::poll_vectored_write((*self).as_mut(), cx, vec)
+            Pin::get_mut(self).as_mut().poll_vectored_write(cx, vec)
         }
 
-        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-            T::poll_flush((*self).as_mut(), cx)
+        fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+            Pin::get_mut(self).as_mut().poll_flush(cx)
         }
 
-        fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-            T::poll_close((*self).as_mut(), cx)
+        fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+            Pin::get_mut(self).as_mut().poll_close(cx)
         }
     }
 

futures-sink/src/lib.rs

@@ -13,6 +13,7 @@
 extern crate alloc;
 
 use futures_core::task::{Context, Poll};
+use core::ops::DerefMut;
 use core::pin::Pin;
 
 /// A `Sink` is a value into which other values can be sent, asynchronously.
@@ -130,23 +131,27 @@ impl<S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &mut S {
     }
 }
 
-impl<S: ?Sized + Sink<Item>, Item> Sink<Item> for Pin<&mut S> {
-    type SinkError = S::SinkError;
+impl<P, Item> Sink<Item> for Pin<P>
+where
+    P: DerefMut + Unpin,
+    P::Target: Sink<Item>,
+{
+    type SinkError = <P::Target as Sink<Item>>::SinkError;
 
-    fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        S::poll_ready((*self).as_mut(), cx)
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
+        Pin::get_mut(self).as_mut().poll_ready(cx)
     }
 
-    fn start_send(mut self: Pin<&mut Self>, item: Item) -> Result<(), Self::SinkError> {
-        S::start_send((*self).as_mut(), item)
+    fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::SinkError> {
+        Pin::get_mut(self).as_mut().start_send(item)
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        S::poll_flush((*self).as_mut(), cx)
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
+        Pin::get_mut(self).as_mut().poll_flush(cx)
     }
 
-    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        S::poll_close((*self).as_mut(), cx)
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
+        Pin::get_mut(self).as_mut().poll_close(cx)
     }
 }
 

futures-util/src/try_future/mod.rs

@@ -62,7 +62,7 @@ pub use self::unwrap_or_else::UnwrapOrElse;
 mod try_chain;
 pub(crate) use self::try_chain::{TryChain, TryChainAction};
 
-impl<Fut: TryFuture> TryFutureExt for Fut {}
+impl<Fut: ?Sized + TryFuture> TryFutureExt for Fut {}
 
 /// Adapters specific to [`Result`]-returning futures
 pub trait TryFutureExt: TryFuture {

futures-util/src/try_stream/mod.rs

@@ -69,7 +69,7 @@ mod into_async_read;
 #[cfg(feature = "std")]
 pub use self::into_async_read::IntoAsyncRead;
 
-impl<S: TryStream> TryStreamExt for S {}
+impl<S: ?Sized + TryStream> TryStreamExt for S {}
 
 /// Adapters specific to `Result`-returning streams
 pub trait TryStreamExt: TryStream {