Changes in types.wast

b8a3e205 - Fix error message for out-of-bounds variant discriminants (#12885)

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

Fix error message for out-of-bounds variant discriminants (#12885)Fixes a minor mistake when loading a `Val` from memory with anout-of-bounds discriminant. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

8fbe4c2c - Fix some panics compiling components and resources (#11798)

Mon, 06 Oct 2025 22:36:55 +0000

Fix some panics compiling components and resources (#11798)In working on bytecodealliance/wasm-tools#2335 I found that there's afew test cases in wasm-tools which Wasmtime was panicking to compile.The issues were all related to resource types and how information wasn'tregistered ahead of time before it was translated from wasmparser'srepresentation to Wasmtime's representation. The high-level cause forthis had to do with how component and instance types are handled, asopposed to concrete components or instances themselves. This waseffectively a hole in Wasmtime's translation process for componentswhich has never been filled out since the original implementation ofresources. The reason that this never came up before is:* Most components don't currently import or export a component itself.* Most components don't currently import or export component or instance types (as opposed to values).One of these was required to trigger this issue. The solutionimplemented in this commit is to plumb the concept of an "abstractresource" which is part of a type but not actually ever used at runtimeexcept for type equality during type reflection. This is expected tohave little-to-no impact on real-world components given that thesesituations are rarely occurring. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

c71d3aab - Deps: Update `wasm-tools` crates to 0.233.0 (#10915)

Wed, 04 Jun 2025 18:53:37 +0000

Deps: Update `wasm-tools` crates to 0.233.0 (#10915)* Update `wasm-tools` deps to 0.233.0* Update `cargo vet` metadataJust a prune and wildcard renewals* cargo fmt* Fix type export identifiers* Fix more type identifiers in exports in WAT List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

35902366 - Remove component union types (#6913)

Sat, 26 Aug 2023 19:51:23 +0000

Remove component union types (#6913)- Bump wasm-tools deps- Use new TypeSectionReader::into_iter_err_on_gc_types method List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

7b9189ba - Update the wasm-tools family of crates, disallow empty component types (#6777)

Wed, 26 Jul 2023 19:23:43 +0000

Update the wasm-tools family of crates, disallow empty component types (#6777)* Remove unused WIT files from WasmtimeThese files aren't actually read by anything currently. They were addedhistorically and a previous refactoring in #6390 forgot to remove them.No tests or build process reads them so this deletes them to get themout of the way.* Update dependencies on wasm-tools crates.This commit updates the deps on the wasm-tools family of crates to bringin a few fixes for WIT/component-related things. Primarily though thisbrings in an update to the component model where empty types are nowdisallowed.Some tests using empty types were adjusted to use non-empty types, butmany tests were also simply removed as they existed to test what wouldhappen with empty types which now no longer needs to be tested.* Update `stream-error` in preview2Add a `dummy` field to make it a non-empty structure. It's expected thatthis will change to something else more "official" in the future, butfor now this is here to keep everything compiling.* Update component fuzzing to avoid empty typesEmpty types are no longer valid* Update crates/wasi/wit/deps/io/streams.witCo-authored-by: Peter Huene ---------Co-authored-by: Peter Huene List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

2e56c973 - Lean on wasmparser's type information when translating components (#6638)

Tue, 27 Jun 2023 18:09:31 +0000

Lean on wasmparser's type information when translating components (#6638)* Lean on wasmparser's type information when translating componentsBefore this commit Wasmtime would build up its own representation oftype information independently of wasmparser, effectively duplicatingthings such as type scopes and managing indices. This to some degree isrequired because Wasmtime's type information is serialized into compiledimages and wasmparser's information isn't easily serialized. With theadvent of resources in components, however, the task of doing thiscorrectly has become much more difficult.When component translation was first written it was more difficult toacquire type information from `wasmparser::Validator`. Nowadays there'shelpful type information exposed every step of the way which makes itmuch easier to get at the types of items while we're translating ratherthan only at the very end (or not at all). This is one of themotivations for this commit where now it's possible to avoid duplicatingthe work `wasmparser` is doing whereas before it wasn't as easy.Additionally with resources in the component model they perform namely anumber of involved type substitutions during instantiation of arbitrarycomponents which isn't implemented in Wasmtime today. Some of this willbe required for Wasmtime to correctly implement resources so instead ofdoing all that again I've decided to replace Wasmtime's management oftypes with wasmparser's management of types.The main difference in this commit is that Wasmtime no longer trackstype information during translation and that conversion into Wasmtime'stype hierarchy now has a different entry point. Previously conversionwould happen based on raw types read from the wasm file (thinkindex-based things) whereas now translation happens on `wasmparser`'sparsed and validated hierarchy of types (think ID-based things ratherthan index-based things). This makes translation slightly more involvedbut overall it's largely performing the same work.One gotcha with this PR is that core wasm modules using GC types andtyped function references could theoretically have worked previously butthey no longer work. It turns out that `wasmparser` is not correctlysurfacing type information in components for core modules that use GCtypes, namely because `wasmparser`'s validated type hierarchy uses thesame core wasm types as what's read raw from the type section. This inturn means that the index-based format can't be resolved. This is a bugin `wasmparser` which will need resolving but is a big chunk of work totake on, so for now the component model will panic on these sorts ofmodules (which are disabled by default anyway).Overall the end-goal of this commit is to ease the implementation ofresources a bit by heavily relying on `wasmparser`'s understanding ofresources, chiefly the functionality of performing type substitutions onsubcomponent instantiations.* Fix a warning* Fix factc build List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

b5e9fb71 - Improve type imports into components (#5777)

Tue, 14 Feb 2023 18:02:19 +0000

Improve type imports into components (#5777)This commit fixes a panic related to type imports where an import of a type didn't correctly declare the new type index on the Wasmtime side of things. Additionally this plumbs more support throughout Wasmtime to support type imports, namely that they do not need to be supplied through a `Linker`. This additionally implements a feature where empty instances, even transitively, do not need to be supplied by a Wasmtime embedder. This means that instances which only have types, for example, do not need to be supplied into a `Linker` since no runtime information for them is required anyway. Closes #5775 List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

0e92fba7 - Improve handling of types and aliases in components (#5591)

Thu, 19 Jan 2023 00:39:21 +0000

Improve handling of types and aliases in components (#5591)This commit fixes more cases from #5565 where `export` items introducing indices wasn't handled by accident. Additionally this fixes support for aliasing types from instances which largely wasn't working before. Most of the fixes here are about correctly maintaining Wasmtime's view of the type index spaces. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

b305f251 - Update the wasm-tools family of crates (#5310)

Mon, 21 Nov 2022 21:37:16 +0000

Update the wasm-tools family of crates (#5310)Most of the changes here are the updates to the component model which includes optional URL fields in imports/exports. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

29c7de73 - Update wasm-tools dependencies (#4970)

Tue, 27 Sep 2022 18:12:34 +0000

Update wasm-tools dependencies (#4970)* Update wasm-tools dependencies This update brings in a number of features such as: * The component model binary format and AST has been slightly adjusted in a few locations. Names are dropped from parameters/results now in the internal representation since they were not used anyway. At this time the ability to bind a multi-return function has not been exposed. * The `wasmparser` validator pass will now share allocations with prior functions, providing what's probably a very minor speedup for Wasmtime itself. * The text format for many component-related tests now requires named parameters. * Some new relaxed-simd instructions are updated to be ignored. I hope to have a follow-up to expose the multi-return ability to the embedding API of components. * Update audit information for new crates List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

62c5af68 - components: Limit the recursive size of types in Wasmtime (#4825)

Wed, 31 Aug 2022 18:29:04 +0000

components: Limit the recursive size of types in Wasmtime (#4825)* components: Limit the recursive size of types in Wasmtime This commit is aimed at fixing #4814 by placing a hard limit on the maximal recursive depth a type may have in the component model. The component model theoretically allows for infinite recursion but many various types of operations within the component model are naturally written as recursion over the structure of a type which can lead to stack overflow with deeply recursive types. Some examples of recursive operations are: * Lifting and lowering a type - currently the recursion here is modeled in Rust directly with `#[derive]` implementations as well as the implementations for the `Val` type. * Compilation of adapter trampolines which iterates over the type structure recursively. * Historically many various calculations like the size of a type, the flattened representation of a type, etc, were all done recursively. Many of these are more efficiently done via other means but it was still natural to implement these recursively initially. By placing a hard limit on type recursion Wasmtime won't be able to load some otherwise-valid modules. The hope, though, is that no human-written program is likely to ever reach this limit. This limit can be revised and/or the locations with recursion revised if it's ever reached. The implementation of this feature is done by generalizing the current flattened-representation calculation which now keeps track of a type's depth and size. The size calculation isn't used just yet but I plan to use it in fixing #4816 and it was natural enough to write here as well. The depth is checked after a type is translated and if it exceeds the maximum then an error is returned. Additionally the `Arbitrary for Type` implementation was updated to prevent generation of a type that's too-recursive. Closes #4814 * Remove unused size calculation * Bump up just under the limit List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

57dca934 - Upgrade wasm-tools crates, namely the component model (#4715)

Wed, 17 Aug 2022 16:17:34 +0000

Upgrade wasm-tools crates, namely the component model (#4715)* Upgrade wasm-tools crates, namely the component model This commit pulls in the latest versions of all of the `wasm-tools` family of crates. There were two major changes that happened in `wasm-tools` in the meantime: * bytecodealliance/wasm-tools#697 - this commit introduced a new API for more efficiently reading binary operators from a wasm binary. The old `Operator`-based reading was left in place, however, and continues to be what Wasmtime uses. I hope to update Wasmtime in a future PR to use this new API, but for now the biggest change is... * bytecodealliance/wasm-tools#703 - this commit was a major update to the component model AST. This commit almost entirely deals with the fallout of this change. The changes made to the component model were: 1. The `unit` type no longer exists. This was generally a simple change where the `Unit` case in a few different locations were all removed. 2. The `expected` type was renamed to `result`. This similarly was relatively lightweight and mostly just a renaming on the surface. I took this opportunity to rename `val::Result` to `val::ResultVal` and `types::Result` to `types::ResultType` to avoid clashing with the standard library types. The `Option`-based types were handled with this as well. 3. The payload type of `variant` and `result` types are now optional. This affected many locations that calculate flat type representations, ABI information, etc. The `#[derive(ComponentType)]` macro now specifically handles Rust-defined `enum` types which have no payload to the equivalent in the component model. 4. Functions can now return multiple parameters. This changed the signature of invoking component functions because the return value is now bound by `ComponentNamedList` (renamed from `ComponentParams`). This had a large effect in the tests, fuzz test case generation, etc. 5. Function types with 2-or-more parameters/results must uniquely name all parameters/results. This mostly affected the text format used throughout the tests. I haven't added specifically new tests for multi-return but I changed a number of tests to use it. Additionally I've updated the fuzzers to all exercise multi-return as well so I think we should get some good coverage with that. * Update version numbers * Use crates.io List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

42233e8e - components: ignore export aliases to types in translation. (#4604)

Thu, 04 Aug 2022 22:45:11 +0000

components: ignore export aliases to types in translation. (#4604)* components: ignore export aliases to types in translation. Currently, translation is ignoring type exports from components during translation by skipping over them before adding them to the exports map. If a component instantiates an inner component and aliases a type export of that instance, it will cause wasmtime to panic with a failure to find the export in the exports map. The fix is to add a representation for exported types to the map that is simply ignored when encountered. This also makes it easier to track places where we would have to support type exports in translation in the future. * Keep type information for type exports. This commit keeps the type information for type exports so that types can be properly aliased from an instance export and thereby adjusting the type index space accordingly. * Add a simple test case for type exports for the component model. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

174b60dc - Add `*.wast` support for invoking components (#4526)

Wed, 27 Jul 2022 21:02:16 +0000

Add `*.wast` support for invoking components (#4526)This commit builds on bytecodealliance/wasm-tools#690 to add support to testing of the component model to execute functions when running `*.wast` files. This support is all built on #4442 as functions are invoked through a "dynamic" API. Right now the testing and integration is fairly crude but I'm hoping that we can try to improve it over time as necessary. For now this should provide a hopefully more convenient syntax for unit tests and the like. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

038383dc - Implement support for outer core type aliases (#4385)

Thu, 07 Jul 2022 16:38:27 +0000

Implement support for outer core type aliases (#4385)Fill in the gaps of the implementation left after #4380. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

7d7ddceb - Update wasm-tools crates (#4246)

Thu, 09 Jun 2022 16:16:07 +0000

Update wasm-tools crates (#4246)This commit updates the wasm-tools family of crates, notably pulling in the refactorings and updates from bytecodealliance/wasm-tools#621 for the latest iteration of the component model. This commit additionally updates all support for the component model for these changes, notably: * Many bits and pieces of type information was refactored. Many `FooTypeIndex` namings are now `TypeFooIndex`. Additionally there is now `TypeIndex` as well as `ComponentTypeIndex` for the two type index spaces in a component. * A number of new sections are now processed to handle the core and component variants. * Internal maps were split such as the `funcs` map into `component_funcs` and `funcs` (same for `instances`). * Canonical options are now processed individually instead of one bulk `into` definition. Overall this was not a major update to the internals of handling the component model in Wasmtime. Instead this was mostly a surface-level refactoring to make sure that everything lines up with the new binary format for components. * All text syntax used in tests was updated to the new syntax. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast

fcf62087 - Initial skeleton of some component model processing (#4005)

Fri, 20 May 2022 20:33:18 +0000

Initial skeleton of some component model processing (#4005)* Initial skeleton of some component model processing This commit is the first of what will likely be many to implement the component model proposal in Wasmtime. This will be structured as a series of incremental commits, most of which haven't been written yet. My hope is to make this incremental and over time to make this easier to review and easier to test each step in isolation. Here much of the skeleton of how components are going to work in Wasmtime is sketched out. This is not a complete implementation of the component model so it's not all that useful yet, but some things you can do are: * Process the type section into a representation amenable for working with in Wasmtime. * Process the module section and register core wasm modules. * Process the instance section for core wasm modules. * Process core wasm module imports. * Process core wasm instance aliasing. * Ability to compile a component with core wasm embedded. * Ability to instantiate a component with no imports. * Ability to get functions from this component. This is already starting to diverge from the previous module linking representation where a `Component` will try to avoid unnecessary metadata about the component and instead internally only have the bare minimum necessary to instantiate the module. My hope is we can avoid constructing most of the index spaces during instantiation only for it to all ge thrown away. Additionally I'm predicting that we'll need to see through processing where possible to know how to generate adapters and where they are fused. At this time you can't actually call a component's functions, and that's the next PR that I would like to make. * Add tests for the component model support This commit uses the recently updated wasm-tools crates to add tests for the component model added in the previous commit. This involved updating the `wasmtime-wast` crate for component-model changes. Currently the component support there is quite primitive, but enough to at least instantiate components and verify the internals of Wasmtime are all working correctly. Additionally some simple tests for the embedding API have also been added. List of files: /wasmtime-44.0.1/tests/misc_testsuite/component-model/types.wast