Changes in async.rs

37c49428 - Fix a panic in `Bytes{,Mut}` `StreamProducer` impls (#12878)

Mon, 30 Mar 2026 14:09:25 +0000

Fix a panic in `Bytes{,Mut}` `StreamProducer` impls (#12878)This commit fixes the logic of these `impl`s to match the `Vec`-styleblocks to relinquish the entire buffer to Wasmtime immediately. Thisfixes an issue where `split_off` is called with too large a value whichcan panic. List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

35887491 - Enable multiple concurrent sync host calls from different threads in the same task (#12735)

Thu, 05 Mar 2026 15:37:33 +0000

Enable multiple concurrent sync host calls from different threads in the same task (#12735)* Move sync call set to thread state* Add test* Cleanup* Cleanup List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

8de60f18 - Fix async stream cancel corrupting read/write state (#12704)

Mon, 02 Mar 2026 23:43:03 +0000

Fix async stream cancel corrupting read/write state (#12704)When `stream.cancel-read` or `stream.cancel-write` is called with the`async` option and the cancel cannot complete immediately (returnsBLOCKED), the code was unconditionally transitioning the read/writestate from GuestReady to Open. This destroyed the buffer address/countinfo stored in GuestReady, causing incorrect behavior when the hostproducer/consumer later tried to access the stream state.Guard the GuestReady -> Open state transition with a check that thecancel did not return BLOCKED. When blocked, the cancel is stillin-flight and the read/write state must be preserved until the cancelcompletes.Adds a regression test that creates a host StreamProducer, starts anasync read (BLOCKED), then async-cancels (BLOCKED), and waits forcancel completion. List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

da093747 - Relax panics in async/futures to traps/errors (#12688)

Mon, 02 Mar 2026 21:26:40 +0000

Relax panics in async/futures to traps/errors (#12688)* Relax panics in async/futures to traps/errorsThis commit is an admittance that I don't believe we're going to getto a point where we are confident enough in the fuzzing ofcomponent-model-async such that we could confidently say we'reexercising the vast majority of possible panics. Development ofcomponent-model-async has shown a steady trickle of panics over thecourse of the development of the feature, and this trend has beenpersistent over time as well.An attempt was made in #12119 to add a fuzzer dedicated to async eventsbut that didn't actually find anything in development and it has misseda number of panics present before and discovered after its introduction.Overall I do not know how to improve the fuzzer to the point that itwould find pretty much all of the existing async-related panics overtime.To help address this concern of the `concurrent.rs` implementation thiscommit goes through and replaces things like `unwrap()`, `assert!`,`panic!`, and `unreachable!` with an error-producing form. The benefitof this is that a bug in the implementation is less likely to result ina panic and instead just results in a non-spec-compliant trap. Thedownside of doing this though is that it can become unclear what errorsare "first class traps", or expected to be guest reachable, and whichare expected to be bugs in Wasmtime. To help address this I've performeda few refactorings here as well.* Some traps previously present as error strings are now promoted to using `Trap::Foo` instead. This has some refactoring of the Rust/C side as well to make it easier to define new variants. Tests were additionally added for any trap messages that weren't previously tested as being reachable.* A new `bail_bug!` macro was added (internally) for Wasmtime. This is coupled with a concrete `WasmtimeBug` error type (exported as `wasmtime::WasmtimeBug`). The intention is that `bail!` continues to be "here's a string and I'm a bit too lazy to make a concrete error" while `bail_bug!` indicates "this is a bug in wasmtime please report this if you see it".The rough vision is that if an error condition is reached, and the systemis not broken in such a way that panicking is required, then `bail_bug!`can be used to indicate a bug in Wasmtime as opposed to panicking. Thisreduces the real-world impact of hitting these scenarios by downgrading aCVE-worthy `panic!` into a bug-worthy non-spec-compliant trap. Not allpanics are able to be transitioned to this as some are load bearing froma safety perspective or similar (or indicate something equally broken),but the vast majority of cases are suitable for "return a trap, lockdown the store, and let destructors take care of everything else".This change additionally has resulted in API changes for `FutureReader`and `StreamReader`. For example creation of these types now returns a`Result` for when the `ResourceTable` is full, for example, instead ofpanicking.* Fix CI build* Translate `WasmtimeBug` to panics in debug mode* Review comments* Refactor some stream methods for fewer panics List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

d2fbd2de - Update to wasm-tools 245 (#12571)

Thu, 12 Feb 2026 15:38:22 +0000

Update to wasm-tools 245 (#12571)* Intrinsics updates* Remove ds_store* Update to wasm-tools 245* Add vets* Fixup tests* Add missing feature for `indexmap`---------Co-authored-by: Sy Brand List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

3764e757 - Refactor borrow state tracking for async tasks (#12550)

Tue, 10 Feb 2026 03:15:51 +0000

Refactor borrow state tracking for async tasks (#12550)* Refactor borrow state tracking for async tasksThis commit is a somewhat deep refactoring of how the state of`borrow` is managed for both the host and the guest with respect toasync tasks. This additionally refactors how some async task managementis done for host-called functions.The fundamental problem being tackled here is #12510. In that issue itwas discovered that the way `CallContext`, the borrow tracking mechanismin Wasmtime, is managed is incompatible with async tasks. Specificallythe previous assumption of the scope being mutated for a borrow issomewhere on the call stack is no longer true. It's possible for anasync task to be suspended, for example, and then a sibling task drops aborrow which should update the scope of the suspended task. There were anumber of other small issues I noticed here and there which this PRadditionally has tests for, all of which failed before this change andpass afterwards.The manner in which borrow state is manipulated is a pretty old part ofthe component model implementation dating back to the originalimplementation of resources. I decided to forgo any possible quick fixand have attempted to more deeply refactor and integrate async tasksinto all of this infrastructure. A list of the changes made here are:* The `CallContexts` structure, a stack of `CallContext`, was removed. Tasks now directly store a `CallContext` which is the source of truth for borrow tracking for that call, and it does not move from this location. The store `CallContexts` is now deleted in favor of updating the `Option` in the store to be an `enum` of either concurrent state or a stack. In this manner the old stack-based structure is still used sometimes, but it's impossible to reach when concurrency is enabled.* Entry to the host from guests now reliably pushes a `HostTask` into the store. Previously where a frame were always pushed into a `CallContext` a `HostTask` is pushed into the store. This is still expected to be a bit too expensive for cheap host calls, but it doesn't meaningfully change the performance profile of before.* The `resource_enter_call` and `resource_exit_call` libcalls have been removed. These are now folded into the `enter_sync_call` and `exit_sync_call` libcalls. Emission of these hooks has been updated accordingly. The concept of entering a call more generally has been removed. This is more formally known in the async world as a task starting, so the task creation is now responsible for the demarcation of entering a call. Additionally this means that the concept of exiting a call has somewhat gone away. Instead this method was renamed to `validate_scope_exit` which double-checks that a borrow-scope can be exited but doesn't actually remove the task. Task removal is deferred to preexisting mechanisms.* Management of a `GuestTask`'s previous `Option` field, for example taking/restoring and pushing/popping onto `CallContexts` is now all gone. All related code is outright deleted as the `GuestTask`'s now non-optional `CallContext` field is the source of truth.* The `ConcurrentState` structure now stores a `CurrentThread` enum instead of `Option`. This represents how the currently executing thread could be a host thread, not just a guest thread, which is required for borrow-tracking.* `HostTask` creation in `poll_and_block` and `first_poll`, the two main entrypoints of async host tasks when called by the guest, is now externalized from these functions. Instead these functions assume that the currently running thread is already a `HostTask` of some kind.* In `poll_and_block` the host's result is no longer stored in the guest task but in the host task instead.Overall this enables the `*.wast` test for #12510 to fix the originalissue. This then adds new tests to ensure that cleanup of variousconstructs happens appropriately, such as cancelling a host task shouldclean up its associated resources. Additionally synchronously calling anasync host task no longer leaks resources in a `Store` and shouldproperly clean up everything.There is still more work to do in this area (e.g. #12544) but that'sgoing to be deferred to a future PR at this point.Closes #12510prtest:full* Review comments/CI fixes List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

c09aa380 - deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)

Tue, 03 Feb 2026 19:13:45 +0000

deprecate `[Typed]Func::post_return[_async]` and make them no-ops (#12498)* deprecate `[Typed]Func::post_return[_async]` and make them no-opsWith the advent of the Component Model concurrency ABI and it's `task.return`intrinsic, post-return functions have been informally deprecated and areexpected to be removed for WASI 1.0 and the corresponding stable edition of theComponent Model. Consequently, it does not make sense anymore to requireembedders to explicitly call the post-return function after using`[Typed]Func::call[_async]`.As of this commit, `[Typed]Func::post_return[_async]` are no-ops. Instead, thepost-return function is called automatically as part of`[Typed]Func::call[_async]` if present, which is how`[Typed]Func::call_concurrent` has worked all along. In addition, this commitfixes and tests a couple of cases where the task and/or thread was beingdisposed of before the post-return function was called.* address review feedback* test post-return function in more scenariosSpecifically, I've split the `invoke_post_return` test into multiple tests:- using `TypedFunc::call`- using `TypedFunc::call_async` with concurrency support enabled- using `TypedFunc::call_async` with concurrency support disabled- using `Func::call_async` with concurrency support disabled- using `TypedFunc::call_concurrent`* remove GCC/clang-specific deprecation attributeThis broke the MSVC build.* bless bindgen output* remove obsolete post-return functions and fieldsNow that post-return calls are handled internally without requiring explicitaction by the embedder, we can avoid unnecessary bookkeeping. List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

21797bb5 - Refactor how concurrency support is enabled in a `Store` (#12416)

Fri, 23 Jan 2026 22:37:55 +0000

Refactor how concurrency support is enabled in a `Store` (#12416)* Document panics from using CM async machinery when CM async is not enabled* Refactor how concurrency support is enabled in a `Store`This commit is an extension/refactor of #12377 and #12379. Notably thisdecouples the runtime behavior of Wasmtime from enabled/disabledWebAssembly proposals. This enables the `wasmtime serve` subcommand, forexample, to continue to disallow component-model-async by default butcontinue to use `*_concurrent` under the hood.Specifically a new `Config::concurrency_support` knob is added. This isplumbed directly through to `Tunables` and takes over the preexisting`component_model_concurrency` field. This field configures whethertasks/etc are enabled at runtime for component-y things. The defaultvalue of this configuration option is the same as `cfg!(feature ="component-model-async")`, and this field is required ifcomponent-model-async wasm proposals are enabled. It's intended thateventually this'll affect on-by-default wasm features in Wasmtimedepending if the support is compiled in.This results in a subtle shift in behavior where component-model-asyncconcurrency is used by default now because the feature is turned on bydefault, even though the wasm features are off-by-default. This requiredadjusting a few indices expected in runtime tests due to tasks/threadsbeing allocated in index spaces.Finally, this additionally denies access at runtime to`Linker::*_concurrent` when concurrent support is disabled as otherwisethe various runtime data structures won't be initialized and panics willhappen.Closes #12393* Add a `-Wconcurrency-support` CLI flagUsed to update disas tests to show that, when disabled, old codegenquality is preserved* Ungate `Config` flag* Review comments---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

cc8d04f4 - Remove need for explicit `Config::async_support` knob (#12371)

Fri, 23 Jan 2026 02:46:45 +0000

Remove need for explicit `Config::async_support` knob (#12371)* Refactor component model host function definitionsPush the `async`-ness down one layer.* Remove need for explicit `Config::async_support` knobThis commit is an attempt to step towards reconciling "old async" and"new async" in Wasmtime. The old async style is the original asyncsupport in Wasmtime with `call_async`, `func_wrap_async`, etc, where themain property is that the store is "locked" during an async operation.Put another way, a store can only execute at most one async operation ata time. This is in contrast to "new async" support in Wasmtime with thecomponent-model-async (WASIp3) support, where stores can have more thanone async operation in flight at once.This commit does not fully reconcile these differences, but it doesremove one hurdle along the way: `Config::async_support`. Since thebeginning of Wasmtime this configuration knob has existed to explicitlydemarcate a config/engine/store as "this thing requires `async` stuffinternally." This has started to make less and less sense over timewhere the line between sync and async has become more murky with WASIp3where the two worlds comingle. The goal of this commit is to deprecate`Config::async_support` and make the function not actually do anything.In isolation this can't simply be done, however, because there are manyload-bearing aspects of Wasmtime that rely on this `async_support` knob.For example once epochs + yielding are enabled it's required that allWasm is executed on a fiber lest it hit an epoch and not know how toyield. That means that this commit is not a simple removal of`async_support` but instead a refactoring/rearchitecting of how async isused internally within Wasmtime. The high-level ideas within Wasmtimenow are:* A `Store` has a "requires async" boolean stored within it.* All configuration options which end up requiring async, such as yielding with epochs, turn this boolean on.* Creation of host functions which use async (e.g. `func_wrap_{async,concurrent}`) will also turn this option on.* Synchronous API entrypoints into Wasmtime ensure that this boolean is disabled.* Asynchronous APIs are usable at any time.This means that the concept of an async store vs a sync store is nowgone. All stores are equally capable of executing sync/async, and thechange now is that dynamically some stores will require that async isused with certain configuration. Additionally all panicking conditionsaround `async_support` have been converted to errors instead. Allrelevant APIs already returned an error and things are murky enough nowthat it's not necessarily trivial to get this right at the embedderlevel. In the interest of avoiding panics all detected async mismatchesare now first-class `wasmtime::Error` values.The end result of this commit is that `Config::async_support` is adeprecated `#[doc(hidden)]` function that does nothing. While manyinternal changes happened as well as having new tests for all this sortof behavior this is not expected to have a great impact on externalconsumers. In general a deletion of `async_support(true)` is in theoryall that's required. This is intended to make it easier to think aboutasync/sync/etc in the future with WASIp3 and eventually reconcile`func_wrap_async` and `func_wrap_concurrent` for example. That's leftfor future refactorings however.prtest:full* Review comments* Fix CI failures List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

94740588 - Migrate the Wasmtime CLI to `wasmtime::error` (#12295)

Fri, 09 Jan 2026 19:15:48 +0000

Migrate the Wasmtime CLI to `wasmtime::error` (#12295)* Migrate wasmtime-cli to `wasmtime::error`* migrate benches to `wasmtime::error` as well* Remove new usage of anyhow that snuck in List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

cb97ae85 - allow recursive Wasm invocation from concurrent host functions (#12152)

Thu, 11 Dec 2025 23:03:58 +0000

allow recursive Wasm invocation from concurrent host functions (#12152)* allow recursive Wasm invocation from concurrent host functionsThe core changes here are:- remove an unnecessary assertion from `concurrent::prepare_call`- track instance states (e.g. backpressure, etc.) on a per `(Instance, RuntimeComponentInstanceIndex)` basis - both parts of that key are needed now that concurrent state is tracked on a per-store basis rather than a per-instance basis since `RuntimeComponentInstanceIndex`es are not globally uniqueWhile discussing the above with Alex, we realized the use of a `HashMap` totrack per-instance states was both pessimal and unnecessary. Consequently, I'vefolded that state into `ComponentInstance::instance_handle_tables`, renaming itto `instance_states`. That involved a fair amount of code churn, but doesn'tchange behavior except as described in the second bullet point above.Thanks to Alex for the test case!Fixes #12098Co-authored-by: Alex Crichton Signed-off-by: Joel Dice * use new `RuntimeInstance` type instead of tuplesSigned-off-by: Joel Dice ---------Signed-off-by: Joel Dice Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

8992b99b - trap on blocking call in sync task before return (#12043)

Tue, 09 Dec 2025 15:41:57 +0000

trap on blocking call in sync task before return (#12043)* trap on blocking call in sync task before returnThis implements a spec change (PR pending) such that tasks created for calls tosynchronous exports may not call potentially-blocking imports or return `wait`or `poll` callback codes prior to returning a value. Specifically, thefollowing are prohibited in that scenario:- returning callback-code.{wait,poll}- sync calling an async import- sync calling subtask.cancel- sync calling {stream,future}.{read,write}- sync calling {stream,future}.cancel-{read,write}- calling waitable-set.{wait,poll}- calling thread.suspendThis breaks a number of tests, which will be addressed in follow-up commits:- The `{tcp,udp}-socket.bind` implementation in `wasmtime-wasi` is implemented using `Linker::func_wrap_concurrent` and thus assumed to be async, whereas the WIT interface says they're sync, leading to a type mismatch error at runtime. Alex and I have discussed this and have a general plan to address it.- A number of tests in the tests/component-model submodule that points to the spec repo are failing. Those will presumably be fixed as part of the upcoming spec PR (although some could be due to bugs in this implementation, in which case I'll fix them).- A number of tests in tests/misc_testsuite are failing. I'll address those in a follow-up commit.Signed-off-by: Joel Dice * call `check_may_leave` before `check_blocking``check_blocking` needs access to the current task, but that's not set forpost-return functions since those should not be calling _any_ imports at all, sofirst check for that.Signed-off-by: Joel Dice * fix `misc_testsuite` test regressionsThis amounts to adding `async` to any exported component functions that mightneed to block.Signed-off-by: Joel Dice * simplify code in `ConcurrentState::check_blocking`Signed-off-by: Joel Dice * make `thread.yield` a no-op in non-blocking contextsPer the proposed spec changes, `thread.yield` should return control to the guestimmediately without allowing any other thread to run. Similarly, when anasync-lifted export or callback returns `CALLBACK_CODE_YIELD`, we should callthe callback again immediately without allowing another thread to run.Signed-off-by: Joel Dice * fix build when `component-model-async` feature disabledSigned-off-by: Joel Dice * fix more test regressionsSigned-off-by: Joel Dice * fix more test regressionsNote that this temporarily updates the `tests/component-model` submodule to thebranch for https://github.com/WebAssembly/component-model/pull/577 until that PRis merged.Signed-off-by: Joel Dice * tweak `Trap::CannotBlockSyncTask` messageThis clarifies that such a task cannot block prior to returning.Signed-off-by: Joel Dice * fix cancel_host_future testSigned-off-by: Joel Dice * trap sync-lowered, guest->guest async calls in sync tasksI somehow forgot to address this earlier. Thanks to Luke for catching this.Note that this commit doesn't include test coverage, but Luke's forthecomingtests in the `component-model` repo will cover it, and we'll pull that in withthe next submodule update.Signed-off-by: Joel Dice * switch back to `main` branch of `component-model` repo...and skip or `should_fail` the tests that won't pass untilhttps://github.com/WebAssembly/component-model/pull/578 is merged.Signed-off-by: Joel Dice * add `trap-if-block-and-sync.wast`We'll remove this again in favor of the upstream version oncehttps://github.com/WebAssembly/component-model/pull/578 has been merged.Signed-off-by: Joel Dice * address review feedback- Assert that `StoreOpaque::suspend` is not called in a non-blocking context except in specific circumstances- Typecheck async-ness for dynamic host functions- Use type parameter instead of value parameter in `call_host[_dynamic]`Signed-off-by: Joel Dice * add explanation comments to `check_blocking` callsSigned-off-by: Joel Dice * fix fuzz test oracle for async functionsSigned-off-by: Joel Dice ---------Signed-off-by: Joel Dice List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

3f2807ac - don't set `TransmitState::done` until future value delivered (#12093)

Wed, 26 Nov 2025 16:10:51 +0000

don't set `TransmitState::done` until future value delivered (#12093)Thanks to Alex for the test case!Fixes #12092Signed-off-by: Joel Dice Co-authored-by: Alex Crichton List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

020727d0 - Update wasm-tools dependencies (#12031)

Fri, 14 Nov 2025 21:34:45 +0000

Update wasm-tools dependencies (#12031)* Change separator style* Update wasm-tools dependencies* Also update wit-bindgen* Drop `[async]` name prefixes* Plumb `async` as part of a function typeRuntime handling of async functions and new traps are to be implementedin subsequent commits. This is just getting everything running again.* Run clang-format, also add test* Fix some more wast tests---------Co-authored-by: Sy Brand List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

e06fbf70 - Cooperative Multithreading (#11751)

Mon, 27 Oct 2025 21:39:35 +0000

Cooperative Multithreading (#11751)* Initial work* Almost compiling* Partially working* Cleanup* Fix merge* Cancellation and suspension refactoring* Remove printlns* Test with several threads* More testing* Cancellation* Fix cancellation for explicit suspends* Finish cancellation test* Store threads in the instance table* Deletion almost there* Tests all pass* Tighten up task deletion* Set thread state correctly* Store pairs of thread and task ids* Remove lift abi members* Cleanup unnecessary change* More cleanup* Cleanup* Revert cargo changes* Revert cargo changes* Comments* Comments on test* Update comments* Update comments* Add space that was removed in an earlier commit* Cleanup* Delete threads from the instance table* Revert cargo file* Remove dead code* Clippy changes* Clippy* Revert unnecessary changes* Revert unnecessary changes* Revert unnecessary changes* Revert unnecessary changes* Revert unnecessary changes* Review comments* Review feedback* Make thread IDs per-component-instance* Fix config* Tighten up completion* Clippy* Trigger full PR test* Move funcref table reading* Remove unused import* Formatting* Rename RemoveOnDrop* Review feedback* Review feedback* Move start thread closure* Review feedback* Review feedback* Correct feature for import* Review feedback* Disable failing tests* Enable fixed tests* Review feedback* Readd tests* Ignore task deletion test with Miri List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

3d67b75e - Add a dummy impl of fibers for Miri (#11009)

Wed, 11 Jun 2025 00:47:47 +0000

Add a dummy impl of fibers for Miri (#11009)* Add a dummy impl of fibers for MiriThis commit extends the `wasmtime-internal-fiber` crate with animplementation for Miri. Previously this was entirely unsupportedbecause fibers use inline assembly. The implementation with Miri spawnsa separate thread and keeps it in a suspended state with locks to modela suspended stack. This technically isn't correct because TLS variableswill be wrong, but it's "correct enough" for our usage in Wasmtime. Inthe end this enables running more tests in Miri which is always a goodthing, and a number of loose odds and ends were cleaned up relate to ourunsafe management of async state.* Apply suggestions from code reviewCo-authored-by: Pat Hickey ---------Co-authored-by: Pat Hickey List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

90ac295e - Update Wasmtime to the 2024 Rust Edition (#10806)

Mon, 19 May 2025 16:40:55 +0000

Update Wasmtime to the 2024 Rust Edition (#10806)* Update Wasmtime to the 2024 Rust EditionNow that our MSRV supports the 2024 edition it's possible to make thisswitch. This commit moves Wasmtime to the 2024 Edition to keepup-to-date with Rust idioms and access many of the edition featuresexclusive to the 2024 edition.prtest:full* Reformat with the 2024 edition List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

ca7081a2 - Consolidate "util" crates for testing (#10423)

Thu, 20 Mar 2025 15:08:47 +0000

Consolidate "util" crates for testing (#10423)* Consolidate "util" crates for testingThis commit consolidates all of the existing crates we have for testinginto a smaller set of crates. Specifically:* `crates/misc/component-fuzz-util` => `wasmtime-test-util` + `component-fuzz` feature* `crates/misc/component-test-util` => `wasmtime-test-util` + `component` feature* `crates/wast-util` => `wasmtime-test-util` + `wast` feature* `crates/misc/component-macro-test` => `wasmtime-test-macros`The goal is to have one location we put various test helpers/macrosrather than our current organically-grown many locations. This isinspired by the test failure on #10405 where I'd like to refactor moreinfrastructure to a "test util" location but it wasn't clear where toput it so I wanted to do this refactoring first.* Remove unused file List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

c1663bab - Generate async drop methods for resources. (#9091)

Wed, 14 Aug 2024 14:44:53 +0000

Generate async drop methods for resources. (#9091)* Add the ability to generate async drop methods for resources.In the component model, `resource.drop` is a canonical built-in without a proper name. So I invented a custom naming scheme for the component bindgen config. I went with:`"[drop]{resource-name}"` where `{resource-name}` is the name as defined in WIT. e.g. `"[drop]input-stream"`.This shouldn't conflict with anything existing in the wild as WIT identifiers are not allowed to contain square brackets.* Add test for resource_async List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs

05fe6282 - Refactor wasmtime::Func to "unsplat" arguments for the async API (#8732)

Mon, 03 Jun 2024 16:18:58 +0000

Refactor wasmtime::Func to "unsplat" arguments for the async API (#8732)* Complete implementation in wasmtime* Get the impl of IntoFunc to point at the new HostContext from_closure method to tie it back to the new implementation* A little bit of cleanup to comments and naming* Update doc comment for Func wrap_async List of files: /wasmtime-44.0.1/tests/all/component_model/async.rs