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 t

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, resolving
the long-standing todo!() in CExternType::new() that caused a Rust panic
whenever a module with tag exports had its exports enumerated via the
C 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 correctness

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

* 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.h

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

* Apply rustfmt and clang-format to tag type implementation

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

* Fix Clippy warnings: remove unused imports and dead code

Drop unused `wasm_tagtype_t` import from extern.rs, and remove the
`force`/`ty`/`wasm_tagtype_t::new` dead-code paths from tag.rs that
were written for future engine-resolution support but are not yet called.

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

* 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<Mutex<LazyTagType>>
- 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 Rust

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

---------

Co-authored-by: Claude Sonnet 4.6 <[email protected]>

show more ...

Update Wasmtime to the 2024 Rust Edition (#10806)

* Update Wasmtime to the 2024 Rust Edition

Now that our MSRV supports the 2024 edition it's possible to make this
switch. This commit moves Wasmtim

Update Wasmtime to the 2024 Rust Edition (#10806)

* Update Wasmtime to the 2024 Rust Edition

Now that our MSRV supports the 2024 edition it's possible to make this
switch. This commit moves Wasmtime to the 2024 Edition to keep
up-to-date with Rust idioms and access many of the edition features
exclusive to the 2024 edition.

prtest:full

* Reformat with the 2024 edition

show more ...

Exception and control tags (#10251)

* Tags

* Tag tests

* Tests

* Refer to tags issue

* Engine index

* Simplify

* Fix clippy warnings

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

* Enable `unsafe-attr-outside-unsafe` 2024 edition lint

This commit enables the `unsafe-attr-outside-unsafe` lint in rustc used
in tran

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

* Enable `unsafe-attr-outside-unsafe` 2024 edition lint

This commit enables the `unsafe-attr-outside-unsafe` lint in rustc used
in 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 here
are a simple search/replace.

* Another attribute update

* Fix command adapter build

show more ...

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

* Refactor `wasmtime::FuncType` to hold a handle to its registered type

Rather than holding a copy of the type directly

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

* Refactor `wasmtime::FuncType` to hold a handle to its registered type

Rather 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`'s
parameters and results fast, avoiding any new locking on call hot paths.

This is helping set the stage for further types and `TypeRegistry` refactors
needed for Wasm GC.

* Update the C API for the function types refactor

prtest:full

* rustfmt

* Fix benches build

show more ...

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 WebA

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

show more ...

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 inform

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.

show more ...

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

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

show more ...

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

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.

show more ...

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

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<wasm_foo_t>`. 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.

show more ...