html-to-markdown 2.24.4 → 2.24.6

data/rust-vendor/wit-bindgen/src/rt/async_support/subtask.rs

@@ -7,12 +7,12 @@
 //! the canonical ABI are additionally leaked with it which should be memory
 //! safe.
 
+use crate::rt::Cleanup;
 use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation};
 use crate::rt::async_support::{
     STATUS_RETURNED, STATUS_RETURNED_CANCELLED, STATUS_STARTED, STATUS_STARTED_CANCELLED,
     STATUS_STARTING,
 };
-use crate::rt::Cleanup;
 use std::alloc::Layout;
 use std::future::Future;
 use std::marker;
@@ -29,14 +29,6 @@ use std::ptr;
 /// All operations/constants must be self-consistent for how this module expects
 /// them all to be used.
 pub unsafe trait Subtask {
-    /// The in-memory layout of both parameters and results allocated with
-    /// parameters coming first.
-    const ABI_LAYOUT: Layout;
-
-    /// The offset, in bytes, from the start of `ABI_LAYOUT` to where the
-    /// results will be stored.
-    const RESULTS_OFFSET: usize;
-
     /// The parameters to this task.
     type Params;
     /// The representation of lowered parameters for this task.
@@ -48,8 +40,16 @@ pub unsafe trait Subtask {
     /// The results of this task.
     type Results;
 
+    /// The in-memory layout of both parameters and results allocated with
+    /// parameters coming first.
+    fn abi_layout(&mut self) -> Layout;
+
+    /// The offset, in bytes, from the start of `ABI_LAYOUT` to where the
+    /// results will be stored.
+    fn results_offset(&mut self) -> usize;
+
     /// The raw function import using `[async-lower]` and the canonical ABI.
-    unsafe fn call_import(params: Self::ParamsLower, results: *mut u8) -> u32;
+    unsafe fn call_import(&mut self, params: Self::ParamsLower, results: *mut u8) -> u32;
 
     /// Bindings-generated version of lowering `params`.
     ///
@@ -60,27 +60,29 @@ pub unsafe trait Subtask {
     /// Note that `ParamsLower` may return `dst` if there are more ABI
     /// parameters than are allowed flat params (as specified by the canonical
     /// ABI).
-    unsafe fn params_lower(params: Self::Params, dst: *mut u8) -> Self::ParamsLower;
+    unsafe fn params_lower(&mut self, params: Self::Params, dst: *mut u8) -> Self::ParamsLower;
 
     /// Bindings-generated version of deallocating any lists stored within
     /// `lower`.
-    unsafe fn params_dealloc_lists(lower: Self::ParamsLower);
+    unsafe fn params_dealloc_lists(&mut self, lower: Self::ParamsLower);
 
     /// Bindings-generated version of deallocating not only owned lists within
     /// `lower` but also deallocating any owned resources.
-    unsafe fn params_dealloc_lists_and_own(lower: Self::ParamsLower);
+    unsafe fn params_dealloc_lists_and_own(&mut self, lower: Self::ParamsLower);
 
     /// Bindings-generated version of lifting the results stored at `src`.
-    unsafe fn results_lift(src: *mut u8) -> Self::Results;
+    unsafe fn results_lift(&mut self, src: *mut u8) -> Self::Results;
 
     /// Helper function to actually perform this asynchronous call with
     /// `params`.
-    fn call(params: Self::Params) -> impl Future<Output = Self::Results>
+    fn call(&mut self, params: Self::Params) -> impl Future<Output = Self::Results>
     where
         Self: Sized,
     {
         async {
-            match WaitableOperation::<SubtaskOps<Self>>::new(Start { params }).await {
+            match WaitableOperation::<SubtaskOps<Self>>::new(SubtaskOps(self), Start { params })
+                .await
+            {
                 Ok(results) => results,
                 Err(_) => unreachable!(
                     "cancellation is not exposed API-wise, \
@@ -91,24 +93,24 @@ pub unsafe trait Subtask {
     }
 }
 
-struct SubtaskOps<T>(marker::PhantomData<T>);
+struct SubtaskOps<'a, T>(&'a mut T);
 
 struct Start<T: Subtask> {
     params: T::Params,
 }
 
-unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
+unsafe impl<T: Subtask> WaitableOp for SubtaskOps<'_, T> {
     type Start = Start<T>;
     type InProgress = InProgress<T>;
     type Result = Result<T::Results, ()>;
     type Cancel = Result<T::Results, ()>;
 
-    fn start(state: Self::Start) -> (u32, Self::InProgress) {
+    fn start(&mut self, state: Self::Start) -> (u32, Self::InProgress) {
         unsafe {
-            let (ptr_params, cleanup) = Cleanup::new(T::ABI_LAYOUT);
-            let ptr_results = ptr_params.add(T::RESULTS_OFFSET);
-            let params_lower = T::params_lower(state.params, ptr_params);
-            let packed = T::call_import(params_lower, ptr_results);
+            let (ptr_params, cleanup) = Cleanup::new(self.0.abi_layout());
+            let ptr_results = ptr_params.add(self.0.results_offset());
+            let params_lower = self.0.params_lower(state.params, ptr_params);
+            let packed = self.0.call_import(params_lower, ptr_results);
             let code = packed & 0xf;
             let subtask = NonZeroU32::new(packed >> 4).map(|handle| SubtaskHandle { handle });
             rtdebug!("<import>({ptr_params:?}, {ptr_results:?}) = ({code:#x}, {subtask:#x?})");
@@ -126,11 +128,12 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
         }
     }
 
-    fn start_cancelled(_state: Self::Start) -> Self::Cancel {
+    fn start_cancelled(&mut self, _state: Self::Start) -> Self::Cancel {
         Err(())
     }
 
     fn in_progress_update(
+        &mut self,
         mut state: Self::InProgress,
         code: u32,
     ) -> Result<Self::Result, Self::InProgress> {
@@ -145,7 +148,7 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
             // Still not done yet, but we can record that this is started and
             // otherwise deallocate lists in the parameters.
             STATUS_STARTED => {
-                state.flag_started();
+                state.flag_started(self.0);
                 Err(state)
             }
 
@@ -153,7 +156,7 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
                 // Conditionally flag as started if we haven't otherwise
                 // explicitly transitioned through `STATUS_STARTED`.
                 if !state.started {
-                    state.flag_started();
+                    state.flag_started(self.0);
                 }
 
                 // Now that our results have been written we can read them.
@@ -161,7 +164,8 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
                 // Note that by dropping `state` here we'll both deallocate the
                 // params/results storage area as well as the subtask handle
                 // itself.
-                unsafe { Ok(Ok(T::results_lift(state.ptr_results()))) }
+                let ptr = state.ptr_results(self.0);
+                unsafe { Ok(Ok(self.0.results_lift(ptr))) }
             }
 
             // This subtask was dropped which forced cancellation. Said
@@ -176,7 +180,7 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
             STATUS_STARTED_CANCELLED => {
                 assert!(!state.started);
                 unsafe {
-                    T::params_dealloc_lists_and_own(state.params_lower);
+                    self.0.params_dealloc_lists_and_own(state.params_lower);
                 }
                 Ok(Err(()))
             }
@@ -197,7 +201,7 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
             // state.
             STATUS_RETURNED_CANCELLED => {
                 if !state.started {
-                    state.flag_started();
+                    state.flag_started(self.0);
                 }
                 Ok(Err(()))
             }
@@ -206,18 +210,18 @@ unsafe impl<T: Subtask> WaitableOp for SubtaskOps<T> {
         }
     }
 
-    fn in_progress_waitable(state: &Self::InProgress) -> u32 {
+    fn in_progress_waitable(&mut self, state: &Self::InProgress) -> u32 {
         // This shouldn't get called in the one case this isn't present: when
         // `STATUS_RETURNED` is returned and no waitable is created. That's the
         // `unwrap()` condition here.
         state.subtask.as_ref().unwrap().handle.get()
     }
 
-    fn in_progress_cancel(state: &Self::InProgress) -> u32 {
-        unsafe { cancel(Self::in_progress_waitable(state)) }
+    fn in_progress_cancel(&mut self, state: &mut Self::InProgress) -> u32 {
+        unsafe { cancel(self.in_progress_waitable(state)) }
     }
 
-    fn result_into_cancel(result: Self::Result) -> Self::Cancel {
+    fn result_into_cancel(&mut self, result: Self::Result) -> Self::Cancel {
         result
     }
 }
@@ -244,7 +248,7 @@ struct InProgress<T: Subtask> {
 }
 
 impl<T: Subtask> InProgress<T> {
-    fn flag_started(&mut self) {
+    fn flag_started(&mut self, op: &mut T) {
         assert!(!self.started);
         self.started = true;
 
@@ -252,11 +256,11 @@ impl<T: Subtask> InProgress<T> {
         // setup correctly and we're obeying the invariants of the vtable,
         // deallocating lists in an allocation that we exclusively own.
         unsafe {
-            T::params_dealloc_lists(self.params_lower);
+            op.params_dealloc_lists(self.params_lower);
         }
     }
 
-    fn ptr_results(&self) -> *mut u8 {
+    fn ptr_results(&mut self, op: &mut T) -> *mut u8 {
         // SAFETY: the `T` trait has unsafely promised us that the offset is
         // in-bounds of the allocation layout.
         unsafe {
@@ -264,26 +268,17 @@ impl<T: Subtask> InProgress<T> {
                 .as_ref()
                 .map(|c| c.ptr.as_ptr())
                 .unwrap_or(ptr::null_mut())
-                .add(T::RESULTS_OFFSET)
+                .add(op.results_offset())
         }
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn drop(_: u32) {
-    unreachable!()
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn cancel(_: u32) -> u32 {
-    unreachable!()
-}
-
-#[cfg(target_arch = "wasm32")]
-#[link(wasm_import_module = "$root")]
-extern "C" {
-    #[link_name = "[subtask-cancel]"]
-    fn cancel(handle: u32) -> u32;
-    #[link_name = "[subtask-drop]"]
-    fn drop(handle: u32);
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    unsafe extern "C" {
+        #[link_name = "[subtask-cancel]"]
+        fn cancel(handle: u32) -> u32;
+        #[link_name = "[subtask-drop]"]
+        fn drop(handle: u32);
+    }
 }

data/rust-vendor/wit-bindgen/src/rt/async_support/unit_stream.rs

@@ -0,0 +1,81 @@
+use crate::rt::async_support::raw_stream_new;
+use crate::{RawStreamReader, RawStreamWriter, StreamOps};
+use std::alloc::Layout;
+
+/// Operations for `stream<()>`.
+///
+/// Can be combined with [`RawStreamWriter`] and [`RawStreamReader`] as created
+/// through [`UnitStreamOps::new`]
+#[derive(Copy, Clone)]
+pub struct UnitStreamOps;
+
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    unsafe extern "C" {
+        #[link_name = "[stream-new-unit]"]
+        fn unit_new() -> u64;
+        #[link_name = "[async-lower][stream-write-unit]"]
+        fn unit_write(stream: u32, val: *const u8, amt: usize) -> u32;
+        #[link_name = "[async-lower][stream-read-unit]"]
+        fn unit_read(stream: u32, val: *mut u8, amt: usize) -> u32;
+        #[link_name = "[stream-cancel-read-unit]"]
+        fn unit_cancel_read(stream: u32) -> u32;
+        #[link_name = "[stream-cancel-write-unit]"]
+        fn unit_cancel_write(stream: u32) -> u32;
+        #[link_name = "[stream-drop-readable-unit]"]
+        fn unit_drop_readable(stream: u32) ;
+        #[link_name = "[stream-drop-writable-unit]"]
+        fn unit_drop_writable(stream: u32) ;
+    }
+}
+
+impl UnitStreamOps {
+    /// Creates a new unit stream read/write pair.
+    pub fn new() -> (RawStreamWriter<Self>, RawStreamReader<Self>) {
+        unsafe { raw_stream_new(UnitStreamOps) }
+    }
+}
+
+unsafe impl StreamOps for UnitStreamOps {
+    type Payload = ();
+
+    fn new(&mut self) -> u64 {
+        unsafe { unit_new() }
+    }
+    fn elem_layout(&self) -> Layout {
+        Layout::new::<()>()
+    }
+    fn native_abi_matches_canonical_abi(&self) -> bool {
+        true
+    }
+    fn contains_lists(&self) -> bool {
+        false
+    }
+    unsafe fn lower(&mut self, (): (), _dst: *mut u8) {
+        unreachable!()
+    }
+    unsafe fn dealloc_lists(&mut self, _dst: *mut u8) {
+        unreachable!()
+    }
+    unsafe fn lift(&mut self, _dst: *mut u8) -> Self::Payload {
+        unreachable!()
+    }
+    unsafe fn start_write(&mut self, stream: u32, val: *const u8, amt: usize) -> u32 {
+        unsafe { unit_write(stream, val, amt) }
+    }
+    unsafe fn start_read(&mut self, stream: u32, val: *mut u8, amt: usize) -> u32 {
+        unsafe { unit_read(stream, val, amt) }
+    }
+    unsafe fn cancel_read(&mut self, stream: u32) -> u32 {
+        unsafe { unit_cancel_read(stream) }
+    }
+    unsafe fn cancel_write(&mut self, stream: u32) -> u32 {
+        unsafe { unit_cancel_write(stream) }
+    }
+    unsafe fn drop_readable(&mut self, stream: u32) {
+        unsafe { unit_drop_readable(stream) }
+    }
+    unsafe fn drop_writable(&mut self, stream: u32) {
+        unsafe { unit_drop_writable(stream) }
+    }
+}

data/rust-vendor/wit-bindgen/src/rt/async_support/waitable.rs

@@ -17,6 +17,7 @@ use std::task::{Context, Poll, Waker};
 /// [`WaitableOp`], which codifies the various state transitions and what to do
 /// on each state transition.
 pub struct WaitableOperation<S: WaitableOp> {
+    op: S,
     state: WaitableOperationState<S>,
     /// Storage for the final result of this asynchronous operation, if it's
     /// completed asynchronously.
@@ -83,7 +84,7 @@ pub unsafe trait WaitableOp {
     /// This method will actually call `{future,stream}.{read,write}` with
     /// `state` provided. The return code of the intrinsic is returned here
     /// along with the `InProgress` state.
-    fn start(state: Self::Start) -> (u32, Self::InProgress);
+    fn start(&mut self, state: Self::Start) -> (u32, Self::InProgress);
 
     /// Optionally complete the async operation.
     ///
@@ -94,17 +95,18 @@ pub unsafe trait WaitableOp {
     /// * a new status code has been received by an async export's `callback`
     /// * cancellation returned a code to be processed here
     fn in_progress_update(
+        &mut self,
         state: Self::InProgress,
         code: u32,
     ) -> Result<Self::Result, Self::InProgress>;
 
     /// Conversion from the "start" state to the "cancel" result, needed when an
     /// operation is cancelled before it's started.
-    fn start_cancelled(state: Self::Start) -> Self::Cancel;
+    fn start_cancelled(&mut self, state: Self::Start) -> Self::Cancel;
 
     /// Acquires the component-model `waitable` index that the `InProgress`
     /// state is waiting on.
-    fn in_progress_waitable(state: &Self::InProgress) -> u32;
+    fn in_progress_waitable(&mut self, state: &Self::InProgress) -> u32;
 
     /// Initiates a request for cancellation of this operation. Returns the
     /// status code returned by the `{future,stream}.cancel-{read,write}`
@@ -115,12 +117,12 @@ pub unsafe trait WaitableOp {
     /// instead the operation must be complete with the returned code. That may
     /// mean that this intrinsic can block while figuring things out in the
     /// component model ABI, for example.
-    fn in_progress_cancel(state: &Self::InProgress) -> u32;
+    fn in_progress_cancel(&mut self, state: &mut Self::InProgress) -> u32;
 
     /// Converts a "completion result" into a "cancel result". This is necessary
     /// when an in-progress operation is cancelled so the in-progress result is
     /// first acquired and then transitioned to a cancel request.
-    fn result_into_cancel(result: Self::Result) -> Self::Cancel;
+    fn result_into_cancel(&mut self, result: Self::Result) -> Self::Cancel;
 }
 
 enum WaitableOperationState<S: WaitableOp> {
@@ -134,8 +136,9 @@ where
     S: WaitableOp,
 {
     /// Creates a new operation in the initial state.
-    pub fn new(state: S::Start) -> WaitableOperation<S> {
+    pub fn new(op: S, state: S::Start) -> WaitableOperation<S> {
         WaitableOperation {
+            op,
             state: WaitableOperationState::Start(state),
             completion_status: CompletionStatus {
                 code: None,
@@ -147,7 +150,11 @@ where
 
     fn pin_project(
         self: Pin<&mut Self>,
-    ) -> (&mut WaitableOperationState<S>, Pin<&mut CompletionStatus>) {
+    ) -> (
+        &mut S,
+        &mut WaitableOperationState<S>,
+        Pin<&mut CompletionStatus>,
+    ) {
         // SAFETY: this is the one method used to project from `Pin<&mut Self>`
         // to the fields, and the contract we're deciding on is that
         // `state` is never pinned but the `CompletionStatus` is. That's used
@@ -155,7 +162,11 @@ where
         // respect to `Option<u32>` internally.
         unsafe {
             let me = self.get_unchecked_mut();
-            (&mut me.state, Pin::new_unchecked(&mut me.completion_status))
+            (
+                &mut me.op,
+                &mut me.state,
+                Pin::new_unchecked(&mut me.completion_status),
+            )
         }
     }
 
@@ -164,7 +175,7 @@ where
     /// * Fill in `completion_status` with the result of a completion event.
     /// * Call `cx.waker().wake()`.
     pub fn register_waker(self: Pin<&mut Self>, waitable: u32, cx: &mut Context) {
-        let (_, mut completion_status) = self.pin_project();
+        let (_, _, mut completion_status) = self.pin_project();
         debug_assert!(completion_status.as_mut().code_mut().is_none());
         *completion_status.as_mut().waker_mut() = Some(cx.waker().clone());
 
@@ -193,7 +204,7 @@ where
         }
 
         unsafe extern "C" fn cabi_wake(ptr: *mut c_void, code: u32) {
-            let ptr: &mut CompletionStatus = &mut *ptr.cast::<CompletionStatus>();
+            let ptr: &mut CompletionStatus = unsafe { &mut *ptr.cast::<CompletionStatus>() };
             ptr.code = Some(code);
             ptr.waker.take().unwrap().wake()
         }
@@ -236,7 +247,7 @@ where
             // Note, though, that if present this must be our `CompletionStatus`
             // pointer.
             if !prev.is_null() {
-                let ptr: *mut CompletionStatus = self.pin_project().1.get_unchecked_mut();
+                let ptr: *mut CompletionStatus = self.pin_project().2.get_unchecked_mut();
                 assert_eq!(ptr, prev.cast());
             }
 
@@ -250,7 +261,7 @@ where
     pub fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<S::Result> {
         use WaitableOperationState::*;
 
-        let (state, completion_status) = self.as_mut().pin_project();
+        let (op, state, completion_status) = self.as_mut().pin_project();
 
         // First up, determine the completion status, if any, that's available.
         let optional_code = match state {
@@ -260,7 +271,7 @@ where
                 let Start(s) = mem::replace(state, Done) else {
                     unreachable!()
                 };
-                let (code, s) = S::start(s);
+                let (code, s) = op.start(s);
                 *state = InProgress(s);
                 Some(code)
             }
@@ -294,7 +305,7 @@ where
     ) -> Poll<S::Result> {
         use WaitableOperationState::*;
 
-        let (state, _completion_status) = self.as_mut().pin_project();
+        let (op, state, _completion_status) = self.as_mut().pin_project();
 
         // If a status code is provided, then extract the in-progress state and
         // see what it thinks about this code. If we're done, yay! If not then
@@ -307,7 +318,7 @@ where
             let InProgress(in_progress) = mem::replace(state, Done) else {
                 unreachable!()
             };
-            match S::in_progress_update(in_progress, code) {
+            match op.in_progress_update(in_progress, code) {
                 Ok(result) => return Poll::Ready(result),
                 Err(in_progress) => *state = InProgress(in_progress),
             }
@@ -323,7 +334,7 @@ where
         // Register the `cx.waker()` to get notified when `writer.handle`
         // receives its completion.
         if let Some(cx) = cx {
-            let handle = S::in_progress_waitable(in_progress);
+            let handle = op.in_progress_waitable(in_progress);
             self.register_waker(handle, cx);
         }
         Poll::Pending
@@ -343,7 +354,7 @@ where
     pub fn cancel(mut self: Pin<&mut Self>) -> S::Cancel {
         use WaitableOperationState::*;
 
-        let (state, mut completion_status) = self.as_mut().pin_project();
+        let (op, state, mut completion_status) = self.as_mut().pin_project();
         let in_progress = match state {
             // This operation was never actually started, so there's no need to
             // cancel anything, just pull out the value and return it.
@@ -351,7 +362,7 @@ where
                 let Start(s) = mem::replace(state, Done) else {
                     unreachable!()
                 };
-                return S::start_cancelled(s);
+                return op.start_cancelled(s);
             }
 
             // This operation is actively in progress, fall through to below.
@@ -385,7 +396,9 @@ where
                     // so just convert that to the `Cancel` type. In this
                     // situation no cancellation is necessary, the async
                     // operation is now inert, and we can immediately return.
-                    Poll::Ready(result) => return S::result_into_cancel(result),
+                    Poll::Ready(result) => {
+                        return self.as_mut().pin_project().0.result_into_cancel(result);
+                    }
 
                     // The operation, despite receiving an update via a code,
                     // has not yet completed. In this case we do indeed need to
@@ -401,7 +414,7 @@ where
             //
             // After we've unregistered fall through to below.
             None => {
-                let waitable = S::in_progress_waitable(in_progress);
+                let waitable = op.in_progress_waitable(in_progress);
                 self.as_mut().unregister_waker(waitable);
             }
         }
@@ -419,15 +432,20 @@ where
         // this to be sound. Rust doesn't currently have linear types or async
         // destructors for example to ensure otherwise that if this were to
         // proceed asynchronously that we could rely on it being invoked.
-        let (InProgress(in_progress), _) = self.as_mut().pin_project() else {
+        let (op, InProgress(in_progress), _) = self.as_mut().pin_project() else {
             unreachable!()
         };
-        let code = S::in_progress_cancel(in_progress);
-        match self.poll_complete_with_code(None, Some(code)) {
-            Poll::Ready(result) => S::result_into_cancel(result),
+        let code = op.in_progress_cancel(in_progress);
+        match self.as_mut().poll_complete_with_code(None, Some(code)) {
+            Poll::Ready(result) => self.as_mut().pin_project().0.result_into_cancel(result),
             Poll::Pending => unreachable!(),
         }
     }
+
+    /// Returns whether or not this operation has completed.
+    pub fn is_done(&self) -> bool {
+        matches!(self.state, WaitableOperationState::Done)
+    }
 }
 
 impl<S: WaitableOp> Future for WaitableOperation<S> {
@@ -440,17 +458,15 @@ impl<S: WaitableOp> Future for WaitableOperation<S> {
 
 impl<S: WaitableOp> Drop for WaitableOperation<S> {
     fn drop(&mut self) {
-        // SAFETY: we're in the destructor here so the value `self` is about
-        // to go away and we can guarantee we're not moving out of it.
-        let mut pin = unsafe { Pin::new_unchecked(self) };
-
-        let (state, _) = pin.as_mut().pin_project();
-
         // If this operation has already completed then skip cancellation,
         // otherwise it's our job to cancel anything in-flight.
-        if let WaitableOperationState::Done = state {
+        if self.is_done() {
             return;
         }
+
+        // SAFETY: we're in the destructor here so the value `self` is about
+        // to go away and we can guarantee we're not moving out of it.
+        let pin = unsafe { Pin::new_unchecked(self) };
         pin.cancel();
     }
 }

data/rust-vendor/wit-bindgen/src/rt/async_support/waitable_set.rs

@@ -17,13 +17,14 @@ impl WaitableSet {
     }
 
     pub fn remove_waitable_from_all_sets(waitable: u32) {
-        rtdebug!("waitable-set.join({waitable}, 0)");
+        rtdebug!("waitable.join({waitable}, 0)");
         unsafe { join(waitable, 0) }
     }
 
     pub fn wait(&self) -> (u32, u32, u32) {
         unsafe {
             let mut payload = [0; 2];
+            rtdebug!("waitable-set.wait({}) = ...", self.0.get());
             let event0 = wait(self.0.get(), &mut payload);
             rtdebug!(
                 "waitable-set.wait({}) = ({event0}, {:#x}, {:#x})",
@@ -38,6 +39,7 @@ impl WaitableSet {
     pub fn poll(&self) -> (u32, u32, u32) {
         unsafe {
             let mut payload = [0; 2];
+            rtdebug!("waitable-set.poll({}) = ...", self.0.get());
             let event0 = poll(self.0.get(), &mut payload);
             rtdebug!(
                 "waitable-set.poll({}) = ({event0}, {:#x}, {:#x})",
@@ -63,38 +65,18 @@ impl Drop for WaitableSet {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn new() -> u32 {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn drop(_: u32) {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn join(_: u32, _: u32) {
-    unreachable!()
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn wait(_: u32, _: *mut [u32; 2]) -> u32 {
-    unreachable!();
-}
-#[cfg(not(target_arch = "wasm32"))]
-unsafe fn poll(_: u32, _: *mut [u32; 2]) -> u32 {
-    unreachable!();
-}
-
-#[cfg(target_arch = "wasm32")]
-#[link(wasm_import_module = "$root")]
-extern "C" {
-    #[link_name = "[waitable-set-new]"]
-    fn new() -> u32;
-    #[link_name = "[waitable-set-drop]"]
-    fn drop(set: u32);
-    #[link_name = "[waitable-join]"]
-    fn join(waitable: u32, set: u32);
-    #[link_name = "[waitable-set-wait]"]
-    fn wait(_: u32, _: *mut [u32; 2]) -> u32;
-    #[link_name = "[waitable-set-poll]"]
-    fn poll(_: u32, _: *mut [u32; 2]) -> u32;
+extern_wasm! {
+    #[link(wasm_import_module = "$root")]
+    unsafe extern "C" {
+        #[link_name = "[waitable-set-new]"]
+        fn new() -> u32;
+        #[link_name = "[waitable-set-drop]"]
+        fn drop(set: u32);
+        #[link_name = "[waitable-join]"]
+        fn join(waitable: u32, set: u32);
+        #[link_name = "[waitable-set-wait]"]
+        fn wait(_: u32, _: *mut [u32; 2]) -> u32;
+        #[link_name = "[waitable-set-poll]"]
+        fn poll(_: u32, _: *mut [u32; 2]) -> u32;
+    }
 }