Extract contents of await module into submodules

Author: MajorBreakfast

futures-util/src/await/mod.rs

@@ -3,79 +3,22 @@
 //! This module contains a number of functions and combinators for working
 //! with `async`/`await` code.
 
-use futures_core::{task, Future, Poll};
+use futures_core::Future;
 use core::marker::Unpin;
-use core::mem::PinMut;
 
-#[doc(hidden)]
-pub fn assert_unpin<T: Future + Unpin>(_: &T) {}
-
-/// A macro which returns the result of polling a future once within the
-/// current `async` context.
-///
-/// This macro is only usable inside of `async` functions, closures, and blocks.
-#[macro_export]
-macro_rules! poll {
-    ($x:expr) => {
-        await!($crate::await::poll($x))
-    }
-}
-
-#[doc(hidden)]
-pub fn poll<F: Future + Unpin>(future: F) -> impl Future<Output = Poll<F::Output>> {
-    PollOnce { future }
-}
-
-#[allow(missing_debug_implementations)]
-struct PollOnce<F: Future + Unpin> {
-    future: F,
-}
-
-impl<F: Future + Unpin> Future for PollOnce<F> {
-    type Output = Poll<F::Output>;
-    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
-        Poll::Ready(PinMut::new(&mut self.future).poll(cx))
-    }
-}
+#[macro_use]
+mod poll;
+pub use self::poll::*;
 
-/// A macro which yields to the event loop once.
-/// This is similar to returning `Poll::Pending` from a `Future::poll` implementation.
-/// If `pending!` is used, the current task should be scheduled to receive a wakeup
-/// when it is ready to make progress.
-///
-/// This macro is only usable inside of `async` functions, closures, and blocks.
-#[macro_export]
-macro_rules! pending {
-    () => {
-        await!($crate::await::pending_once())
-    }
-}
-
-#[doc(hidden)]
-pub fn pending_once() -> impl Future<Output = ()> {
-    PendingOnce { is_ready: false }
-}
-
-#[allow(missing_debug_implementations)]
-struct PendingOnce {
-    is_ready: bool,
-}
-
-impl Future for PendingOnce {
-    type Output = ();
-    fn poll(mut self: PinMut<Self>, _: &mut task::Context) -> Poll<Self::Output> {
-        if self.is_ready {
-            Poll::Ready(())
-        } else {
-            self.is_ready = true;
-            Poll::Pending
-        }
-    }
-}
+#[macro_use]
+mod pending;
+pub use self::pending::*;
 
 // Primary export is a macro
 mod join;
 
 // Primary export is a macro
 mod select;
 
+#[doc(hidden)]
+pub fn assert_unpin<T: Future + Unpin>(_: &T) {}

futures-util/src/await/pending.rs

@@ -0,0 +1,37 @@
+use futures_core::{task, Future, Poll};
+use core::mem::PinMut;
+
+/// A macro which yields to the event loop once.
+/// This is similar to returning `Poll::Pending` from a `Future::poll` implementation.
+/// If `pending!` is used, the current task should be scheduled to receive a wakeup
+/// when it is ready to make progress.
+///
+/// This macro is only usable inside of `async` functions, closures, and blocks.
+#[macro_export]
+macro_rules! pending {
+    () => {
+        await!($crate::await::pending_once())
+    }
+}
+
+#[doc(hidden)]
+pub fn pending_once() -> PendingOnce {
+    PendingOnce { is_ready: false }
+}
+
+#[allow(missing_debug_implementations)]
+pub struct PendingOnce {
+    is_ready: bool,
+}
+
+impl Future for PendingOnce {
+    type Output = ();
+    fn poll(mut self: PinMut<Self>, _: &mut task::Context) -> Poll<Self::Output> {
+        if self.is_ready {
+            Poll::Ready(())
+        } else {
+            self.is_ready = true;
+            Poll::Pending
+        }
+    }
+}

futures-util/src/await/poll.rs

@@ -0,0 +1,31 @@
+use futures_core::{task, Future, Poll};
+use core::marker::Unpin;
+use core::mem::PinMut;
+
+/// A macro which returns the result of polling a future once within the
+/// current `async` context.
+///
+/// This macro is only usable inside of `async` functions, closures, and blocks.
+#[macro_export]
+macro_rules! poll {
+    ($x:expr) => {
+        await!($crate::await::poll($x))
+    }
+}
+
+#[doc(hidden)]
+pub fn poll<F: Future + Unpin>(future: F) -> PollOnce<F> {
+    PollOnce { future }
+}
+
+#[allow(missing_debug_implementations)]
+pub struct PollOnce<F: Future + Unpin> {
+    future: F,
+}
+
+impl<F: Future + Unpin> Future for PollOnce<F> {
+    type Output = Poll<F::Output>;
+    fn poll(mut self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
+        Poll::Ready(PinMut::new(&mut self.future).poll(cx))
+    }
+}