Changes in extern.rs

546f6dbc - c-api: implement wasm_tagtype_t for exception tag types (#10252) (#12763)

Thu, 12 Mar 2026 17:09:57 +0000

c-api: implement wasm_tagtype_t for exception tag types (#10252) (#12763)* c-api: implement wasm_tagtype_t for exception tag types (#10252)Implement the C embedder API for WebAssembly exception tags, resolvingthe long-standing todo!() in CExternType::new() that caused a Rust panicwhenever a module with tag exports had its exports enumerated via theC API (e.g. wasm_module_exports / wasmtime_module_exports).Changes:- Add wasm_tagtype_t type with wasm_tagtype_new/params/delete/copy and the standard as_externtype / externtype_as_tagtype cast functions- Add WASM_EXTERN_TAG = 4 constant to wasm_externkind_enum in wasm.h- Add CExternType::Tag(CTagType) variant; wire into CExternType::new() and wasm_externtype_kind()- Add wasmtime/types/tag.hh C++ wrapper (TagType / TagType::Ref)- Extend ExternType::Ref variant and ref_from_c() switch in extern.hh- Add TagType tests: construction, module export enumeration (regression for #10252), and wasm_externtype_kind / cast function correctnessCo-Authored-By: Claude Sonnet 4.6 * c-api: move tag type declarations to wasmtime/tag.h- Revert wasm.h to its vendored upstream state (it must not be modified locally; tag support is not yet in the upstream wasm-c-api spec header)- Add crates/c-api/include/wasmtime/tag.h with wasm_tagtype_t forward declaration, WASM_EXTERN_TAG constant, and all wasm_tagtype_* / wasm_externtype_as_tagtype* function declarations- Include wasmtime/tag.h from wasmtime.hCo-Authored-By: Claude Sonnet 4.6 * Apply rustfmt and clang-format to tag type implementationCo-Authored-By: Claude Sonnet 4.6 * Fix Clippy warnings: remove unused imports and dead codeDrop unused `wasm_tagtype_t` import from extern.rs, and remove the`force`/`ty`/`wasm_tagtype_t::new` dead-code paths from tag.rs thatwere written for future engine-resolution support but are not yet called.Co-Authored-By: Claude Sonnet 4.6 * Redesign tag type API with wasmtime_* prefix per reviewer feedback- Rename wasm_tagtype_t → wasmtime_tagtype_t and all wasm_tagtype_* functions → wasmtime_tagtype_* to avoid clashing with future wasm.h additions (as requested by alexcrichton)- Constructor now takes wasm_engine_t* + wasm_valkind_t array + count instead of wasm_valtype_vec_t, eliminating the lazy-init complexity- Replace wasm_tagtype_params() (returning a vec) with wasmtime_tagtype_param_count() + wasmtime_tagtype_param(nth), matching the component type accessor iterator pattern- Rename WASM_EXTERN_TAG → WASMTIME_EXTERN_TAG- Simplify CTagType: stores TagType directly, no Arc>- Update C++ TagType wrapper: constructor takes Engine&, Ref exposes param_count() / param(nth) instead of params() returning ListRef- Add ValType::c_to_kind() static helper used by TagType::Ref::param()- Fix null-pointer panic for zero-length param arrays in RustCo-Authored-By: Claude Sonnet 4.6 ---------Co-authored-by: Claude Sonnet 4.6 List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.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/crates/c-api/src/types/extern.rs

0b4c754a - Exception and control tags (#10251)

Thu, 20 Feb 2025 15:49:20 +0000

Exception and control tags (#10251)* Tags* Tag tests* Tests* Refer to tags issue* Engine index* Simplify* Fix clippy warnings List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

ae84e6ed - Enable `unsafe-attr-outside-unsafe` 2024 edition lint (#9964)

Thu, 09 Jan 2025 21:05:55 +0000

Enable `unsafe-attr-outside-unsafe` 2024 edition lint (#9964)* Enable `unsafe-attr-outside-unsafe` 2024 edition lintThis commit enables the `unsafe-attr-outside-unsafe` lint in rustc usedin transitioning to the 2024 edition. This requires that the`#[no_mangle]` attribute is replaced in favor of `#[unsafe(no_mangle)]`.This mostly affects the C API of wasmtime and most of the changes hereare a simple search/replace.* Another attribute update* Fix command adapter build List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

8652011f - Refactor `wasmtime::FuncType` to hold a handle to its registered type (#7892)

Fri, 09 Feb 2024 21:07:52 +0000

Refactor `wasmtime::FuncType` to hold a handle to its registered type (#7892)* Refactor `wasmtime::FuncType` to hold a handle to its registered typeRather than holding a copy of the type directly, it now holds a `RegisteredType`which internally is* A `VMSharedTypeIndex` pointing into the engine's types registry.* An `Arc` handle to the engine's type registry.* An `Arc` handle to the actual type.The last exists only to keep it so that accessing a `wasmtime::FuncType`'sparameters and results fast, avoiding any new locking on call hot paths.This is helping set the stage for further types and `TypeRegistry` refactorsneeded for Wasm GC.* Update the C API for the function types refactorprtest:full* rustfmt* Fix benches build List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

76b82910 - Remove the module linking implementation in Wasmtime (#3958)

Wed, 23 Mar 2022 19:57:34 +0000

Remove the module linking implementation in Wasmtime (#3958)* Remove the module linking implementation in Wasmtime This commit removes the experimental implementation of the module linking WebAssembly proposal from Wasmtime. The module linking is no longer intended for core WebAssembly but is instead incorporated into the component model now at this point. This means that very large parts of Wasmtime's implementation of module linking are no longer applicable and would change greatly with an implementation of the component model. The main purpose of this is to remove Wasmtime's reliance on the support for module-linking in `wasmparser` and tooling crates. With this reliance removed we can move over to the `component-model` branch of `wasmparser` and use the updated support for the component model. Additionally given the trajectory of the component model proposal the embedding API of Wasmtime will not look like what it looks like today for WebAssembly. For example the core wasm `Instance` will not change and instead a `Component` is likely to be added instead. Some more rationale for this is in #3941, but the basic idea is that I feel that it's not going to be viable to develop support for the component model on a non-`main` branch of Wasmtime. Additionaly I don't think it's viable, for the same reasons as `wasm-tools`, to support the old module linking proposal and the new component model at the same time. This commit takes a moment to not only delete the existing module linking implementation but some abstractions are also simplified. For example module serialization is a bit simpler that there's only one module. Additionally instantiation is much simpler since the only initializer we have to deal with are imports and nothing else. Closes #3941 * Fix doc link * Update comments List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

7a1b7cdf - Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Thu, 03 Jun 2021 14:10:53 +0000

Implement RFC 11: Redesigning Wasmtime's APIs (#2897)Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread. List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

41caf67a - Update the C API with module linking support (#2472)

Thu, 03 Dec 2020 21:51:38 +0000

Update the C API with module linking support (#2472)* Update the C API with module linking support This commit does everything necessary (ideally) to support the module linking proposal in the C API. The changes here are: * New `wasm_{module,instance}type_t` types and accessors * New `wasm_{module,instance}_type` functions * Conversions between `wasm_extern_t` and `wasm_{instance,module}_t`, as well as `wasm_externtype_t` and the new types. * Addition of `WASM_EXTERN_{MODULE,INSTANCE}` constants * New `wasm_config_t` modifier to enable/disable module linking With these functions it should be possible to pass instances/modules to instances and also acquire them from exports. Altogether this should enable everything for module linking. An important point for this is that I've opted to add all these items under the `wasm_*` name prefix instead of `wasmtime_*`. I've done this since they're all following the idioms of existing APIs and while not standard the intention would be to standardize them (unlike many other Wasmtime-specific APIs). cc #2094 * Appease doxygen List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

73cda835 - Propagate module-linking types to `wasmtime` (#2115)

Fri, 06 Nov 2020 20:48:09 +0000

Propagate module-linking types to `wasmtime` (#2115)This commit adds lots of plumbing to get the type section from the module linking proposal plumbed all the way through to the `wasmtime` crate and the `wasmtime-c-api` crate. This isn't all that useful right now because Wasmtime doesn't support imported/exported modules/instances, but this is all necessary groundwork to getting that exported at some point. I've added some light tests but I suspect the bulk of the testing will come in a future commit. One major change in this commit is that `SignatureIndex` no longer follows type type index space in a wasm module. Instead a new `TypeIndex` type is used to track that. Function signatures, still indexed by `SignatureIndex`, are then packed together tightly. List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs

6ef09359 - Refactor and fill out wasmtime's C API (#1415)

Fri, 27 Mar 2020 14:50:32 +0000

Refactor and fill out wasmtime's C API (#1415)* Refactor and improve safety of C API This commit is intended to be a relatively large refactoring of the C API which is targeted at improving the safety of our C API definitions. Not all of the APIs have been updated yet but this is intended to be the start. The goal here is to make as many functions safe as we can, expressing inputs/outputs as native Rust types rather than raw pointers wherever possible. For example instead of `*const wasm_foo_t` we'd take `&wasm_foo_t`. Instead of returning `*mut wasm_foo_t` we'd return `Box`. No ABI/API changes are intended from this commit, it's supposed to only change how we define all these functions internally. This commit also additionally implements a few more API bindings for exposed vector types by unifying everything into one macro. Finally, this commit moves many internal caches in the C API to the `OnceCell` type which provides a safe interface for one-time initialization. * Split apart monolithic C API `lib.rs` This commit splits the monolithic `src/lib.rs` in the C API crate into lots of smaller files. The goal here is to make this a bit more readable and digestable. Each module now contains only API bindings for a particular type, roughly organized around the grouping in the wasm.h header file already. A few more extensions were added, such as filling out `*_as_*` conversions with both const and non-const versions. Additionally many APIs were made safer in the same style as the previous commit, generally preferring Rust types rather than raw pointer types. Overall no functional change is intended here, it should be mostly just code movement and minor refactorings! * Make a few wasi C bindings safer Use safe Rust types where we can and touch up a few APIs here and there. * Implement `wasm_*type_as_externtype*` APIs This commit restructures `wasm_externtype_t` to be similar to `wasm_extern_t` so type conversion between the `*_extern_*` variants to the concrete variants are all simple casts. (checked in the case of general to concrete, of course). * Consistently imlpement host info functions in the API This commit adds a small macro crate which is then used to consistently define the various host-info-related functions in the C API. The goal here is to try to mirror what the `wasm.h` header provides to provide a full implementation of the header. List of files: /wasmtime-44.0.1/crates/c-api/src/types/extern.rs