Remove dependency on std for async feature (#1591)

* Remove dependency on `std` for `async` feature

This commit adds `no_std` support for the `async` feature of the
`wit-bindgen` crate, notably enabling this to be used as part of the
standard library for wasip3.

* Fix inter-task-wakeup compat

* Run rustfmt

* Update test expectations

* Add a `TryLock` primitive

* Run rustfmt

Author: alexcrichton

crates/guest-rust/Cargo.toml

@@ -32,9 +32,9 @@ default = ["macros", "realloc", "async", "std", "bitflags", "macro-string"]
 macros = ["dep:wit-bindgen-rust-macro"]
 realloc = []
 std = []
-async = ["std", "wit-bindgen-rust-macro?/async"]
+async = ["wit-bindgen-rust-macro?/async"]
 bitflags = ["dep:bitflags"]
-async-spawn = ['async', 'dep:futures']
+async-spawn = ['async', 'dep:futures', 'std']
 futures-stream = ['async', 'dep:futures']
 macro-string = ["wit-bindgen-rust-macro?/macro-string"]
 

crates/guest-rust/src/rt/async_support.rs

@@ -1,23 +1,24 @@
 #![deny(missing_docs)]
 
-extern crate std;
+use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
+use alloc::sync::Arc;
+use alloc::task::Wake;
+use core::ffi::c_void;
+use core::future::Future;
+use core::mem;
+use core::pin::Pin;
+use core::ptr;
 use core::sync::atomic::{AtomicU32, Ordering};
-use std::boxed::Box;
-use std::collections::BTreeMap;
-use std::ffi::c_void;
-use std::future::Future;
-use std::mem;
-use std::pin::Pin;
-use std::ptr;
-use std::sync::Arc;
-use std::task::{Context, Poll, Wake, Waker};
+use core::task::{Context, Poll, Waker};
 
 macro_rules! rtdebug {
     ($($f:tt)*) => {
         // Change this flag to enable debugging, right now we're not using a
         // crate like `log` or such to reduce runtime deps. Intended to be used
         // during development for now.
         if false {
+            #[cfg(feature = "std")]
             std::eprintln!($($f)*);
         }
     }
@@ -67,6 +68,7 @@ mod futures_stream;
 mod inter_task_wakeup;
 mod stream_support;
 mod subtask;
+mod try_lock;
 #[cfg(feature = "inter-task-wakeup")]
 mod unit_stream;
 mod waitable;

crates/guest-rust/src/rt/async_support/abi_buffer.rs

@@ -1,9 +1,9 @@
 use crate::rt::Cleanup;
 use crate::rt::async_support::StreamOps;
-use std::alloc::Layout;
-use std::mem::{self, MaybeUninit};
-use std::ptr;
-use std::vec::Vec;
+use alloc::alloc::Layout;
+use alloc::vec::Vec;
+use core::mem::{self, MaybeUninit};
+use core::ptr;
 
 /// A helper structure used with a stream to handle the canonical ABI
 /// representation of lists and track partial writes.

crates/guest-rust/src/rt/async_support/error_context.rs

@@ -1,8 +1,8 @@
 //! Raw bindings to `error-context` in the canonical ABI.
 
-use std::fmt::{self, Debug, Display};
-use std::ptr;
-use std::string::String;
+use alloc::string::String;
+use core::fmt::{self, Debug, Display};
+use core::ptr;
 
 /// Represents the Component Model `error-context` type.
 #[derive(PartialEq, Eq)]
@@ -56,7 +56,7 @@ impl Display for ErrorContext {
     }
 }
 
-impl std::error::Error for ErrorContext {}
+impl core::error::Error for ErrorContext {}
 
 impl Drop for ErrorContext {
     fn drop(&mut self) {

crates/guest-rust/src/rt/async_support/future_support.rs

@@ -113,17 +113,19 @@
 
 use crate::rt::Cleanup;
 use crate::rt::async_support::ReturnCode;
+use crate::rt::async_support::try_lock::TryLock;
 use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation};
-use std::alloc::Layout;
-use std::fmt;
-use std::future::{Future, IntoFuture};
-use std::marker;
-use std::mem::{self, ManuallyDrop};
-use std::pin::Pin;
-use std::ptr;
-use std::sync::atomic::{AtomicU32, Ordering::Relaxed};
-use std::sync::{Arc, Mutex};
-use std::task::{Context, Poll, Wake, Waker};
+use alloc::sync::Arc;
+use alloc::task::Wake;
+use core::alloc::Layout;
+use core::fmt;
+use core::future::{Future, IntoFuture};
+use core::marker;
+use core::mem::{self, ManuallyDrop};
+use core::pin::Pin;
+use core::ptr;
+use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
+use core::task::{Context, Poll, Waker};
 
 /// Helper trait which encapsulates the various operations which can happen
 /// with a future.
@@ -501,7 +503,7 @@ impl<O: FutureOps> RawFutureWriter<O> {
         O: 'static,
     {
         return Arc::new(DeferredWrite {
-            write: Mutex::new(self.write(value)),
+            write: TryLock::new(self.write(value)),
         })
         .wake();
 
@@ -519,7 +521,7 @@ impl<O: FutureOps> RawFutureWriter<O> {
         /// doesn't require the `async-spawn` feature and instead works with the
         /// `wasip3_task` C ABI structures (which spawn doesn't support).
         struct DeferredWrite<O: FutureOps> {
-            write: Mutex<RawFutureWrite<O>>,
+            write: TryLock<RawFutureWrite<O>>,
         }
 
         // SAFETY: Needed to satisfy `Waker::from` but otherwise should be ok
@@ -550,7 +552,7 @@ impl<O: FutureOps> RawFutureWriter<O> {
                 let poll = {
                     let waker = Waker::from(self.clone());
                     let mut cx = Context::from_waker(&waker);
-                    let mut write = self.write.lock().unwrap();
+                    let mut write = self.write.try_lock().unwrap();
                     unsafe { Pin::new_unchecked(&mut *write).poll(&mut cx) }
                 };
                 if poll.is_ready() {
@@ -756,7 +758,7 @@ impl<T> fmt::Display for FutureWriteError<T> {
     }
 }
 
-impl<T> std::error::Error for FutureWriteError<T> {}
+impl<T> core::error::Error for FutureWriteError<T> {}
 
 /// Result of [`FutureWrite::cancel`].
 #[derive(Debug)]

crates/guest-rust/src/rt/async_support/futures_stream.rs

@@ -1,6 +1,6 @@
 use super::stream_support::{RawStreamReader, StreamOps, StreamVtable};
-use std::boxed::Box;
-use std::{
+use alloc::boxed::Box;
+use core::{
     future::Future,
     pin::Pin,
     task::{Context, Poll},
@@ -60,7 +60,7 @@ impl<O: StreamOps + 'static> futures::stream::Stream for RawStreamReaderStream<O
         // All variants of `StreamAdapterState` are `Unpin`, so `Pin<&mut Self>`
         // can be freely projected.
         loop {
-            match std::mem::replace(&mut self.state, StreamAdapterState::Complete) {
+            match core::mem::replace(&mut self.state, StreamAdapterState::Complete) {
                 StreamAdapterState::Idle(mut reader) => {
                     let fut: ReadNextFut<O> = Box::pin(async move {
                         let item = reader.next().await;

crates/guest-rust/src/rt/async_support/inter_task_wakeup.rs

@@ -1,8 +1,8 @@
 use super::FutureState;
+use crate::rt::async_support::try_lock::TryLock;
 use crate::rt::async_support::{BLOCKED, COMPLETED};
 use crate::{RawStreamReader, RawStreamWriter, StreamOps, UnitStreamOps};
-use std::ptr;
-use std::sync::Mutex;
+use core::ptr;
 
 #[derive(Default)]
 pub struct State {
@@ -27,7 +27,7 @@ impl FutureState<'_> {
             assert!(!self.inter_task_wakeup.stream_reading);
             let (writer, reader) = UnitStreamOps::new();
             self.inter_task_wakeup.stream = Some(reader);
-            let mut waker_stream = self.waker.inter_task_stream.lock.lock().unwrap();
+            let mut waker_stream = self.waker.inter_task_stream.lock.try_lock().unwrap();
             assert!(waker_stream.is_none());
             *waker_stream = Some(writer);
         }
@@ -81,7 +81,7 @@ impl State {
 
 #[derive(Default)]
 pub struct WakerState {
-    lock: Mutex<Option<RawStreamWriter<UnitStreamOps>>>,
+    lock: TryLock<Option<RawStreamWriter<UnitStreamOps>>>,
 }
 
 impl WakerState {
@@ -90,7 +90,7 @@ impl WakerState {
         // original future itself. The stream should also have an active read
         // while the future is sleeping. This means that this write should
         // succeed immediately.
-        let mut inter_task_stream = self.lock.lock().unwrap();
+        let mut inter_task_stream = self.lock.try_lock().unwrap();
         let stream = inter_task_stream.as_mut().unwrap();
         let rc = unsafe { UnitStreamOps.start_write(stream.handle(), ptr::null_mut(), 1) };
         assert_eq!(rc, COMPLETED | (1 << 4));

crates/guest-rust/src/rt/async_support/spawn_disabled.rs

@@ -1,5 +1,5 @@
 use crate::rt::async_support::BoxFuture;
-use std::task::{Context, Poll};
+use core::task::{Context, Poll};
 
 #[derive(Default)]
 pub struct Tasks<'a> {

crates/guest-rust/src/rt/async_support/stream_support.rs

@@ -3,17 +3,17 @@
 
 use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation};
 use crate::rt::async_support::{AbiBuffer, DROPPED, ReturnCode};
+use alloc::vec::Vec;
 use {
     crate::rt::Cleanup,
-    std::{
+    core::{
         alloc::Layout,
         fmt,
         future::Future,
         pin::Pin,
         ptr,
         sync::atomic::{AtomicU32, Ordering::Relaxed},
         task::{Context, Poll},
-        vec::Vec,
     },
 };
 
@@ -308,7 +308,7 @@ where
         // TODO: can probably be a bit more efficient about this and avoid
         // moving `value` onto the heap in some situations, but that's left as
         // an optimization for later.
-        self.write_all(std::vec![value]).await.pop()
+        self.write_all(alloc::vec![value]).await.pop()
     }
 }
 

crates/guest-rust/src/rt/async_support/subtask.rs

@@ -13,11 +13,11 @@ use crate::rt::async_support::{
     STATUS_RETURNED, STATUS_RETURNED_CANCELLED, STATUS_STARTED, STATUS_STARTED_CANCELLED,
     STATUS_STARTING,
 };
-use std::alloc::Layout;
-use std::future::Future;
-use std::marker;
-use std::num::NonZeroU32;
-use std::ptr;
+use core::alloc::Layout;
+use core::future::Future;
+use core::marker;
+use core::num::NonZeroU32;
+use core::ptr;
 
 /// Raw operations used to invoke an imported asynchronous function.
 ///