move the meat of futures-time underneath wstd::time

commenting out everything having to do with channels / park, temporarily
no more prelude
and tests are broken

Author: pchickey

Cargo.toml

@@ -15,7 +15,9 @@ authors = [
 [features]
 
 [dependencies]
+futures-core.workspace = true
 http.workspace = true
+pin-project-lite.workspace = true
 slab.workspace = true
 wasi.workspace = true
 wstd-macro.workspace = true
@@ -46,8 +48,10 @@ repository = "https://github.com/yoshuawuyts/wstd"
 [workspace.dependencies]
 anyhow = "1"
 cargo_metadata = "0.18.1"
+futures-core = "0.3.19"
 heck = "0.5"
 http = "1.1"
+pin-project-lite = "0.2.8"
 quote = "1.0"
 serde_json = "1"
 slab = "0.4.9"

futures-time/src/future/into_future.rs

@@ -1,12 +1,11 @@
-use crate::{
-    future::IntoFuture,
+use super::{
     stream::{Interval, IntoStream},
     task::Sleep,
+    Instant,
 };
-
+use std::future::IntoFuture;
 use std::ops::{Add, AddAssign, Sub, SubAssign};
-
-use super::Instant;
+use wasi::clocks::monotonic_clock;
 
 /// A Duration type to represent a span of time, typically used for system
 /// timeouts.
@@ -15,7 +14,7 @@ use super::Instant;
 /// without coherence issues, just like if we were implementing this in the
 /// stdlib.
 #[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Hash, Clone, Copy)]
-pub struct Duration(pub(crate) std::time::Duration);
+pub struct Duration(pub(crate) monotonic_clock::Duration);
 impl Duration {
     /// Creates a new `Duration` from the specified number of whole seconds and
     /// additional nanoseconds.
@@ -78,7 +77,7 @@ impl Duration {
 }
 
 impl std::ops::Deref for Duration {
-    type Target = std::time::Duration;
+    type Target = monotonic_clock::Duration;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -93,41 +92,46 @@ impl std::ops::DerefMut for Duration {
 
 impl From<std::time::Duration> for Duration {
     fn from(inner: std::time::Duration) -> Self {
-        Self(inner)
+        Self(
+            inner
+                .as_nanos()
+                .try_into()
+                .expect("only dealing with durations that can fit in u64"),
+        )
     }
 }
 
 impl Into<std::time::Duration> for Duration {
     fn into(self) -> std::time::Duration {
-        self.0
+        std::time::Duration::from_nanos(self.0)
     }
 }
 
 impl Add<Duration> for Duration {
     type Output = Self;
 
     fn add(self, rhs: Duration) -> Self::Output {
-        (self.0 + rhs.0).into()
+        Self(self.0 + rhs.0)
     }
 }
 
 impl AddAssign<Duration> for Duration {
     fn add_assign(&mut self, rhs: Duration) {
-        *self = (self.0 + rhs.0).into()
+        *self = Self(self.0 + rhs.0)
     }
 }
 
 impl Sub<Duration> for Duration {
     type Output = Self;
 
     fn sub(self, rhs: Duration) -> Self::Output {
-        (self.0 - rhs.0).into()
+        Self(self.0 - rhs.0)
     }
 }
 
 impl SubAssign<Duration> for Duration {
     fn sub_assign(&mut self, rhs: Duration) {
-        *self = (self.0 - rhs.0).into()
+        *self = Self(self.0 - rhs.0)
     }
 }
 
@@ -137,7 +141,7 @@ impl IntoFuture for Duration {
     type IntoFuture = Sleep;
 
     fn into_future(self) -> Self::IntoFuture {
-        crate::task::sleep(self)
+        super::task::sleep(self)
     }
 }
 
@@ -147,6 +151,6 @@ impl IntoStream for Duration {
     type IntoStream = Interval;
 
     fn into_stream(self) -> Self::IntoStream {
-        crate::stream::interval(self)
+        super::stream::interval(self)
     }
 }

futures-time/src/time/mod.rs

@@ -1,9 +1,9 @@
 use core::future::Future;
 
-use crate::channel::Parker;
-use crate::stream::IntoStream;
+//use crate::channel::Parker;
+//use crate::time::stream::IntoStream;
 
-use super::{Delay, IntoFuture, Park, Timeout};
+use super::{Delay, IntoFuture, Timeout};
 
 /// Extend `Future` with time-based operations.
 pub trait FutureExt: Future {
@@ -77,20 +77,21 @@ pub trait FutureExt: Future {
     {
         Delay::new(self, deadline.into_future())
     }
-
-    /// Suspend or resume execution of a future.
-    ///
-    /// When this method is called the execution of the future will be put into
-    /// a suspended state until the channel returns `Parker::Unpark` or the
-    /// channel's senders are dropped. The underlying future will not be polled
-    /// while the it is paused.
-    fn park<I>(self, interval: I) -> Park<Self, I::IntoStream>
-    where
-        Self: Sized,
-        I: IntoStream<Item = Parker>,
-    {
-        Park::new(self, interval.into_stream())
-    }
+    /* FIXME channels
+        /// Suspend or resume execution of a future.
+        ///
+        /// When this method is called the execution of the future will be put into
+        /// a suspended state until the channel returns `Parker::Unpark` or the
+        /// channel's senders are dropped. The underlying future will not be polled
+        /// while the it is paused.
+        fn park<I>(self, interval: I) -> Park<Self, I::IntoStream>
+        where
+            Self: Sized,
+            I: IntoStream<Item = Parker>,
+        {
+            Park::new(self, interval.into_stream())
+        }
+    */
 }
 
 impl<T> FutureExt for T where T: Future {}

futures-time/src/time/duration.rs renamed to src/time/duration.rs

@@ -41,14 +41,13 @@
 
 mod delay;
 mod future_ext;
-mod into_future;
-mod park;
+//mod park;
 mod relative_future;
 mod timeout;
 
 pub use delay::Delay;
 pub use future_ext::FutureExt;
-pub use into_future::IntoFuture;
-pub use park::Park;
+//pub use park::Park;
 pub use relative_future::Timer;
+pub use std::future::IntoFuture;
 pub use timeout::Timeout;

futures-time/src/future/delay.rs renamed to src/time/future/delay.rs

@@ -1,4 +1,4 @@
-use crate::utils::timeout_err;
+use crate::time::utils::timeout_err;
 
 use std::future::Future;
 use std::io;