name the timer wait() future explicitly, now thats how task::sleep, sleep_until work

Author: pchickey

src/runtime/mod.rs

@@ -14,7 +14,7 @@ mod block_on;
 mod reactor;
 
 pub use block_on::block_on;
-pub use reactor::{AsyncPollable, Reactor};
+pub use reactor::{AsyncPollable, Reactor, WaitFor};
 use std::cell::RefCell;
 
 // There are no threads in WASI 0.2, so this is just a safe way to thread a single reactor to all

src/task/mod.rs

@@ -3,5 +3,5 @@
 mod sleep;
 mod sleep_until;
 
-pub use sleep::{sleep, Sleep};
-pub use sleep_until::{sleep_until, SleepUntil};
+pub use sleep::sleep;
+pub use sleep_until::sleep_until;

src/task/sleep.rs

@@ -1,46 +1,8 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use crate::time::Timer as AsyncTimer;
-use pin_project_lite::pin_project;
-
-use crate::time::{Duration, Instant};
+use crate::time::{Duration, Timer, Wait};
 
 /// Sleeps for the specified amount of time.
 ///
 /// This future can be `push_deadline` to be moved
-pub fn sleep(dur: Duration) -> Sleep {
-    Sleep {
-        dur,
-        timer: AsyncTimer::after(dur.into()),
-        completed: false,
-    }
-}
-
-pin_project! {
-    /// Sleeps for the specified amount of time.
-    #[must_use = "futures do nothing unless polled or .awaited"]
-    pub struct Sleep {
-        #[pin]
-        timer: AsyncTimer,
-        completed: bool,
-        dur: Duration,
-    }
-}
-
-impl Future for Sleep {
-    type Output = Instant;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        assert!(!self.completed, "future polled after completing");
-        let this = self.project();
-        match this.timer.poll(cx) {
-            Poll::Ready(instant) => {
-                *this.completed = true;
-                Poll::Ready(instant.into())
-            }
-            Poll::Pending => Poll::Pending,
-        }
-    }
+pub fn sleep(dur: Duration) -> Wait {
+    Timer::after(dur).wait()
 }

src/task/sleep_until.rs

@@ -1,40 +1,6 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use crate::time::{Instant, Timer};
-use pin_project_lite::pin_project;
+use crate::time::{Instant, Timer, Wait};
 
 /// Sleeps until the specified instant.
-pub fn sleep_until(deadline: Instant) -> SleepUntil {
-    SleepUntil {
-        timer: Timer::at(deadline.into()),
-        completed: false,
-    }
-}
-
-pin_project! {
-    /// Sleeps until the specified instant.
-    #[must_use = "futures do nothing unless polled or .awaited"]
-    pub struct SleepUntil {
-        #[pin]
-        timer: Timer,
-        completed: bool,
-    }
-}
-
-impl Future for SleepUntil {
-    type Output = Instant;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        assert!(!self.completed, "future polled after completing");
-        let this = self.project();
-        match this.timer.poll(cx) {
-            Poll::Ready(instant) => {
-                *this.completed = true;
-                Poll::Ready(instant.into())
-            }
-            Poll::Pending => Poll::Pending,
-        }
-    }
+pub fn sleep_until(deadline: Instant) -> Wait {
+    Timer::at(deadline).wait()
 }

src/time/duration.rs

@@ -1,5 +1,4 @@
-use super::Instant;
-use crate::task::Sleep;
+use super::{Instant, Wait};
 use std::future::IntoFuture;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 use wasi::clocks::monotonic_clock;
@@ -135,7 +134,7 @@ impl SubAssign<Duration> for Duration {
 impl IntoFuture for Duration {
     type Output = Instant;
 
-    type IntoFuture = Sleep;
+    type IntoFuture = Wait;
 
     fn into_future(self) -> Self::IntoFuture {
         crate::task::sleep(self)

src/time/instant.rs

@@ -1,5 +1,4 @@
-use super::Duration;
-use crate::task::SleepUntil;
+use super::{Duration, Wait};
 use std::future::IntoFuture;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 use wasi::clocks::monotonic_clock;
@@ -85,7 +84,7 @@ impl std::ops::DerefMut for Instant {
 impl IntoFuture for Instant {
     type Output = Instant;
 
-    type IntoFuture = SleepUntil;
+    type IntoFuture = Wait;
 
     fn into_future(self) -> Self::IntoFuture {
         crate::task::sleep_until(self)

src/time/mod.rs

@@ -7,6 +7,7 @@ mod instant;
 pub use duration::Duration;
 pub use instant::Instant;
 
+use pin_project_lite::pin_project;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
@@ -48,7 +49,7 @@ impl AsyncIterator for Interval {
     type Item = Instant;
 
     async fn next(&mut self) -> Option<Self::Item> {
-        Some(Timer::after(self.duration).await)
+        Some(Timer::after(self.duration).wait().await)
     }
 }
 
@@ -70,21 +71,33 @@ impl Timer {
     pub fn set_after(&mut self, duration: Duration) {
         *self = Self::after(duration);
     }
-    pub async fn wait(&self) -> Instant {
-        match &self.0 {
-            Some(pollable) => pollable.wait_for().await,
-            None => std::future::pending().await,
-        }
-        Instant::now()
+    pub fn wait(&self) -> Wait {
+        let wait_for = self.0.as_ref().map(|pollable| pollable.wait_for());
+        Wait { wait_for }
+    }
+}
+
+pin_project! {
+    /// Future created by [`Timer::wait`]
+    #[must_use = "futures do nothing unless polled or .awaited"]
+    pub struct Wait {
+        #[pin]
+        wait_for: Option<crate::runtime::WaitFor>
     }
 }
 
-impl Future for Timer {
+impl Future for Wait {
     type Output = Instant;
+
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_ref();
-        let pinned = std::pin::pin!(this.wait());
-        pinned.poll(cx)
+        let this = self.project();
+        match this.wait_for.as_pin_mut() {
+            None => Poll::Pending,
+            Some(f) => match f.poll(cx) {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(()) => Poll::Ready(Instant::now()),
+            },
+        }
     }
 }
 
@@ -103,14 +116,14 @@ mod test {
     #[test]
     fn timer_now() {
         crate::runtime::block_on(debug_duration("timer_now", async {
-            Timer::at(Instant::now()).await
+            Timer::at(Instant::now()).wait().await
         }));
     }
 
     #[test]
     fn timer_after_100_milliseconds() {
         crate::runtime::block_on(debug_duration("timer_after_100_milliseconds", async {
-            Timer::after(Duration::from_millis(100)).await
+            Timer::after(Duration::from_millis(100)).wait().await
         }));
     }
 }