feat: add a histrical wit-bindgen

__wasm/wit-bindgen-sample/wit-bindgen/crates/rust-wasm/src/futures.rs

@@ -0,0 +1,202 @@
+//! Helper library support for `async` wit functions, used for both
+
+use std::cell::RefCell;
+use std::future::Future;
+use std::mem;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::task::*;
+
+#[cfg(target_arch = "wasm32")]
+#[link(wasm_import_module = "canonical_abi")]
+extern "C" {
+    pub fn async_export_done(ctx: i32, ptr: i32);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub unsafe extern "C" fn async_export_done(_ctx: i32, _ptr: i32) {
+    panic!("only supported on wasm");
+}
+
+struct PollingWaker {
+    state: RefCell<State>,
+}
+
+enum State {
+    Waiting(Pin<Box<dyn Future<Output = ()>>>),
+    Polling,
+    Woken,
+}
+
+// These are valid for single-threaded WebAssembly because everything is
+// single-threaded and send/sync don't matter much. This module will need
+// an alternative implementation for threaded WebAssembly when that comes about
+// to host runtimes off-the-web.
+#[cfg(not(target_feature = "atomics"))]
+unsafe impl Send for PollingWaker {}
+#[cfg(not(target_feature = "atomics"))]
+unsafe impl Sync for PollingWaker {}
+
+/// Runs the `future` provided to completion, polling the future whenever its
+/// waker receives a call to `wake`.
+pub fn execute(future: impl Future<Output = ()> + 'static) {
+    let waker = Arc::new(PollingWaker {
+        state: RefCell::new(State::Waiting(Box::pin(future))),
+    });
+    waker.wake()
+}
+
+impl Wake for PollingWaker {
+    fn wake(self: Arc<Self>) {
+        let mut state = self.state.borrow_mut();
+        let mut future = match mem::replace(&mut *state, State::Polling) {
+            // We are the first wake to come in to wake-up this future. This
+            // means that we need to actually poll the future, so leave the
+            // `Polling` state in place.
+            State::Waiting(future) => future,
+
+            // Otherwise the future is either already polling or it was already
+            // woken while it was being polled, in both instances we reset the
+            // state back to `Woken` and then we return. This means that the
+            // future is owned by some previous stack frame and will drive the
+            // future as necessary.
+            State::Polling | State::Woken => {
+                *state = State::Woken;
+                return;
+            }
+        };
+        drop(state);
+
+        // Create the futures waker/context from ourselves, used for polling.
+        let waker = self.clone().into();
+        let mut cx = Context::from_waker(&waker);
+        loop {
+            match future.as_mut().poll(&mut cx) {
+                // The future is finished! By returning here we destroy the
+                // future and release all of its resources.
+                Poll::Ready(()) => break,
+
+                // The future has work yet-to-do, so continue below.
+                Poll::Pending => {}
+            }
+
+            let mut state = self.state.borrow_mut();
+            match *state {
+                // This means that we were not woken while we were polling and
+                // the state is as it was when we took out the future before. By
+                // `Pending` being returned at this point we're guaranteed that
+                // our waker will be woken up at some point in the future, which
+                // will come look at this future again. This means that we
+                // simply store our future and return, since this call to `wake`
+                // is now finished.
+                State::Polling => {
+                    *state = State::Waiting(future);
+                    break;
+                }
+
+                // This means that we received a call to `wake` while we were
+                // polling. Ideally we'd enqueue some sort of microtask-tick
+                // here or something like that but for now we just loop around
+                // and poll again.
+                State::Woken => {}
+
+                // This shouldn't be possible since we own the future, and no
+                // one else should insert another future here.
+                State::Waiting(_) => unreachable!(),
+            }
+        }
+    }
+}
+
+pub struct Oneshot<T> {
+    inner: Rc<OneshotInner<T>>,
+}
+
+pub struct Sender<T> {
+    inner: Rc<OneshotInner<T>>,
+}
+
+struct OneshotInner<T> {
+    state: RefCell<OneshotState<T>>,
+}
+
+enum OneshotState<T> {
+    Start,
+    Waiting(Waker),
+    Done(T),
+}
+
+impl<T> Oneshot<T> {
+    /// Returns a new "oneshot" channel as well as a completion callback.
+    pub fn new() -> (Oneshot<T>, Sender<T>) {
+        let inner = Rc::new(OneshotInner {
+            state: RefCell::new(OneshotState::Start),
+        });
+        (
+            Oneshot {
+                inner: Rc::clone(&inner),
+            },
+            Sender { inner },
+        )
+    }
+}
+
+impl<T> Future for Oneshot<T> {
+    type Output = T;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
+        let mut state = self.inner.state.borrow_mut();
+        match mem::replace(&mut *state, OneshotState::Start) {
+            OneshotState::Done(t) => Poll::Ready(t),
+            OneshotState::Waiting(_) | OneshotState::Start => {
+                *state = OneshotState::Waiting(cx.waker().clone());
+                Poll::Pending
+            }
+        }
+    }
+}
+
+impl<T> Sender<T> {
+    pub fn into_usize(self) -> usize {
+        Rc::into_raw(self.inner) as usize
+    }
+
+    pub unsafe fn from_usize(ptr: usize) -> Sender<T> {
+        Sender {
+            inner: Rc::from_raw(ptr as *const _),
+        }
+    }
+
+    pub fn send(self, val: T) {
+        let mut state = self.inner.state.borrow_mut();
+        let prev = mem::replace(&mut *state, OneshotState::Done(val));
+        // Must `drop` before the `wake` below because waking may induce
+        // polling which would induce another `borrow_mut` which would
+        // conflict with this `borrow_mut` otherwise.
+        drop(state);
+
+        match prev {
+            // nothing has polled the returned future just yet, so we just
+            // filled in the result of the computation. Presumably this will
+            // get picked up at some point in the future.
+            OneshotState::Start => {}
+
+            // Something was waiting for the result, so we wake the waker
+            // here which, for wasm, will likely induce polling immediately.
+            OneshotState::Waiting(waker) => waker.wake(),
+
+            // Shouldn't be possible, this is the only closure that writes
+            // `Done` and this can only be invoked once.
+            OneshotState::Done(_) => unreachable!(),
+        }
+    }
+}
+
+impl<T> Drop for OneshotInner<T> {
+    fn drop(&mut self) {
+        if let OneshotState::Waiting(waker) = &*self.state.borrow() {
+            waker.wake_by_ref();
+        }
+    }
+}