Upgrade rust/crates/futures-util to 0.3.13 am: 1fdff8fd4c am: cf1d92ef03 am: ac32bfb85d

Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/futures-util/+/1662922

Change-Id: I2ae408bfa218468323fecc75cab01c06ba6c8b8b

20 files changed, 126 insertions, 53 deletions

diff --git a/src/future/abortable.rs b/src/future/abortable.rs
index 1fc75b0..3f2e5a0 100644
--- a/src/future/abortable.rs
+++ b/src/future/abortable.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use crate::task::AtomicWaker;
 use futures_core::future::Future;
 use futures_core::task::{Context, Poll};
@@ -39,10 +40,10 @@ impl<Fut> Abortable<Fut> where Fut: Future {
     /// # });
     /// ```
     pub fn new(future: Fut, reg: AbortRegistration) -> Self {
-        Self {
+        assert_future::<Result<Fut::Output, Aborted>, _>(Self {
             future,
             inner: reg.inner,
-        }
+        })
     }
 }
 
diff --git a/src/future/either.rs b/src/future/either.rs
index a1b9f0a..5f5b614 100644
--- a/src/future/either.rs
+++ b/src/future/either.rs
@@ -101,6 +101,13 @@ where
             Either::Right(x) => x.poll_next(cx),
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            Either::Left(x) => x.size_hint(),
+            Either::Right(x) => x.size_hint(),
+        }
+    }
 }
 
 impl<A, B> FusedStream for Either<A, B>
diff --git a/src/future/future/mod.rs b/src/future/future/mod.rs
index f01d346..c11d108 100644
--- a/src/future/future/mod.rs
+++ b/src/future/future/mod.rs
@@ -7,10 +7,10 @@
 use alloc::boxed::Box;
 use core::pin::Pin;
 
-use crate::future::{assert_future, Either};
-use crate::stream::assert_stream;
 use crate::fns::{inspect_fn, into_fn, ok_fn, InspectFn, IntoFn, OkFn};
+use crate::future::{assert_future, Either};
 use crate::never::Never;
+use crate::stream::assert_stream;
 #[cfg(feature = "alloc")]
 use futures_core::future::{BoxFuture, LocalBoxFuture};
 use futures_core::{
@@ -506,7 +506,8 @@ pub trait FutureExt: Future {
     where
         Self: Sized,
     {
-        remote_handle::remote_handle(self)
+        let (wrapped, handle) = remote_handle::remote_handle(self);
+        (assert_future::<(), _>(wrapped), handle)
     }
 
     /// Wrap the future in a Box, pinning it.
diff --git a/src/future/future/shared.rs b/src/future/future/shared.rs
index 53635b5..74311a0 100644
--- a/src/future/future/shared.rs
+++ b/src/future/future/shared.rs
@@ -126,6 +126,32 @@ where
         }
         None
     }
+
+    /// Gets the number of strong pointers to this allocation.
+    ///
+    /// Returns [`None`] if it has already been polled to completion.
+    ///
+    /// # Safety
+    ///
+    /// This method by itself is safe, but using it correctly requires extra care. Another thread
+    /// can change the strong count at any time, including potentially between calling this method
+    /// and acting on the result.
+    pub fn strong_count(&self) -> Option<usize> {
+        self.inner.as_ref().map(|arc| Arc::strong_count(arc))
+    }
+
+    /// Gets the number of weak pointers to this allocation.
+    ///
+    /// Returns [`None`] if it has already been polled to completion.
+    ///
+    /// # Safety
+    ///
+    /// This method by itself is safe, but using it correctly requires extra care. Another thread
+    /// can change the weak count at any time, including potentially between calling this method
+    /// and acting on the result.
+    pub fn weak_count(&self) -> Option<usize> {
+        self.inner.as_ref().map(|arc| Arc::weak_count(arc))
+    }
 }
 
 impl<Fut> Inner<Fut>
@@ -287,10 +313,8 @@ where
         // Wake all tasks and drop the slab
         let mut wakers_guard = inner.notifier.wakers.lock().unwrap();
         let mut wakers = wakers_guard.take().unwrap();
-        for opt_waker in wakers.drain() {
-            if let Some(waker) = opt_waker {
-                waker.wake();
-            }
+        for waker in wakers.drain().flatten() {
+            waker.wake();
         }
 
         drop(_reset); // Make borrow checker happy
diff --git a/src/future/join.rs b/src/future/join.rs
index cfe53a7..a818343 100644
--- a/src/future/join.rs
+++ b/src/future/join.rs
@@ -1,14 +1,13 @@
 #![allow(non_snake_case)]
 
-use crate::future::{MaybeDone, maybe_done};
+use super::assert_future;
+use crate::future::{maybe_done, MaybeDone};
 use core::fmt;
 use core::pin::Pin;
-use futures_core::future::{Future, FusedFuture};
+use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
 use pin_project_lite::pin_project;
 
-use super::assert_future;
-
 macro_rules! generate {
     ($(
         $(#[$doc:meta])*
@@ -144,7 +143,8 @@ where
     Fut2: Future,
     Fut3: Future,
 {
-    Join3::new(future1, future2, future3)
+    let f = Join3::new(future1, future2, future3);
+    assert_future::<(Fut1::Output, Fut2::Output, Fut3::Output), _>(f)
 }
 
 /// Same as [`join`](join()), but with more futures.
@@ -176,7 +176,8 @@ where
     Fut3: Future,
     Fut4: Future,
 {
-    Join4::new(future1, future2, future3, future4)
+    let f = Join4::new(future1, future2, future3, future4);
+    assert_future::<(Fut1::Output, Fut2::Output, Fut3::Output, Fut4::Output), _>(f)
 }
 
 /// Same as [`join`](join()), but with more futures.
@@ -211,5 +212,15 @@ where
     Fut4: Future,
     Fut5: Future,
 {
-    Join5::new(future1, future2, future3, future4, future5)
+    let f = Join5::new(future1, future2, future3, future4, future5);
+    assert_future::<
+        (
+            Fut1::Output,
+            Fut2::Output,
+            Fut3::Output,
+            Fut4::Output,
+            Fut5::Output,
+        ),
+        _,
+    >(f)
 }
diff --git a/src/future/join_all.rs b/src/future/join_all.rs
index 0c8357c..7ccf869 100644
--- a/src/future/join_all.rs
+++ b/src/future/join_all.rs
@@ -10,7 +10,7 @@ use core::task::{Context, Poll};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 
-use super::MaybeDone;
+use super::{MaybeDone, assert_future};
 
 fn iter_pin_mut<T>(slice: Pin<&mut [T]>) -> impl Iterator<Item = Pin<&mut T>> {
     // Safety: `std` _could_ make this unsound if it were to decide Pin's
@@ -85,7 +85,7 @@ where
     I::Item: Future,
 {
     let elems: Box<[_]> = i.into_iter().map(MaybeDone::Future).collect();
-    JoinAll { elems: elems.into() }
+    assert_future::<Vec<<I::Item as Future>::Output>, _>(JoinAll { elems: elems.into() })
 }
 
 impl<F> Future for JoinAll<F>
diff --git a/src/future/lazy.rs b/src/future/lazy.rs
index 409717a..42812d3 100644
--- a/src/future/lazy.rs
+++ b/src/future/lazy.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
@@ -34,7 +35,7 @@ impl<F> Unpin for Lazy<F> {}
 pub fn lazy<F, R>(f: F) -> Lazy<F>
     where F: FnOnce(&mut Context<'_>) -> R,
 {
-    Lazy { f: Some(f) }
+    assert_future::<R, _>(Lazy { f: Some(f) })
 }
 
 impl<F, R> FusedFuture for Lazy<F>
diff --git a/src/future/maybe_done.rs b/src/future/maybe_done.rs
index bb5579e..26e6c27 100644
--- a/src/future/maybe_done.rs
+++ b/src/future/maybe_done.rs
@@ -1,5 +1,6 @@
 //! Definition of the MaybeDone combinator
 
+use super::assert_future;
 use core::mem;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
@@ -40,7 +41,7 @@ impl<Fut: Future + Unpin> Unpin for MaybeDone<Fut> {}
 /// # });
 /// ```
 pub fn maybe_done<Fut: Future>(future: Fut) -> MaybeDone<Fut> {
-    MaybeDone::Future(future)
+    assert_future::<(), _>(MaybeDone::Future(future))
 }
 
 impl<Fut: Future> MaybeDone<Fut> {
diff --git a/src/future/mod.rs b/src/future/mod.rs
index ab29823..84e457c 100644
--- a/src/future/mod.rs
+++ b/src/future/mod.rs
@@ -9,9 +9,12 @@
 //!   from a closure that defines its return value, and [`ready`](ready()),
 //!   which constructs a future with an immediate defined value.
 
+#[doc(no_inline)]
+pub use core::future::Future;
+
 #[cfg(feature = "alloc")]
 pub use futures_core::future::{BoxFuture, LocalBoxFuture};
-pub use futures_core::future::{FusedFuture, Future, TryFuture};
+pub use futures_core::future::{FusedFuture, TryFuture};
 pub use futures_task::{FutureObj, LocalFutureObj, UnsafeFutureObj};
 
 // Extension traits and combinators
diff --git a/src/future/pending.rs b/src/future/pending.rs
index 5a7bbb8..4311b9a 100644
--- a/src/future/pending.rs
+++ b/src/future/pending.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use core::marker;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
@@ -33,9 +34,9 @@ impl<T> FusedFuture for Pending<T> {
 /// # });
 /// ```
 pub fn pending<T>() -> Pending<T> {
-    Pending {
+    assert_future::<T, _>(Pending {
         _data: marker::PhantomData,
-    }
+    })
 }
 
 impl<T> Future for Pending<T> {
diff --git a/src/future/poll_fn.rs b/src/future/poll_fn.rs
index b7b10be..6ac1ab8 100644
--- a/src/future/poll_fn.rs
+++ b/src/future/poll_fn.rs
@@ -1,5 +1,6 @@
 //! Definition of the `PollFn` adapter combinator
 
+use super::assert_future;
 use core::fmt;
 use core::pin::Pin;
 use futures_core::future::Future;
@@ -36,7 +37,7 @@ pub fn poll_fn<T, F>(f: F) -> PollFn<F>
 where
     F: FnMut(&mut Context<'_>) -> Poll<T>
 {
-    PollFn { f }
+    assert_future::<T, _>(PollFn { f })
 }
 
 impl<F> fmt::Debug for PollFn<F> {
diff --git a/src/future/ready.rs b/src/future/ready.rs
index 35f01c9..e3d791b 100644
--- a/src/future/ready.rs
+++ b/src/future/ready.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future};
 use futures_core::task::{Context, Poll};
@@ -45,7 +46,7 @@ impl<T> Future for Ready<T> {
 /// # });
 /// ```
 pub fn ready<T>(t: T) -> Ready<T> {
-    Ready(Some(t))
+    assert_future::<T, _>(Ready(Some(t)))
 }
 
 /// Create a future that is immediately ready with a success value.
diff --git a/src/future/select.rs b/src/future/select.rs
index bc24779..043ed17 100644
--- a/src/future/select.rs
+++ b/src/future/select.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use core::pin::Pin;
 use futures_core::future::{Future, FusedFuture};
 use futures_core::task::{Context, Poll};
@@ -31,25 +32,33 @@ impl<A: Unpin, B: Unpin> Unpin for Select<A, B> {}
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::future::{self, Either};
-/// use futures::pin_mut;
-///
-/// // These two futures have different types even though their outputs have the same type
-/// let future1 = async { 1 };
-/// let future2 = async { 2 };
+/// use futures::{
+///     pin_mut,
+///     future::Either,
+///     future::self,
+/// };
+/// 
+/// // These two futures have different types even though their outputs have the same type.
+/// let future1 = async {
+///     future::pending::<()>().await; // will never finish
+///     1
+/// };
+/// let future2 = async { 
+///     future::ready(2).await
+/// };
 ///
 /// // 'select' requires Future + Unpin bounds
 /// pin_mut!(future1);
 /// pin_mut!(future2);
 ///
 /// let value = match future::select(future1, future2).await {
-///     Either::Left((value1, _)) => value1, // `value1` is resolved from `future1`
-///                                          // `_` represents `future2`
+///     Either::Left((value1, _)) => value1,  // `value1` is resolved from `future1`
+///                                           // `_` represents `future2`
 ///     Either::Right((value2, _)) => value2, // `value2` is resolved from `future2`
 ///                                           // `_` represents `future1`
 /// };
 ///
-/// assert!(value == 1 || value == 2);
+/// assert!(value == 2);
 /// # });
 /// ```
 ///
@@ -75,7 +84,7 @@ impl<A: Unpin, B: Unpin> Unpin for Select<A, B> {}
 pub fn select<A, B>(future1: A, future2: B) -> Select<A, B>
     where A: Future + Unpin, B: Future + Unpin
 {
-    Select { inner: Some((future1, future2)) }
+    assert_future::<Either<(A::Output, B), (B::Output, A)>, _>(Select { inner: Some((future1, future2)) })
 }
 
 impl<A, B> Future for Select<A, B>
diff --git a/src/future/select_all.rs b/src/future/select_all.rs
index 9f7fb24..0db90a7 100644
--- a/src/future/select_all.rs
+++ b/src/future/select_all.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use crate::future::FutureExt;
 use core::iter::FromIterator;
 use core::mem;
@@ -38,7 +39,7 @@ pub fn select_all<I>(iter: I) -> SelectAll<I::Item>
         inner: iter.into_iter().collect()
     };
     assert!(!ret.inner.is_empty());
-    ret
+    assert_future::<(<I::Item as Future>::Output, usize, Vec<I::Item>), _>(ret)
 }
 
 impl<Fut: Future + Unpin> Future for SelectAll<Fut> {
diff --git a/src/future/select_ok.rs b/src/future/select_ok.rs
index 7f4f4d6..52d393c 100644
--- a/src/future/select_ok.rs
+++ b/src/future/select_ok.rs
@@ -1,3 +1,4 @@
+use super::assert_future;
 use crate::future::TryFutureExt;
 use core::iter::FromIterator;
 use core::mem;
@@ -36,7 +37,7 @@ pub fn select_ok<I>(iter: I) -> SelectOk<I::Item>
         inner: iter.into_iter().collect()
     };
     assert!(!ret.inner.is_empty(), "iterator provided to select_ok was empty");
-    ret
+    assert_future::<Result<(<I::Item as TryFuture>::Ok, Vec<I::Item>), <I::Item as TryFuture>::Error>, _>(ret)
 }
 
 impl<Fut: TryFuture + Unpin> Future for SelectOk<Fut> {
diff --git a/src/future/try_future/mod.rs b/src/future/try_future/mod.rs
index 1ce01d2..fb3bdd8 100644
--- a/src/future/try_future/mod.rs
+++ b/src/future/try_future/mod.rs
@@ -173,7 +173,7 @@ pub trait TryFutureExt: TryFuture {
         Self::Ok: Sink<Item, Error = Self::Error>,
         Self: Sized,
     {
-        FlattenSink::new(self)
+        crate::sink::assert_sink::<Item, Self::Error, _>(FlattenSink::new(self))
     }
 
     /// Maps this future's success value to a different value.
@@ -501,7 +501,7 @@ pub trait TryFutureExt: TryFuture {
         Self::Ok: TryFuture<Error = Self::Error>,
         Self: Sized,
     {
-        TryFlatten::new(self)
+        assert_future::<Result<<Self::Ok as TryFuture>::Ok, Self::Error>, _>(TryFlatten::new(self))
     }
 
     /// Flatten the execution of this future when the successful result of this
@@ -539,7 +539,7 @@ pub trait TryFutureExt: TryFuture {
         ))
     }
 
-    /// Unwraps this future's ouput, producing a future with this future's
+    /// Unwraps this future's output, producing a future with this future's
     /// [`Ok`](TryFuture::Ok) type as its
     /// [`Output`](std::future::Future::Output) type.
     ///
@@ -569,8 +569,8 @@ pub trait TryFutureExt: TryFuture {
         assert_future::<Self::Ok, _>(UnwrapOrElse::new(self, f))
     }
 
-    /// Wraps a [`TryFuture`] into a future compatable with libraries using
-    /// futures 0.1 future definitons. Requires the `compat` feature to enable.
+    /// Wraps a [`TryFuture`] into a future compatible with libraries using
+    /// futures 0.1 future definitions. Requires the `compat` feature to enable.
     #[cfg(feature = "compat")]
     #[cfg_attr(docsrs, doc(cfg(feature = "compat")))]
     fn compat(self) -> Compat<Self>
diff --git a/src/future/try_join.rs b/src/future/try_join.rs
index 25ccdde..6af1f0c 100644
--- a/src/future/try_join.rs
+++ b/src/future/try_join.rs
@@ -1,6 +1,6 @@
 #![allow(non_snake_case)]
 
-use crate::future::{TryMaybeDone, try_maybe_done};
+use crate::future::{assert_future, try_maybe_done, TryMaybeDone};
 use core::fmt;
 use core::pin::Pin;
 use futures_core::future::{Future, TryFuture};
@@ -108,7 +108,7 @@ generate! {
 ///
 /// This function will return a new future which awaits both futures to
 /// complete. If successful, the returned future will finish with a tuple of
-/// both results. If unsuccesful, it will complete with the first error
+/// both results. If unsuccessful, it will complete with the first error
 /// encountered.
 ///
 /// Note that this function consumes the passed futures and returns a
@@ -150,7 +150,7 @@ where
     Fut1: TryFuture,
     Fut2: TryFuture<Error = Fut1::Error>,
 {
-    TryJoin::new(future1, future2)
+    assert_future::<Result<(Fut1::Ok, Fut2::Ok), Fut1::Error>, _>(TryJoin::new(future1, future2))
 }
 
 /// Same as [`try_join`](try_join()), but with more futures.
@@ -179,7 +179,9 @@ where
     Fut2: TryFuture<Error = Fut1::Error>,
     Fut3: TryFuture<Error = Fut1::Error>,
 {
-    TryJoin3::new(future1, future2, future3)
+    assert_future::<Result<(Fut1::Ok, Fut2::Ok, Fut3::Ok), Fut1::Error>, _>(TryJoin3::new(
+        future1, future2, future3,
+    ))
 }
 
 /// Same as [`try_join`](try_join()), but with more futures.
@@ -211,7 +213,9 @@ where
     Fut3: TryFuture<Error = Fut1::Error>,
     Fut4: TryFuture<Error = Fut1::Error>,
 {
-    TryJoin4::new(future1, future2, future3, future4)
+    assert_future::<Result<(Fut1::Ok, Fut2::Ok, Fut3::Ok, Fut4::Ok), Fut1::Error>, _>(
+        TryJoin4::new(future1, future2, future3, future4),
+    )
 }
 
 /// Same as [`try_join`](try_join()), but with more futures.
@@ -246,5 +250,7 @@ where
     Fut4: TryFuture<Error = Fut1::Error>,
     Fut5: TryFuture<Error = Fut1::Error>,
 {
-    TryJoin5::new(future1, future2, future3, future4, future5)
+    assert_future::<Result<(Fut1::Ok, Fut2::Ok, Fut3::Ok, Fut4::Ok, Fut5::Ok), Fut1::Error>, _>(
+        TryJoin5::new(future1, future2, future3, future4, future5),
+    )
 }
diff --git a/src/future/try_join_all.rs b/src/future/try_join_all.rs
index 4de0a79..371f753 100644
--- a/src/future/try_join_all.rs
+++ b/src/future/try_join_all.rs
@@ -10,7 +10,7 @@ use core::task::{Context, Poll};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 
-use super::{TryFuture, TryMaybeDone};
+use super::{assert_future, TryFuture, TryMaybeDone};
 
 fn iter_pin_mut<T>(slice: Pin<&mut [T]>) -> impl Iterator<Item = Pin<&mut T>> {
     // Safety: `std` _could_ make this unsound if it were to decide Pin's
@@ -93,9 +93,9 @@ where
     I::Item: TryFuture,
 {
     let elems: Box<[_]> = i.into_iter().map(TryMaybeDone::Future).collect();
-    TryJoinAll {
+    assert_future::<Result<Vec<<I::Item as TryFuture>::Ok>, <I::Item as TryFuture>::Error>, _>(TryJoinAll {
         elems: elems.into(),
-    }
+    })
 }
 
 impl<F> Future for TryJoinAll<F>
diff --git a/src/future/try_maybe_done.rs b/src/future/try_maybe_done.rs
index 90067e9..dfd2900 100644
--- a/src/future/try_maybe_done.rs
+++ b/src/future/try_maybe_done.rs
@@ -1,5 +1,6 @@
 //! Definition of the TryMaybeDone combinator
 
+use super::assert_future;
 use core::mem;
 use core::pin::Pin;
 use futures_core::future::{FusedFuture, Future, TryFuture};
@@ -25,7 +26,7 @@ impl<Fut: TryFuture + Unpin> Unpin for TryMaybeDone<Fut> {}
 
 /// Wraps a future into a `TryMaybeDone`
 pub fn try_maybe_done<Fut: TryFuture>(future: Fut) -> TryMaybeDone<Fut> {
-    TryMaybeDone::Future(future)
+    assert_future::<Result<(), Fut::Error>, _>(TryMaybeDone::Future(future))
 }
 
 impl<Fut: TryFuture> TryMaybeDone<Fut> {
diff --git a/src/future/try_select.rs b/src/future/try_select.rs
index 56564f5..b26eed3 100644
--- a/src/future/try_select.rs
+++ b/src/future/try_select.rs
@@ -50,7 +50,10 @@ impl<A: Unpin, B: Unpin> Unpin for TrySelect<A, B> {}
 pub fn try_select<A, B>(future1: A, future2: B) -> TrySelect<A, B>
     where A: TryFuture + Unpin, B: TryFuture + Unpin
 {
-    TrySelect { inner: Some((future1, future2)) }
+    super::assert_future::<Result<
+        Either<(A::Ok, B), (B::Ok, A)>,
+        Either<(A::Error, B), (B::Error, A)>,
+    >, _>(TrySelect { inner: Some((future1, future2)) })
 }
 
 impl<A: Unpin, B: Unpin> Future for TrySelect<A, B>