Fix rustdoc

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Author: Stjepan Glavina

src/future/future.rs

@@ -2,8 +2,10 @@ use crate::utils::extension_trait;
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "docs")] {
-        use crate::task::{Context, Poll};
         use std::pin::Pin;
+        use std::ops::{Deref, DerefMut};
+
+        use crate::task::{Context, Poll};
     }
 }
 
@@ -104,4 +106,40 @@ extension_trait! {
 
     pub trait FutureExt: std::future::Future {
     }
+
+    impl<F: Future + Unpin + ?Sized> Future for Box<F> {
+        type Output = F::Output;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            unreachable!("this impl only appears in the rendered docs")
+        }
+    }
+
+    impl<F: Future + Unpin + ?Sized> Future for &mut F {
+        type Output = F::Output;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            unreachable!("this impl only appears in the rendered docs")
+        }
+    }
+
+    impl<P> Future for Pin<P>
+    where
+        P: DerefMut + Unpin,
+        <P as Deref>::Target: Future,
+    {
+        type Output = <<P as Deref>::Target as Future>::Output;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            unreachable!("this impl only appears in the rendered docs")
+        }
+    }
+
+    impl<F: Future> Future for std::panic::AssertUnwindSafe<F> {
+        type Output = F::Output;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            unreachable!("this impl only appears in the rendered docs")
+        }
+    }
 }

src/task/blocking.rs

@@ -1,13 +1,13 @@
 //! A thread pool for running blocking functions asynchronously.
 
+use std::future::Future;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::thread;
 use std::time::Duration;
 
 use crossbeam_channel::{bounded, Receiver, Sender};
 use lazy_static::lazy_static;
 
-use crate::future::Future;
 use crate::task::task::{JoinHandle, Tag};
 use crate::utils::abort_on_panic;
 

src/task/task.rs

@@ -1,4 +1,5 @@
 use std::fmt;
+use std::future::Future;
 use std::i64;
 use std::mem;
 use std::num::NonZeroU64;
@@ -7,7 +8,6 @@ use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
 use std::sync::Arc;
 
 use super::task_local;
-use crate::future::Future;
 use crate::task::{Context, Poll};
 
 /// A handle to a task.

src/task/task_local.rs

@@ -1,13 +1,13 @@
 use std::cell::UnsafeCell;
 use std::error::Error;
 use std::fmt;
+use std::future::Future;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Mutex;
 
 use lazy_static::lazy_static;
 
 use super::worker;
-use crate::future::Future;
 use crate::utils::abort_on_panic;
 
 /// Declares task-local values.

src/utils.rs

@@ -20,7 +20,7 @@ pub fn abort_on_panic<T>(f: impl FnOnce() -> T) -> T {
     t
 }
 
-/// Defines an extension trait for a base trait from the `futures` crate.
+/// Defines an extension trait for a base trait.
 ///
 /// In generated docs, the base trait will contain methods from the extension trait. In actual
 /// code, the base trait will be re-exported and the extension trait will be hidden. We then
@@ -35,7 +35,7 @@ macro_rules! extension_trait {
         // Interesting patterns:
         // - `$name`: trait name that gets rendered in the docs
         // - `$ext`: name of the hidden extension trait
-        // - `$base`: base trait from the `futures` crate
+        // - `$base`: base trait
         #[doc = $doc:tt]
         pub trait $name:ident {
             $($body_base:tt)*
@@ -87,13 +87,21 @@ macro_rules! extension_trait {
     };
 
     // Parse the return type in an extension method.
-    (@doc ($($head:tt)*) -> impl Future<Output = $out:ty> $(+ $lt:lifetime)? [$f:ty] $($tail:tt)*) => {
-        extension_trait!(@doc ($($head)* -> borrowed::ImplFuture<$($lt,)? $out>) $($tail)*);
+    (@doc ($($head:tt)*) -> impl Future<Output = $out:ty> [$f:ty] $($tail:tt)*) => {
+        extension_trait!(@doc ($($head)* -> owned::ImplFuture<$out>) $($tail)*);
     };
     (@ext ($($head:tt)*) -> impl Future<Output = $out:ty> $(+ $lt:lifetime)? [$f:ty] $($tail:tt)*) => {
         extension_trait!(@ext ($($head)* -> $f) $($tail)*);
     };
 
+    // Parse the return type in an extension method.
+    (@doc ($($head:tt)*) -> impl Future<Output = $out:ty> + $lt:lifetime [$f:ty] $($tail:tt)*) => {
+        extension_trait!(@doc ($($head)* -> borrowed::ImplFuture<$lt, $out>) $($tail)*);
+    };
+    (@ext ($($head:tt)*) -> impl Future<Output = $out:ty> + $lt:lifetime [$f:ty] $($tail:tt)*) => {
+        extension_trait!(@ext ($($head)* -> $f) $($tail)*);
+    };
+
     // Parse a token.
     (@doc ($($head:tt)*) $token:tt $($tail:tt)*) => {
         extension_trait!(@doc ($($head)* $token) $($tail)*);