undo migration changes

yoshuawuyts · yoshuawuyts · commit 0da08c43a58f · 2026-04-08T17:39:24.000+02:00
diff --git a/src/future.rs b/src/future.rs
@@ -53,13 +53,13 @@ pin_project! {
         future: F,
         #[pin]
         deadline: D,
-        state: DelayState,
+        state: State,
     }
 }
 
 /// The internal state
 #[derive(Debug)]
-enum DelayState {
+enum State {
     Started,
     PollFuture,
     Completed,
@@ -70,7 +70,7 @@ impl<F, D> Delay<F, D> {
         Self {
             future,
             deadline,
-            state: DelayState::Started,
+            state: State::Started,
         }
     }
 }
@@ -82,16 +82,16 @@ impl<F: Future, D: Future> Future for Delay<F, D> {
         let mut this = self.project();
         loop {
             match this.state {
-                DelayState::Started => {
+                State::Started => {
                     ready!(this.deadline.as_mut().poll(cx));
-                    *this.state = DelayState::PollFuture;
+                    *this.state = State::PollFuture;
                 }
-                DelayState::PollFuture => {
+                State::PollFuture => {
                     let value = ready!(this.future.as_mut().poll(cx));
-                    *this.state = DelayState::Completed;
+                    *this.state = State::Completed;
                     return Poll::Ready(value);
                 }
-                DelayState::Completed => panic!("future polled after completing"),
+                State::Completed => panic!("future polled after completing"),
             }
         }
     }
diff --git a/src/sys/p2/http/request.rs b/src/sys/p2/http/request.rs
@@ -12,6 +12,8 @@ use wasip2::http::types::IncomingRequest;
 
 pub use http::request::{Builder, Request};
 
+// TODO: go back and add json stuff???
+
 pub(crate) fn try_into_outgoing<T>(request: Request<T>) -> Result<(OutgoingRequest, T), Error> {
     let wasi_req = OutgoingRequest::new(header_map_to_wasi(request.headers())?);
 
diff --git a/src/sys/p2/http/response.rs b/src/sys/p2/http/response.rs
@@ -21,6 +21,15 @@ pub(crate) fn try_from_incoming(incoming: IncomingResponse) -> Result<Response<B
         .expect("cannot call `consume` twice on incoming response");
     let body = Body::from_incoming(incoming_body, hint);
 
+    // The [`http::response::Builder`] keeps internal state of whether the
+    // builder has errored, which is only reachable by passing
+    // [`Builder::header`] an erroring `TryInto<HeaderName>` or
+    // `TryInto<HeaderValue>`. Since the `Builder::header` method is never
+    // used, we know `Builder::headers_mut` will never give the None case, nor
+    // will `Builder::body` give the error case. So, rather than treat those
+    // as control flow, we unwrap if this invariant is ever broken because
+    // that would only be possible due to some unrecoverable bug in wstd,
+    // rather than incorrect use or invalid input.
     let mut builder = Response::builder().status(status);
     *builder.headers_mut().expect("builder has not errored") = headers;
     Ok(builder
diff --git a/src/sys/p2/http/server.rs b/src/sys/p2/http/server.rs
@@ -1,3 +1,23 @@
+//! HTTP servers
+//!
+//! The WASI HTTP server uses the [typed main] idiom, with a `main` function
+//! that takes a [`Request`] and succeeds with a [`Response`], using the
+//! [`http_server`] macro:
+//!
+//! ```no_run
+//! use wstd::http::{Request, Response, Body, Error};
+//! #[wstd::http_server]
+//! async fn main(_request: Request<Body>) -> Result<Response<Body>, Error> {
+//!     Ok(Response::new("Hello!\n".into()))
+//! }
+//! ```
+//!
+//! [typed main]: https://sunfishcode.github.io/typed-main-wasi-presentation/chapter_1.html
+//! [`Request`]: crate::http::Request
+//! [`Responder`]: crate::http::server::Responder
+//! [`Response`]: crate::http::Response
+//! [`http_server`]: crate::http_server
+
 use crate::http::{Body, Error, Response, error::ErrorCode};
 use super::fields::header_map_to_wasi;
 use http::header::CONTENT_LENGTH;
diff --git a/src/sys/p2/io.rs b/src/sys/p2/io.rs
@@ -26,7 +26,7 @@ impl AsyncInputStream {
             stream,
         }
     }
-    pub(crate) fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<()> {
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<()> {
         // Lazily initialize the AsyncPollable
         let subscription = self
             .subscription
@@ -43,7 +43,7 @@ impl AsyncInputStream {
         }
     }
     /// Await for read readiness.
-    pub(crate) async fn ready(&self) {
+    async fn ready(&self) {
         poll_fn(|cx| self.poll_ready(cx)).await
     }
     /// Asynchronously read from the input stream.
@@ -233,7 +233,7 @@ impl AsyncOutputStream {
         }
     }
     /// Await write readiness.
-    pub(crate) async fn ready(&self) {
+    async fn ready(&self) {
         // Lazily initialize the AsyncPollable
         let subscription = self
             .subscription
diff --git a/src/sys/p2/net/mod.rs b/src/sys/p2/net/mod.rs
@@ -1,3 +1,5 @@
+//! Async network abstractions.
+
 use std::io::{self, ErrorKind};
 use wasip2::sockets::network::ErrorCode;
 
@@ -7,7 +9,7 @@ mod tcp_stream;
 pub use tcp_listener::*;
 pub use tcp_stream::*;
 
-pub(crate) fn to_io_err(err: ErrorCode) -> io::Error {
+fn to_io_err(err: ErrorCode) -> io::Error {
     match err {
         ErrorCode::Unknown => ErrorKind::Other.into(),
         ErrorCode::AccessDenied => ErrorKind::PermissionDenied.into(),
diff --git a/src/sys/p2/random.rs b/src/sys/p2/random.rs
@@ -1,3 +1,5 @@
+//! Random number generation.
+
 use wasip2::random;
 
 /// Fill the slice with cryptographically secure random bytes.
diff --git a/src/sys/p2/runtime/mod.rs b/src/sys/p2/runtime/mod.rs
@@ -14,7 +14,7 @@ use std::future::Future;
 use std::pin::pin;
 use std::task::{Context, Poll, Waker};
 
-/// Start the event loop. Blocks until the future completes.
+/// Start the event loop. Blocks until the future
 pub fn block_on<F>(fut: F) -> F::Output
 where
     F: Future,
diff --git a/src/sys/p2/time.rs b/src/sys/p2/time.rs
@@ -17,8 +17,11 @@ pub fn now() -> MonotonicInstant {
     monotonic_clock::now()
 }
 
-/// A measurement of the system clock.
+/// A measurement of the system clock, useful for talking to external entities
+/// like the file system or other processes. May be converted losslessly to a
+/// more useful `std::time::SystemTime` to provide more methods.
 #[derive(Debug, Clone, Copy)]
+#[allow(dead_code)]
 pub struct SystemTime(wall_clock::Datetime);
 
 impl SystemTime {

Original file line number	Diff line number	Diff line change
`@@ -53,13 +53,13 @@ pin_project! {`
`53`	`53`	`future: F,`
`54`	`54`	`#[pin]`
`55`	`55`	`deadline: D,`
`56`		`- state: DelayState,`
	`56`	`+ state: State,`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/// The internal state`
`61`	`61`	`#[derive(Debug)]`
`62`		`-enum DelayState {`
	`62`	`+enum State {`
`63`	`63`	`Started,`
`64`	`64`	`PollFuture,`
`65`	`65`	`Completed,`
`@@ -70,7 +70,7 @@ impl<F, D> Delay<F, D> {`
`70`	`70`	`Self {`
`71`	`71`	`future,`
`72`	`72`	`deadline,`
`73`		`- state: DelayState::Started,`
	`73`	`+ state: State::Started,`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`	`}`
`@@ -82,16 +82,16 @@ impl<F: Future, D: Future> Future for Delay<F, D> {`
`82`	`82`	`let mut this = self.project();`
`83`	`83`	`loop {`
`84`	`84`	`match this.state {`
`85`		`- DelayState::Started => {`
	`85`	`+ State::Started => {`
`86`	`86`	`ready!(this.deadline.as_mut().poll(cx));`
`87`		`- *this.state = DelayState::PollFuture;`
	`87`	`+ *this.state = State::PollFuture;`
`88`	`88`	`}`
`89`		`- DelayState::PollFuture => {`
	`89`	`+ State::PollFuture => {`
`90`	`90`	`let value = ready!(this.future.as_mut().poll(cx));`
`91`		`- *this.state = DelayState::Completed;`
	`91`	`+ *this.state = State::Completed;`
`92`	`92`	`return Poll::Ready(value);`
`93`	`93`	`}`
`94`		`- DelayState::Completed => panic!("future polled after completing"),`
	`94`	`+ State::Completed => panic!("future polled after completing"),`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ impl AsyncInputStream {`
`26`	`26`	`stream,`
`27`	`27`	`}`
`28`	`28`	`}`
`29`		`- pub(crate) fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<()> {`
	`29`	`+ fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<()> {`
`30`	`30`	`// Lazily initialize the AsyncPollable`
`31`	`31`	`let subscription = self`
`32`	`32`	`.subscription`
`@@ -43,7 +43,7 @@ impl AsyncInputStream {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`/// Await for read readiness.`
`46`		`- pub(crate) async fn ready(&self) {`
	`46`	`+ async fn ready(&self) {`
`47`	`47`	`poll_fn(\|cx\| self.poll_ready(cx)).await`
`48`	`48`	`}`
`49`	`49`	`/// Asynchronously read from the input stream.`
`@@ -233,7 +233,7 @@ impl AsyncOutputStream {`
`233`	`233`	`}`
`234`	`234`	`}`
`235`	`235`	`/// Await write readiness.`
`236`		`- pub(crate) async fn ready(&self) {`
	`236`	`+ async fn ready(&self) {`
`237`	`237`	`// Lazily initialize the AsyncPollable`
`238`	`238`	`let subscription = self`
`239`	`239`	`.subscription`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+//! Random number generation.`
	`2`	`+`
`1`	`3`	`use wasip2::random;`
`2`	`4`
`3`	`5`	`/// Fill the slice with cryptographically secure random bytes.`