From dc4acfe184aa39955a1321614c938416922ac7aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Tue, 7 Oct 2025 16:59:27 +0000 Subject: [PATCH 1/7] Uses the latest stable channel version --- .devcontainer/Dockerfile | 11 ++++---- .devcontainer/devcontainer.json | 47 +++++++++++++++++++++++++++++++-- .devcontainer/setup.sh | 0 Cargo.toml | 4 +-- crates/c/Cargo.toml | 2 +- crates/core/Cargo.toml | 2 +- crates/cpp/Cargo.toml | 2 +- crates/csharp/Cargo.toml | 2 +- crates/guest-rust/Cargo.toml | 2 +- crates/markdown/Cargo.toml | 2 +- crates/moonbit/Cargo.toml | 2 +- crates/rust/Cargo.toml | 2 +- crates/test/Cargo.toml | 2 +- rust-toolchain.toml | 5 ++++ 14 files changed, 67 insertions(+), 18 deletions(-) mode change 100644 => 100755 .devcontainer/setup.sh create mode 100644 rust-toolchain.toml diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index ba71db8c7..571b3e51e 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,6 +1,7 @@ -FROM mcr.microsoft.com/devcontainers/rust +# FROM mcr.microsoft.com/devcontainers/rust +FROM rust:trixie -COPY .devcontainer/setup.sh /tmp/setup.sh -RUN chmod +x /tmp/setup.sh -USER vscode -RUN /tmp/setup.sh \ No newline at end of file +# COPY .devcontainer/setup.sh /tmp/setup.sh +# RUN chmod +x /tmp/setup.sh +# USER vscode +# RUN /tmp/setup.sh \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 7ea108510..49cbc67c4 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -5,7 +5,50 @@ "dockerfile": "Dockerfile", "context": ".." }, - + "features": { + "ghcr.io/devcontainers/features/common-utils:2.5.4": { + "username": "vscode", + "uid": 1000, + "gid": 1000, + "installZsh": false, + "installOhMyZsh": false, + "upgradePackages": true, + "nonFreePackages": false + }, + "ghcr.io/devcontainers-extra/features/zig:1.1.2": {} + }, + "customizations": { + "vscode": { + "settings": { + "lldb.executable": "/usr/bin/lldb", + // VS Code don't watch files under ./target + "files.watcherExclude": { + "**/target/**": true + }, + "rust-analyzer.checkOnSave": true, + // "rust-analyzer.check.command": "clippy", + "explorer.compactFolders": false, + "rust-analyzer.inlayHints.implicitDrops.enable": true, + "editor.fontWeight": "bold", + "workbench.colorTheme": "Default Dark Modern", + "workbench.preferredDarkColorTheme": "Monokai", + "workbench.activityBar.location": "top", + "workbench.sideBar.location": "right" + }, + "extensions": [ + "ms-azuretools.vscode-docker", + "rust-lang.rust-analyzer", + "fill-labs.dependi", + "BytecodeAlliance.wit-idl", + "tamasfe.even-better-toml", + "vadimcn.vscode-lldb", + "skellock.just", + "ms-vscode-remote.remote-containers", + "ziglang.vscode-zig" + ] + } + }, + "postCreateCommand": "sh .devcontainer/setup.sh", // Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root. "remoteUser": "vscode" -} +} \ No newline at end of file diff --git a/.devcontainer/setup.sh b/.devcontainer/setup.sh old mode 100644 new mode 100755 diff --git a/Cargo.toml b/Cargo.toml index cbf02a893..3a87b4e1e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ CLI tool to generate bindings for WIT documents and the component model. @@ -19,7 +19,7 @@ edition = "2021" version = "0.46.0" license = "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT" repository = "https://github.com/bytecodealliance/wit-bindgen" -rust-version = "1.82.0" +# # rust-version = "1.82.0" [workspace.dependencies] anyhow = "1.0.72" diff --git a/crates/c/Cargo.toml b/crates/c/Cargo.toml index 57769651d..de53ea094 100644 --- a/crates/c/Cargo.toml +++ b/crates/c/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ C bindings generator for WIT and the component model, typically used through the diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 025eeacb6..42f5549b5 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Low-level support for bindings generation based on WIT files for use with diff --git a/crates/cpp/Cargo.toml b/crates/cpp/Cargo.toml index 3be343e33..9af7ac15d 100644 --- a/crates/cpp/Cargo.toml +++ b/crates/cpp/Cargo.toml @@ -3,7 +3,7 @@ name = "wit-bindgen-cpp" authors = ["Christof Petig "] version = "0.46.0" edition.workspace = true -rust-version.workspace = true +# rust-version.workspace = true repository = 'https://github.com/cpetig/wit-bindgen' license = "Apache-2.0 WITH LLVM-exception" description = """ diff --git a/crates/csharp/Cargo.toml b/crates/csharp/Cargo.toml index 9b4aa062c..3a4d992be 100644 --- a/crates/csharp/Cargo.toml +++ b/crates/csharp/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ C# bindings generator for WIT and the component model, typically used diff --git a/crates/guest-rust/Cargo.toml b/crates/guest-rust/Cargo.toml index 91c167a64..2e7387a6c 100644 --- a/crates/guest-rust/Cargo.toml +++ b/crates/guest-rust/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Rust bindings generator and runtime support for WIT and the component model. diff --git a/crates/markdown/Cargo.toml b/crates/markdown/Cargo.toml index ecdc976f2..cdb36f6d0 100644 --- a/crates/markdown/Cargo.toml +++ b/crates/markdown/Cargo.toml @@ -4,7 +4,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Markdown generator for WIT and the component model, typically used diff --git a/crates/moonbit/Cargo.toml b/crates/moonbit/Cargo.toml index 68238e372..657ee9176 100644 --- a/crates/moonbit/Cargo.toml +++ b/crates/moonbit/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ MoonBit bindings generator for WIT and the component model, typically used diff --git a/crates/rust/Cargo.toml b/crates/rust/Cargo.toml index ca96966ae..25a02ca5c 100644 --- a/crates/rust/Cargo.toml +++ b/crates/rust/Cargo.toml @@ -5,7 +5,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Rust bindings generator for WIT and the component model, typically used through diff --git a/crates/test/Cargo.toml b/crates/test/Cargo.toml index a47ac5633..381580a4c 100644 --- a/crates/test/Cargo.toml +++ b/crates/test/Cargo.toml @@ -4,7 +4,7 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -rust-version = { workspace = true } +# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Backend of the `wit-bindgen test` subcommand diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 000000000..6c0101fb7 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,5 @@ +[toolchain] +channel = "stable" +components = [ "rustfmt", "clippy", "rustc-dev" ] +targets = [ "x86_64-unknown-linux-gnu" ] +profile = "minimal" From 10519bdab261e0b5e78161472b42852dc1aa1b52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Tue, 7 Oct 2025 17:10:21 +0000 Subject: [PATCH 2/7] Update edition to 2024 and resolver to 3 --- Cargo.toml | 4 +- README.md | 8 +- crates/cpp/src/lib.rs | 458 +++++++++--------- crates/csharp/src/function.rs | 2 +- crates/csharp/src/world_generator.rs | 76 +-- crates/markdown/src/lib.rs | 112 ++--- crates/moonbit/src/lib.rs | 294 +++++------ crates/rust/src/bindgen.rs | 2 +- crates/test/src/moonbit.rs | 2 +- .../async/future-cancel-read/test.mbt | 2 +- .../async/future-cancel-write/test.mbt | 2 +- .../future-close-after-coming-back/test.mbt | 2 +- .../async/simple-future/test.mbt | 2 +- .../simple-import-params-results/test.mbt | 2 +- .../async/simple-stream-payload/test.mbt | 2 +- .../async/simple-stream/test.mbt | 2 +- tests/runtime/demo/test.mbt | 2 +- tests/runtime/flavorful/test.mbt | 2 +- tests/runtime/lists/test.mbt | 2 +- tests/runtime/many-arguments/test.mbt | 2 +- tests/runtime/numbers/test.mbt | 2 +- tests/runtime/results/leaf.mbt | 2 +- .../rust/with-only-affects-imports/test.rs | 2 +- tests/runtime/strings/test.mbt | 2 +- tests/runtime/variants/test.mbt | 2 +- 25 files changed, 495 insertions(+), 495 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 3a87b4e1e..3e106172d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,10 +12,10 @@ CLI tool to generate bindings for WIT documents and the component model. """ [workspace] -resolver = "2" +resolver = "3" [workspace.package] -edition = "2021" +edition = "2024" version = "0.46.0" license = "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT" repository = "https://github.com/bytecodealliance/wit-bindgen" diff --git a/README.md b/README.md index afdee28e0..0100a7808 100644 --- a/README.md +++ b/README.md @@ -406,14 +406,14 @@ MoonBit can be compiled to WebAssembly using [its toolchain](https://moonbitlang moon build --target wasm # --debug to keep symbols ``` -The generated core wasm will be found under `target/wasm/release/build/gen/gen.wasm` by default. Then you can use `wasm-tools` to componentize the module: +The generated core wasm will be found under `target/wasm/release/build/r#gen/r#gen.wasm` by default. Then you can use `wasm-tools` to componentize the module: ``` -wasm-tools component embed wit target/wasm/release/build/gen/gen.wasm -o target/gen.wasm -wasm-tools component new target/gen.wasm -o target/gen.component.wasm +wasm-tools component embed wit target/wasm/release/build/r#gen/r#gen.wasm -o target/r#gen.wasm +wasm-tools component new target/r#gen.wasm -o target/r#gen.component.wasm ``` -You may use `--gen-dir` to specify which package should be responsible for the exportation. The default is `gen` as mentioned above. +You may use `--r#gen-dir` to specify which package should be responsible for the exportation. The default is `r#gen` as mentioned above. This can be useful having one project that exports multiple worlds. When using `wit-bindgen moonbit`, you may use `--derive-show` or `--derive-eq` to derive `Show` or `Eq` traits for all types. diff --git a/crates/cpp/src/lib.rs b/crates/cpp/src/lib.rs index d2e07ac30..f9ef7a8c0 100644 --- a/crates/cpp/src/lib.rs +++ b/crates/cpp/src/lib.rs @@ -293,7 +293,7 @@ impl Cpp { CppInterfaceGenerator { _src: Source::default(), - gen: self, + r#gen: self, resolve, interface: None, _name: name, @@ -493,15 +493,15 @@ impl WorldGenerator for Cpp { self.imported_interfaces.insert(id); let wasm_import_module = resolve.name_world_key(name); let binding = Some(name); - let mut gen = self.interface(resolve, binding, true, Some(wasm_import_module)); - gen.interface = Some(id); - gen.types(id); - let namespace = namespace(resolve, &TypeOwner::Interface(id), false, &gen.gen.opts); + let mut r#gen = self.interface(resolve, binding, true, Some(wasm_import_module)); + r#gen.interface = Some(id); + r#gen.types(id); + let namespace = namespace(resolve, &TypeOwner::Interface(id), false, &r#gen.r#gen.opts); for (_name, func) in resolve.interfaces[id].functions.iter() { if matches!(func.kind, FunctionKind::Freestanding) { - gen.gen.h_src.change_namespace(&namespace); - gen.generate_function(func, &TypeOwner::Interface(id), AbiVariant::GuestImport); + r#gen.r#gen.h_src.change_namespace(&namespace); + r#gen.generate_function(func, &TypeOwner::Interface(id), AbiVariant::GuestImport); } } self.finish_file(&namespace, store); @@ -531,15 +531,15 @@ impl WorldGenerator for Cpp { self.imported_interfaces.remove(&id); let wasm_import_module = resolve.name_world_key(name); let binding = Some(name); - let mut gen = self.interface(resolve, binding, false, Some(wasm_import_module)); - gen.interface = Some(id); - gen.types(id); - let namespace = namespace(resolve, &TypeOwner::Interface(id), true, &gen.gen.opts); + let mut r#gen = self.interface(resolve, binding, false, Some(wasm_import_module)); + r#gen.interface = Some(id); + r#gen.types(id); + let namespace = namespace(resolve, &TypeOwner::Interface(id), true, &r#gen.r#gen.opts); for (_name, func) in resolve.interfaces[id].functions.iter() { if matches!(func.kind, FunctionKind::Freestanding) { - gen.gen.h_src.change_namespace(&namespace); - gen.generate_function(func, &TypeOwner::Interface(id), AbiVariant::GuestExport); + r#gen.r#gen.h_src.change_namespace(&namespace); + r#gen.generate_function(func, &TypeOwner::Interface(id), AbiVariant::GuestExport); } } self.finish_file(&namespace, store); @@ -557,13 +557,13 @@ impl WorldGenerator for Cpp { let name = WorldKey::Name("$root".to_string()); //WorldKey::Name(resolve.worlds[world].name.clone()); let wasm_import_module = resolve.name_world_key(&name); let binding = Some(name); - let mut gen = self.interface(resolve, binding.as_ref(), true, Some(wasm_import_module)); - let namespace = namespace(resolve, &TypeOwner::World(world), false, &gen.gen.opts); + let mut r#gen = self.interface(resolve, binding.as_ref(), true, Some(wasm_import_module)); + let namespace = namespace(resolve, &TypeOwner::World(world), false, &r#gen.r#gen.opts); for (_name, func) in funcs.iter() { if matches!(func.kind, FunctionKind::Freestanding) { - gen.gen.h_src.change_namespace(&namespace); - gen.generate_function(func, &TypeOwner::World(world), AbiVariant::GuestImport); + r#gen.r#gen.h_src.change_namespace(&namespace); + r#gen.generate_function(func, &TypeOwner::World(world), AbiVariant::GuestImport); } } } @@ -577,13 +577,13 @@ impl WorldGenerator for Cpp { ) -> anyhow::Result<()> { let name = WorldKey::Name(resolve.worlds[world].name.clone()); let binding = Some(name); - let mut gen = self.interface(resolve, binding.as_ref(), false, None); - let namespace = namespace(resolve, &TypeOwner::World(world), true, &gen.gen.opts); + let mut r#gen = self.interface(resolve, binding.as_ref(), false, None); + let namespace = namespace(resolve, &TypeOwner::World(world), true, &r#gen.r#gen.opts); for (_name, func) in funcs.iter() { if matches!(func.kind, FunctionKind::Freestanding) { - gen.gen.h_src.change_namespace(&namespace); - gen.generate_function(func, &TypeOwner::World(world), AbiVariant::GuestExport); + r#gen.r#gen.h_src.change_namespace(&namespace); + r#gen.generate_function(func, &TypeOwner::World(world), AbiVariant::GuestExport); } } Ok(()) @@ -786,7 +786,7 @@ impl SourceWithState { struct CppInterfaceGenerator<'a> { _src: Source, - gen: &'a mut Cpp, + r#gen: &'a mut Cpp, resolve: &'a Resolve, interface: Option, _name: Option<&'a WorldKey>, @@ -848,9 +848,9 @@ impl CppInterfaceGenerator<'_> { Default::default(), self.interface .map(TypeOwner::Interface) - .unwrap_or(TypeOwner::World(self.gen.world_id.unwrap())), + .unwrap_or(TypeOwner::World(self.r#gen.world_id.unwrap())), )); - let mut namespace = namespace(self.resolve, &owner, guest_export, &self.gen.opts); + let mut namespace = namespace(self.resolve, &owner, guest_export, &self.r#gen.opts); let is_drop = is_special_method(func); let func_name_h = if !matches!(&func.kind, FunctionKind::Freestanding) { namespace.push(object.clone()); @@ -941,11 +941,11 @@ impl CppInterfaceGenerator<'_> { res }); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, r#"extern "C" __attribute__((__export_name__("{module_prefix}{func_name}")))"# ); let return_via_pointer = false; - self.gen + self.r#gen .c_src .src .push_str(if signature.results.is_empty() || return_via_pointer { @@ -953,39 +953,39 @@ impl CppInterfaceGenerator<'_> { } else { wit_bindgen_c::wasm_type(signature.results[0]) }); - self.gen.c_src.src.push_str(" "); + self.r#gen.c_src.src.push_str(" "); let export_name = match module_name { Some(ref module_name) => make_external_symbol(module_name, &func_name, symbol_variant), None => make_external_component(&func_name), }; - if let Some(prefix) = self.gen.opts.export_prefix.as_ref() { - self.gen.c_src.src.push_str(prefix); + if let Some(prefix) = self.r#gen.opts.export_prefix.as_ref() { + self.r#gen.c_src.src.push_str(prefix); } - self.gen.c_src.src.push_str(&export_name); - self.gen.c_src.src.push_str("("); + self.r#gen.c_src.src.push_str(&export_name); + self.r#gen.c_src.src.push_str("("); let mut first_arg = true; let mut params = Vec::new(); for (n, ty) in signature.params.iter().enumerate() { let name = format!("arg{n}"); if !first_arg { - self.gen.c_src.src.push_str(", "); + self.r#gen.c_src.src.push_str(", "); } else { first_arg = false; } - self.gen.c_src.src.push_str(wit_bindgen_c::wasm_type(*ty)); - self.gen.c_src.src.push_str(" "); - self.gen.c_src.src.push_str(&name); + self.r#gen.c_src.src.push_str(wit_bindgen_c::wasm_type(*ty)); + self.r#gen.c_src.src.push_str(" "); + self.r#gen.c_src.src.push_str(&name); params.push(name); } if return_via_pointer { if !first_arg { - self.gen.c_src.src.push_str(", "); + self.r#gen.c_src.src.push_str(", "); } - self.gen.c_src.src.push_str(self.gen.opts.ptr_type()); - self.gen.c_src.src.push_str(" resultptr"); + self.r#gen.c_src.src.push_str(self.r#gen.opts.ptr_type()); + self.r#gen.c_src.src.push_str(" resultptr"); params.push("resultptr".into()); } - self.gen.c_src.src.push_str(")\n"); + self.r#gen.c_src.src.push_str(")\n"); params } @@ -1074,33 +1074,33 @@ impl CppInterfaceGenerator<'_> { import: bool, ) -> Vec { let is_special = is_special_method(func); - let from_namespace = self.gen.h_src.namespace.clone(); + let from_namespace = self.r#gen.h_src.namespace.clone(); let cpp_sig = self.high_level_signature(func, variant, &from_namespace); if cpp_sig.static_member { - self.gen.h_src.src.push_str("static "); + self.r#gen.h_src.src.push_str("static "); } - self.gen.h_src.src.push_str(&cpp_sig.result); + self.r#gen.h_src.src.push_str(&cpp_sig.result); if !cpp_sig.result.is_empty() { - self.gen.h_src.src.push_str(" "); + self.r#gen.h_src.src.push_str(" "); } - self.gen.h_src.src.push_str(&cpp_sig.name); - self.gen.h_src.src.push_str("("); + self.r#gen.h_src.src.push_str(&cpp_sig.name); + self.r#gen.h_src.src.push_str("("); for (num, (arg, typ)) in cpp_sig.arguments.iter().enumerate() { if num > 0 { - self.gen.h_src.src.push_str(", "); + self.r#gen.h_src.src.push_str(", "); } - self.gen.h_src.src.push_str(typ); - self.gen.h_src.src.push_str(" "); - self.gen.h_src.src.push_str(arg); + self.r#gen.h_src.src.push_str(typ); + self.r#gen.h_src.src.push_str(" "); + self.r#gen.h_src.src.push_str(arg); } - self.gen.h_src.src.push_str(")"); + self.r#gen.h_src.src.push_str(")"); if cpp_sig.const_member { - self.gen.h_src.src.push_str(" const"); + self.r#gen.h_src.src.push_str(" const"); } match (&is_special, false, &variant) { (SpecialMethod::Allocate, _, _) => { uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, "{{\ return {OWNED_CLASS_NAME}(new {}({}));\ }}", @@ -1118,14 +1118,14 @@ impl CppInterfaceGenerator<'_> { (SpecialMethod::Dtor, _, _ /*AbiVariant::GuestImport*/) | (SpecialMethod::ResourceDrop, true, _) => { uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, "{{\ delete {};\ }}", cpp_sig.arguments.first().unwrap().0 ); } - _ => self.gen.h_src.src.push_str(";\n"), + _ => self.r#gen.h_src.src.push_str(";\n"), } // we want to separate the lowered signature (wasm) and the high level signature @@ -1140,33 +1140,33 @@ impl CppInterfaceGenerator<'_> { self.print_export_signature(func, variant) } else { // recalulate with c file namespace - let c_namespace = self.gen.c_src.namespace.clone(); + let c_namespace = self.r#gen.c_src.namespace.clone(); let cpp_sig = self.high_level_signature(func, variant, &c_namespace); let mut params = Vec::new(); - self.gen.c_src.src.push_str(&cpp_sig.result); + self.r#gen.c_src.src.push_str(&cpp_sig.result); if !cpp_sig.result.is_empty() { - self.gen.c_src.src.push_str(" "); + self.r#gen.c_src.src.push_str(" "); } - self.gen.c_src.qualify(&cpp_sig.namespace); - self.gen.c_src.src.push_str(&cpp_sig.name); - self.gen.c_src.src.push_str("("); + self.r#gen.c_src.qualify(&cpp_sig.namespace); + self.r#gen.c_src.src.push_str(&cpp_sig.name); + self.r#gen.c_src.src.push_str("("); if cpp_sig.implicit_self { params.push("(*this)".into()); } for (num, (arg, typ)) in cpp_sig.arguments.iter().enumerate() { if num > 0 { - self.gen.c_src.src.push_str(", "); + self.r#gen.c_src.src.push_str(", "); } - self.gen.c_src.src.push_str(typ); - self.gen.c_src.src.push_str(" "); - self.gen.c_src.src.push_str(arg); + self.r#gen.c_src.src.push_str(typ); + self.r#gen.c_src.src.push_str(" "); + self.r#gen.c_src.src.push_str(arg); params.push(arg.clone()); } - self.gen.c_src.src.push_str(")"); + self.r#gen.c_src.src.push_str(")"); if cpp_sig.const_member { - self.gen.c_src.src.push_str(" const"); + self.r#gen.c_src.src.push_str(" const"); } - self.gen.c_src.src.push_str("\n"); + self.r#gen.c_src.src.push_str("\n"); params } } @@ -1185,7 +1185,7 @@ impl CppInterfaceGenerator<'_> { cifg.resolve, &owner.owner, matches!(variant, AbiVariant::GuestExport), - &cifg.gen.opts, + &cifg.r#gen.opts, ); namespace.push(owner.name.as_ref().unwrap().to_upper_camel_case()); namespace @@ -1201,15 +1201,15 @@ impl CppInterfaceGenerator<'_> { let params = self.print_signature(func, variant, !export); let special = is_special_method(func); if !matches!(special, SpecialMethod::Allocate) { - self.gen.c_src.src.push_str("{\n"); - let needs_dealloc = if self.gen.opts.api_style == APIStyle::Symmetric + self.r#gen.c_src.src.push_str("{\n"); + let needs_dealloc = if self.r#gen.opts.api_style == APIStyle::Symmetric && matches!(variant, AbiVariant::GuestExport) { - self.gen + self.r#gen .c_src .src .push_str("std::vector _deallocate;\n"); - self.gen.dependencies.needs_vector = true; + self.r#gen.dependencies.needs_vector = true; true } else { false @@ -1227,7 +1227,7 @@ impl CppInterfaceGenerator<'_> { let wasm_sig = self.declare_import(&module_name, &func.name, &[WasmType::I32], &[]); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, "{wasm_sig}({});", func.params.first().unwrap().0 ); @@ -1237,7 +1237,7 @@ impl CppInterfaceGenerator<'_> { let name = self.declare_import(&module_name, &func.name, &[WasmType::I32], &[]); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, " if (handle>=0) {{ {name}(handle); }}" @@ -1246,8 +1246,8 @@ impl CppInterfaceGenerator<'_> { }, SpecialMethod::Dtor => { let classname = class_namespace(self, func, variant).join("::"); - uwriteln!(self.gen.c_src.src, "(({classname}*)arg0)->handle=-1;"); - uwriteln!(self.gen.c_src.src, "{0}::Dtor(({0}*)arg0);", classname); + uwriteln!(self.r#gen.c_src.src, "(({classname}*)arg0)->handle=-1;"); + uwriteln!(self.r#gen.c_src.src, "{0}::Dtor(({0}*)arg0);", classname); } SpecialMethod::ResourceNew => { let module_name = @@ -1259,9 +1259,9 @@ impl CppInterfaceGenerator<'_> { &[WasmType::I32], ); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, "return {wasm_sig}(({}){});", - self.gen.opts.ptr_type(), + self.r#gen.opts.ptr_type(), func.params.first().unwrap().0 ); } @@ -1276,7 +1276,7 @@ impl CppInterfaceGenerator<'_> { ); let classname = class_namespace(self, func, variant).join("::"); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, "return ({}*){wasm_sig}({});", classname, func.params.first().unwrap().0 @@ -1290,7 +1290,7 @@ impl CppInterfaceGenerator<'_> { self.resolve, owner, matches!(variant, AbiVariant::GuestExport), - &self.gen.opts, + &self.r#gen.opts, ) } else { let owner = &self.resolve.types[match &func.kind { @@ -1307,7 +1307,7 @@ impl CppInterfaceGenerator<'_> { self.resolve, &owner.owner, matches!(variant, AbiVariant::GuestExport), - &self.gen.opts, + &self.r#gen.opts, ); namespace.push(owner.name.as_ref().unwrap().to_upper_camel_case()); namespace @@ -1319,12 +1319,12 @@ impl CppInterfaceGenerator<'_> { f.variant = variant; f.needs_dealloc = needs_dealloc; f.cabi_post = None; - abi::call(f.gen.resolve, variant, lift_lower, func, &mut f, false); + abi::call(f.r#gen.resolve, variant, lift_lower, func, &mut f, false); let code = String::from(f.src); - self.gen.c_src.src.push_str(&code); + self.r#gen.c_src.src.push_str(&code); } } - self.gen.c_src.src.push_str("}\n"); + self.r#gen.c_src.src.push_str("}\n"); // cabi_post if matches!(variant, AbiVariant::GuestExport) && abi::guest_export_needs_post_return(self.resolve, func) @@ -1344,29 +1344,29 @@ impl CppInterfaceGenerator<'_> { None => make_external_component(&func.name), }; uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, "extern \"C\" __attribute__((__weak__, __export_name__(\"cabi_post_{export_name}\")))" ); - uwrite!(self.gen.c_src.src, "void cabi_post_{import_name}("); + uwrite!(self.r#gen.c_src.src, "void cabi_post_{import_name}("); let mut params = Vec::new(); for (i, result) in sig.results.iter().enumerate() { let name = format!("arg{i}"); uwrite!( - self.gen.c_src.src, + self.r#gen.c_src.src, "{} {name}", wit_bindgen_c::wasm_type(*result) ); params.push(name); } - self.gen.c_src.src.push_str(") {\n"); + self.r#gen.c_src.src.push_str(") {\n"); let mut f = FunctionBindgen::new(self, params.clone()); f.params = params; - abi::post_return(f.gen.resolve, func, &mut f); + abi::post_return(f.r#gen.resolve, func, &mut f); let FunctionBindgen { src, .. } = f; - self.gen.c_src.src.push_str(&src); - self.gen.c_src.src.push_str("}\n"); + self.r#gen.c_src.src.push_str(&src); + self.r#gen.c_src.src.push_str("}\n"); } } } @@ -1394,12 +1394,12 @@ impl CppInterfaceGenerator<'_> { let name = self.scoped_type_name(id, from_namespace, guest_export); if let Flavor::Argument(AbiVariant::GuestImport) = flavor { - match self.gen.opts.ownership { + match self.r#gen.opts.ownership { Ownership::Owning => { format!("{}", name) } Ownership::CoarseBorrowing => { - if self.gen.types.get(id).has_own_handle { + if self.r#gen.types.get(id).has_own_handle { format!("{}", name) } else { format!("{}Param", name) @@ -1421,7 +1421,7 @@ impl CppInterfaceGenerator<'_> { guest_export: bool, ) -> String { let ty = &self.resolve.types[id]; - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); let mut relative = SourceWithState::default(); relative.namespace = Vec::from(from_namespace); relative.qualify(&namespc); @@ -1448,22 +1448,22 @@ impl CppInterfaceGenerator<'_> { Type::F64 => "double".into(), Type::String => match flavor { Flavor::BorrowedArgument => { - self.gen.dependencies.needs_string_view = true; + self.r#gen.dependencies.needs_string_view = true; "std::string_view".into() } Flavor::Argument(var) if matches!(var, AbiVariant::GuestImport) - || self.gen.opts.api_style == APIStyle::Symmetric => + || self.r#gen.opts.api_style == APIStyle::Symmetric => { - self.gen.dependencies.needs_string_view = true; + self.r#gen.dependencies.needs_string_view = true; "std::string_view".into() } Flavor::Argument(AbiVariant::GuestExport) => { - self.gen.dependencies.needs_wit = true; + self.r#gen.dependencies.needs_wit = true; "wit::string".into() } _ => { - self.gen.dependencies.needs_wit = true; + self.r#gen.dependencies.needs_wit = true; "wit::string".into() } }, @@ -1518,7 +1518,7 @@ impl CppInterfaceGenerator<'_> { } a + &self.type_name(b, from_namespace, flavor) }); - self.gen.dependencies.needs_tuple = true; + self.r#gen.dependencies.needs_tuple = true; String::from("std::tuple<") + &types + ">" } TypeDefKind::Variant(_v) => { @@ -1532,14 +1532,14 @@ impl CppInterfaceGenerator<'_> { self.scoped_type_name(*id, from_namespace, guest_export) } TypeDefKind::Option(o) => { - self.gen.dependencies.needs_optional = true; + self.r#gen.dependencies.needs_optional = true; "std::optional<".to_string() + &self.type_name(o, from_namespace, flavor) + ">" } TypeDefKind::Result(r) => { let err_type = r.err.as_ref().map_or(String::from("wit::Void"), |ty| { self.type_name(ty, from_namespace, flavor) }); - self.gen.dependencies.needs_expected = true; + self.r#gen.dependencies.needs_expected = true; "std::expected<".to_string() + &self.optional_type_name(r.ok.as_ref(), from_namespace, flavor) + ", " @@ -1550,16 +1550,16 @@ impl CppInterfaceGenerator<'_> { let inner = self.type_name(ty, from_namespace, flavor); match flavor { Flavor::BorrowedArgument => { - self.gen.dependencies.needs_span = true; + self.r#gen.dependencies.needs_span = true; format!("std::span<{inner} const>") } Flavor::Argument(var) if matches!(var, AbiVariant::GuestImport) - || self.gen.opts.api_style == APIStyle::Symmetric => + || self.r#gen.opts.api_style == APIStyle::Symmetric => { - self.gen.dependencies.needs_span = true; + self.r#gen.dependencies.needs_span = true; // If the list has an owning handle, it must support moving, so can't be const - let constness = if self.gen.types.get(*id).has_own_handle { + let constness = if self.r#gen.types.get(*id).has_own_handle { "" } else { " const" @@ -1567,11 +1567,11 @@ impl CppInterfaceGenerator<'_> { format!("std::span<{inner}{constness}>") } Flavor::Argument(AbiVariant::GuestExport) => { - self.gen.dependencies.needs_wit = true; + self.r#gen.dependencies.needs_wit = true; format!("wit::vector<{inner}>") } _ => { - self.gen.dependencies.needs_wit = true; + self.r#gen.dependencies.needs_wit = true; format!("wit::vector<{inner}>") } } @@ -1621,7 +1621,7 @@ impl CppInterfaceGenerator<'_> { }; let variant = AbiVariant::GuestImport; let (name, code) = self.declare_import2(module_name, name, &args, result, variant); - self.gen.extern_c_decls.push_str(&code); + self.r#gen.extern_c_decls.push_str(&code); name } @@ -1643,10 +1643,10 @@ impl CppInterfaceGenerator<'_> { namespc: &[String], ) { let (flavor, needs_param_type) = { - match self.gen.opts.ownership { + match self.r#gen.opts.ownership { Ownership::Owning => (Flavor::InStruct, false), Ownership::CoarseBorrowing => { - if self.gen.types.get(id).has_own_handle { + if self.r#gen.types.get(id).has_own_handle { (Flavor::InStruct, false) } else { (Flavor::BorrowedArgument, true) @@ -1659,19 +1659,19 @@ impl CppInterfaceGenerator<'_> { if needs_param_type { let pascal = format!("{name}-param").to_pascal_case(); - uwriteln!(self.gen.h_src.src, "struct {pascal} {{"); + uwriteln!(self.r#gen.h_src.src, "struct {pascal} {{"); for field in record.fields.iter() { let typename = self.type_name(&field.ty, namespc, flavor); let fname = field.name.to_snake_case(); - uwriteln!(self.gen.h_src.src, "{typename} {fname};"); + uwriteln!(self.r#gen.h_src.src, "{typename} {fname};"); } - uwriteln!(self.gen.h_src.src, "}};"); + uwriteln!(self.r#gen.h_src.src, "}};"); } } fn is_exported_type(&self, ty: &TypeDef) -> bool { if let TypeOwner::Interface(intf) = ty.owner { - !self.gen.imported_interfaces.contains(&intf) + !self.r#gen.imported_interfaces.contains(&intf) } else { true } @@ -1692,21 +1692,21 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let ty = &self.resolve.types[id]; let guest_export = self.is_exported_type(ty); - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); - if self.gen.is_first_definition(&namespc, &name) { - self.gen.h_src.change_namespace(&namespc); - Self::docs(&mut self.gen.h_src.src, docs); + if self.r#gen.is_first_definition(&namespc, &name) { + self.r#gen.h_src.change_namespace(&namespc); + Self::docs(&mut self.r#gen.h_src.src, docs); let pascal = name.to_pascal_case(); - uwriteln!(self.gen.h_src.src, "struct {pascal} {{"); + uwriteln!(self.r#gen.h_src.src, "struct {pascal} {{"); for field in record.fields.iter() { - Self::docs(&mut self.gen.h_src.src, &field.docs); + Self::docs(&mut self.r#gen.h_src.src, &field.docs); let typename = self.type_name(&field.ty, &namespc, Flavor::InStruct); let fname = field.name.to_snake_case(); - uwriteln!(self.gen.h_src.src, "{typename} {fname};"); + uwriteln!(self.r#gen.h_src.src, "{typename} {fname};"); } - uwriteln!(self.gen.h_src.src, "}};"); + uwriteln!(self.r#gen.h_src.src, "}};"); self.type_record_param(id, name, record, namespc.as_slice()); } } @@ -1719,31 +1719,31 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let type_ = &self.resolve.types[id]; if let TypeOwner::Interface(intf) = type_.owner { - let guest_import = self.gen.imported_interfaces.contains(&intf); + let guest_import = self.r#gen.imported_interfaces.contains(&intf); let definition = !(guest_import); - let store = self.gen.start_new_file(Some(definition)); - let mut world_name = self.gen.world.to_snake_case(); + let store = self.r#gen.start_new_file(Some(definition)); + let mut world_name = self.r#gen.world.to_snake_case(); world_name.push_str("::"); - let namespc = namespace(self.resolve, &type_.owner, !guest_import, &self.gen.opts); + let namespc = namespace(self.resolve, &type_.owner, !guest_import, &self.r#gen.opts); let pascal = name.to_upper_camel_case(); let mut user_filename = namespc.clone(); user_filename.push(pascal.clone()); if definition { uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, r#"/* User class definition file, autogenerated once, then user modified * Updated versions of this file are generated into {pascal}.template. */"# ); } - self.gen.h_src.change_namespace(&namespc); + self.r#gen.h_src.change_namespace(&namespc); if !definition { - self.gen.dependencies.needs_imported_resources = true; + self.r#gen.dependencies.needs_imported_resources = true; } else { - self.gen.dependencies.needs_exported_resources = true; + self.r#gen.dependencies.needs_exported_resources = true; } - self.gen.dependencies.needs_wit = true; + self.r#gen.dependencies.needs_wit = true; let base_type = match (definition, false) { (true, false) => format!("wit::{RESOURCE_EXPORT_BASE_CLASS_NAME}<{pascal}>"), @@ -1756,8 +1756,8 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> (true, true) => format!("wit::{RESOURCE_IMPORT_BASE_CLASS_NAME}<{pascal}>"), }; let derive = format!(" : public {base_type}"); - uwriteln!(self.gen.h_src.src, "class {pascal}{derive} {{\n"); - uwriteln!(self.gen.h_src.src, "public:\n"); + uwriteln!(self.r#gen.h_src.src, "class {pascal}{derive} {{\n"); + uwriteln!(self.r#gen.h_src.src, "public:\n"); let variant = if guest_import { AbiVariant::GuestImport } else { @@ -1816,15 +1816,15 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> if !definition { // consuming constructor from handle (bindings) - uwriteln!(self.gen.h_src.src, "{pascal}({base_type} &&);",); - uwriteln!(self.gen.h_src.src, "{pascal}({pascal}&&) = default;"); + uwriteln!(self.r#gen.h_src.src, "{pascal}({base_type} &&);",); + uwriteln!(self.r#gen.h_src.src, "{pascal}({pascal}&&) = default;"); uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, "{pascal}& operator=({pascal}&&) = default;" ); - self.gen.c_src.qualify(&namespc); + self.r#gen.c_src.qualify(&namespc); uwriteln!( - self.gen.c_src.src, + self.r#gen.c_src.src, "{pascal}::{pascal}({base_type}&&b) : {base_type}(std::move(b)) {{}}" ); } @@ -1860,8 +1860,8 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> }; self.generate_function(&func2, &TypeOwner::Interface(intf), variant); } - uwriteln!(self.gen.h_src.src, "}};\n"); - self.gen.finish_file(&user_filename, store); + uwriteln!(self.r#gen.h_src.src, "}};\n"); + self.r#gen.finish_file(&user_filename, store); } } @@ -1874,22 +1874,22 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let ty = &self.resolve.types[id]; let guest_export = self.is_exported_type(ty); - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); - if self.gen.is_first_definition(&namespc, name) { - self.gen.h_src.change_namespace(&namespc); - Self::docs(&mut self.gen.h_src.src, docs); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); + if self.r#gen.is_first_definition(&namespc, name) { + self.r#gen.h_src.change_namespace(&namespc); + Self::docs(&mut self.r#gen.h_src.src, docs); let pascal = name.to_pascal_case(); let int_repr = wit_bindgen_c::int_repr(wit_bindgen_c::flags_repr(flags)); - uwriteln!(self.gen.h_src.src, "enum class {pascal} : {int_repr} {{"); - uwriteln!(self.gen.h_src.src, "k_None = 0,"); + uwriteln!(self.r#gen.h_src.src, "enum class {pascal} : {int_repr} {{"); + uwriteln!(self.r#gen.h_src.src, "k_None = 0,"); for (n, field) in flags.flags.iter().enumerate() { - Self::docs(&mut self.gen.h_src.src, &field.docs); + Self::docs(&mut self.r#gen.h_src.src, &field.docs); let fname = field.name.to_pascal_case(); - uwriteln!(self.gen.h_src.src, "k{fname} = (1ULL<<{n}),"); + uwriteln!(self.r#gen.h_src.src, "k{fname} = (1ULL<<{n}),"); } - uwriteln!(self.gen.h_src.src, "}};"); + uwriteln!(self.r#gen.h_src.src, "}};"); uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, r#"static inline {pascal} operator|({pascal} a, {pascal} b) {{ return {pascal}({int_repr}(a)|{int_repr}(b)); }} static inline {pascal} operator&({pascal} a, {pascal} b) {{ return {pascal}({int_repr}(a)&{int_repr}(b)); }}"# ); @@ -1915,32 +1915,32 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let ty = &self.resolve.types[id]; let guest_export = self.is_exported_type(ty); - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); - if self.gen.is_first_definition(&namespc, name) { - self.gen.h_src.change_namespace(&namespc); - Self::docs(&mut self.gen.h_src.src, docs); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); + if self.r#gen.is_first_definition(&namespc, name) { + self.r#gen.h_src.change_namespace(&namespc); + Self::docs(&mut self.r#gen.h_src.src, docs); let pascal = name.to_pascal_case(); - uwriteln!(self.gen.h_src.src, "struct {pascal} {{"); + uwriteln!(self.r#gen.h_src.src, "struct {pascal} {{"); let mut inner_namespace = namespc.clone(); inner_namespace.push(pascal.clone()); let mut all_types = String::new(); for case in variant.cases.iter() { - Self::docs(&mut self.gen.h_src.src, &case.docs); + Self::docs(&mut self.r#gen.h_src.src, &case.docs); let case_pascal = case.name.to_pascal_case(); if !all_types.is_empty() { all_types += ", "; } all_types += &case_pascal; - uwrite!(self.gen.h_src.src, "struct {case_pascal} {{"); + uwrite!(self.r#gen.h_src.src, "struct {case_pascal} {{"); if let Some(ty) = case.ty.as_ref() { let typestr = self.type_name(ty, &inner_namespace, Flavor::InStruct); - uwrite!(self.gen.h_src.src, " {typestr} value; ") + uwrite!(self.r#gen.h_src.src, " {typestr} value; ") } - uwriteln!(self.gen.h_src.src, "}};"); + uwriteln!(self.r#gen.h_src.src, "}};"); } - uwriteln!(self.gen.h_src.src, " std::variant<{all_types}> variants;"); - uwriteln!(self.gen.h_src.src, "}};"); - self.gen.dependencies.needs_variant = true; + uwriteln!(self.r#gen.h_src.src, " std::variant<{all_types}> variants;"); + uwriteln!(self.r#gen.h_src.src, "}};"); + self.r#gen.dependencies.needs_variant = true; } } @@ -1973,22 +1973,22 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let ty = &self.resolve.types[id]; let guest_export = self.is_exported_type(ty); - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); - if self.gen.is_first_definition(&namespc, name) { - self.gen.h_src.change_namespace(&namespc); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); + if self.r#gen.is_first_definition(&namespc, name) { + self.r#gen.h_src.change_namespace(&namespc); let pascal = name.to_pascal_case(); - Self::docs(&mut self.gen.h_src.src, docs); + Self::docs(&mut self.r#gen.h_src.src, docs); let int_t = wit_bindgen_c::int_repr(enum_.tag()); - uwriteln!(self.gen.h_src.src, "enum class {pascal} : {int_t} {{"); + uwriteln!(self.r#gen.h_src.src, "enum class {pascal} : {int_t} {{"); for (i, case) in enum_.cases.iter().enumerate() { - Self::docs(&mut self.gen.h_src.src, &case.docs); + Self::docs(&mut self.r#gen.h_src.src, &case.docs); uwriteln!( - self.gen.h_src.src, + self.r#gen.h_src.src, " k{} = {i},", case.name.to_pascal_case(), ); } - uwriteln!(self.gen.h_src.src, "}};\n"); + uwriteln!(self.r#gen.h_src.src, "}};\n"); } } @@ -2001,12 +2001,12 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> ) { let ty = &self.resolve.types[id]; let guest_export = self.is_exported_type(ty); - let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.gen.opts); - self.gen.h_src.change_namespace(&namespc); + let namespc = namespace(self.resolve, &ty.owner, guest_export, &self.r#gen.opts); + self.r#gen.h_src.change_namespace(&namespc); let pascal = name.to_pascal_case(); - Self::docs(&mut self.gen.h_src.src, docs); + Self::docs(&mut self.r#gen.h_src.src, docs); let typename = self.type_name(alias_type, &namespc, Flavor::InStruct); - uwriteln!(self.gen.h_src.src, "using {pascal} = {typename};"); + uwriteln!(self.r#gen.h_src.src, "using {pascal} = {typename};"); } fn type_list( @@ -2045,7 +2045,7 @@ struct CabiPostInformation { } struct FunctionBindgen<'a, 'b> { - gen: &'b mut CppInterfaceGenerator<'a>, + r#gen: &'b mut CppInterfaceGenerator<'a>, params: Vec, tmp: usize, namespace: Vec, @@ -2062,9 +2062,9 @@ struct FunctionBindgen<'a, 'b> { } impl<'a, 'b> FunctionBindgen<'a, 'b> { - fn new(gen: &'b mut CppInterfaceGenerator<'a>, params: Vec) -> Self { + fn new(r#gen: &'b mut CppInterfaceGenerator<'a>, params: Vec) -> Self { Self { - gen, + r#gen, params, tmp: 0, namespace: Default::default(), @@ -2175,7 +2175,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { match inst { abi::Instruction::GetArg { nth } => { if *nth == 0 && self.params[0].as_str() == "self" { - if self.gen.in_guest_import { + if self.r#gen.in_guest_import { results.push("(*this)".to_string()); } else { results.push("(*lookup_resource(self))".to_string()); @@ -2188,7 +2188,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { abi::Instruction::Bitcasts { casts } => { for (cast, op) in casts.iter().zip(operands) { // let op = op; - results.push(self.gen.gen.perform_cast(op, cast)); + results.push(self.r#gen.r#gen.perform_cast(op, cast)); } } abi::Instruction::ConstZero { tys } => { @@ -2269,7 +2269,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { self.push_str(&format!( "auto {} = ({})({}.data());\n", ptr, - self.gen.gen.opts.ptr_type(), + self.r#gen.r#gen.opts.ptr_type(), val )); self.push_str(&format!("auto {} = (size_t)({}.size());\n", len, val)); @@ -2290,7 +2290,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { self.push_str(&format!( "auto {} = ({})({}.data());\n", ptr, - self.gen.gen.opts.ptr_type(), + self.r#gen.r#gen.opts.ptr_type(), val )); self.push_str(&format!("auto {} = (size_t)({}.size());\n", len, val)); @@ -2308,12 +2308,12 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { let val = format!("vec{}", tmp); let ptr = format!("ptr{}", tmp); let len = format!("len{}", tmp); - let size = self.gen.sizes.size(element); + let size = self.r#gen.sizes.size(element); self.push_str(&format!("auto&& {} = {};\n", val, operands[0])); self.push_str(&format!( "auto {} = ({})({}.data());\n", ptr, - self.gen.gen.opts.ptr_type(), + self.r#gen.r#gen.opts.ptr_type(), val )); self.push_str(&format!("auto {} = (size_t)({}.size());\n", len, val)); @@ -2337,10 +2337,10 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { let tmp = self.tmp(); let len = format!("len{}", tmp); let inner = self - .gen + .r#gen .type_name(element, &self.namespace, Flavor::InStruct); self.push_str(&format!("auto {} = {};\n", len, operands[1])); - let result = if self.gen.gen.opts.api_style == APIStyle::Symmetric + let result = if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { format!( @@ -2356,7 +2356,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { let tmp = self.tmp(); let len = format!("len{}", tmp); uwriteln!(self.src, "auto {} = {};\n", len, operands[1]); - let result = if self.gen.gen.opts.api_style == APIStyle::Symmetric + let result = if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { assert!(self.needs_dealloc); @@ -2374,16 +2374,16 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { abi::Instruction::ListLift { element, .. } => { let body = self.blocks.pop().unwrap(); let tmp = self.tmp(); - let size = self.gen.sizes.size(element); - let _align = self.gen.sizes.align(element); - let flavor = if self.gen.gen.opts.api_style == APIStyle::Symmetric + let size = self.r#gen.sizes.size(element); + let _align = self.r#gen.sizes.align(element); + let flavor = if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { Flavor::BorrowedArgument } else { Flavor::InStruct }; - let vtype = self.gen.type_name(element, &self.namespace, flavor); + let vtype = self.r#gen.type_name(element, &self.namespace, flavor); let len = format!("len{tmp}"); let base = format!("base{tmp}"); let result = format!("result{tmp}"); @@ -2400,7 +2400,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { "#, )); - if self.gen.gen.opts.api_style == APIStyle::Symmetric + if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { assert!(self.needs_dealloc); @@ -2423,11 +2423,11 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { uwriteln!(self.src, "{result}.initialize(i, std::move(e{tmp}));"); uwriteln!(self.src, "}}"); - if self.gen.gen.opts.api_style == APIStyle::Symmetric + if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { results.push(format!("{result}.get_const_view()")); - if self.gen.gen.opts.api_style == APIStyle::Symmetric + if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { self.leak_on_insertion.replace(format!( @@ -2448,7 +2448,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } abi::Instruction::RecordLift { record, ty, .. } => { let mut result = - self.gen + self.r#gen .type_name(&Type::Id(*ty), &self.namespace, Flavor::InStruct); result.push('{'); for (_field, val) in record.fields.iter().zip(operands) { @@ -2490,7 +2490,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { AbiVariant::GuestImport => { let tmp = self.tmp(); let var = self.tempname("obj", tmp); - let tname = self.gen.type_name( + let tname = self.r#gen.type_name( &Type::Id(*ty), &self.namespace, Flavor::Argument(self.variant), @@ -2513,7 +2513,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { AbiVariant::GuestExport => { let tmp = self.tmp(); let var = self.tempname("obj", tmp); - let tname = self.gen.type_name( + let tname = self.r#gen.type_name( &Type::Id(*ty), &self.namespace, Flavor::Argument(self.variant), @@ -2530,7 +2530,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { AbiVariant::GuestExportAsyncStackful => todo!(), }, (Handle::Borrow(ty), true) => { - let tname = self.gen.type_name( + let tname = self.r#gen.type_name( &Type::Id(*ty), &self.namespace, Flavor::Argument(self.variant), @@ -2540,7 +2540,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { (Handle::Borrow(ty), false) => match self.variant { AbiVariant::GuestImport => results.push(op.clone()), AbiVariant::GuestExport => { - let tname = self.gen.type_name( + let tname = self.r#gen.type_name( &Type::Id(*ty), &self.namespace, Flavor::Argument(self.variant), @@ -2566,7 +2566,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { &(tuple .types .iter() - .map(|t| self.gen.type_name(t, &self.namespace, Flavor::InStruct))) + .map(|t| self.r#gen.type_name(t, &self.namespace, Flavor::InStruct))) .collect::>() .join(", "), ); @@ -2582,7 +2582,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } Int::U64 => { let name = - self.gen + self.r#gen .type_name(&Type::Id(*ty), &self.namespace, Flavor::InStruct); let tmp = self.tmp(); let tempname = self.tempname("flags", tmp); @@ -2596,7 +2596,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } abi::Instruction::FlagsLift { flags, ty, .. } => { let typename = - self.gen + self.r#gen .type_name(&Type::Id(*ty), &self.namespace, Flavor::InStruct); match wit_bindgen_c::flags_repr(flags) { Int::U8 | Int::U16 | Int::U32 => { @@ -2645,7 +2645,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { let expr_to_match = format!("({}).variants.index()", operands[0]); let elem_ns = - self.gen + self.r#gen .type_name(&Type::Id(*var_ty), &self.namespace, Flavor::InStruct); uwriteln!(self.src, "switch ((int32_t) {}) {{", expr_to_match); @@ -2654,7 +2654,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { { uwriteln!(self.src, "case {}: {{", i); if let Some(ty) = case.ty.as_ref() { - let ty = self.gen.type_name(ty, &self.namespace, Flavor::InStruct); + let ty = self.r#gen.type_name(ty, &self.namespace, Flavor::InStruct); let case = format!("{elem_ns}::{}", case.name.to_pascal_case()); uwriteln!( self.src, @@ -2681,7 +2681,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { .collect::>(); let ty = self - .gen + .r#gen .type_name(&Type::Id(*ty), &self.namespace, Flavor::InStruct); let resultno = self.tmp(); let result = format!("variant{resultno}"); @@ -2710,7 +2710,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { abi::Instruction::EnumLower { .. } => results.push(format!("int32_t({})", operands[0])), abi::Instruction::EnumLift { ty, .. } => { let typename = - self.gen + self.r#gen .type_name(&Type::Id(*ty), &self.namespace, Flavor::InStruct); results.push(format!("({typename}){}", &operands[0])); } @@ -2744,7 +2744,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } else { Flavor::InStruct }; - let ty = self.gen.type_name(payload, &self.namespace, flavor); + let ty = self.r#gen.type_name(payload, &self.namespace, flavor); let bind_some = format!("{ty} {some_payload} = (std::move({op0})).value();"); uwrite!( @@ -2762,14 +2762,14 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { let (_none, none_results) = self.blocks.pop().unwrap(); assert!(none_results.is_empty()); assert!(some_results.len() == 1); - let flavor = if self.gen.gen.opts.api_style == APIStyle::Symmetric + let flavor = if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric && matches!(self.variant, AbiVariant::GuestExport) { Flavor::BorrowedArgument } else { Flavor::InStruct }; - let type_name = self.gen.type_name(payload, &self.namespace, flavor); + let type_name = self.r#gen.type_name(payload, &self.namespace, flavor); let full_type = format!("std::optional<{type_name}>"); let op0 = &operands[0]; @@ -2811,12 +2811,12 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } let op0 = &operands[0]; - let ok_ty = self.gen.optional_type_name( + let ok_ty = self.r#gen.optional_type_name( result.ok.as_ref(), &self.namespace, Flavor::InStruct, ); - let err_ty = self.gen.optional_type_name( + let err_ty = self.r#gen.optional_type_name( result.err.as_ref(), &self.namespace, Flavor::InStruct, @@ -2855,18 +2855,18 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } if result.err.is_none() { err.clear(); - self.gen.gen.dependencies.needs_wit = true; + self.r#gen.r#gen.dependencies.needs_wit = true; err_result = String::from("wit::Void{}"); } else { err_result = move_if_necessary(&err_results[0]); } - let ok_type = self.gen.optional_type_name( + let ok_type = self.r#gen.optional_type_name( result.ok.as_ref(), &self.namespace, Flavor::InStruct, ); let err_type = result.err.as_ref().map_or(String::from("wit::Void"), |ty| { - self.gen.type_name(ty, &self.namespace, Flavor::InStruct) + self.r#gen.type_name(ty, &self.namespace, Flavor::InStruct) }); let full_type = format!("std::expected<{ok_type}, {err_type}>",); let err_type = "std::unexpected"; @@ -2894,12 +2894,12 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } abi::Instruction::CallWasm { name, sig } => { let module_name = self - .gen + .r#gen .wasm_import_module .as_ref() .map(|e| { - self.gen - .gen + self.r#gen + .r#gen .import_prefix .as_ref() .cloned() @@ -2909,7 +2909,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { .unwrap(); let func = self - .gen + .r#gen .declare_import(&module_name, name, &sig.params, &sig.results); // ... then call the function with all our operands @@ -2925,7 +2925,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { abi::Instruction::CallInterface { func, .. } => { // dbg!(func); self.let_results(if func.result.is_some() { 1 } else { 0 }, results); - let (namespace, func_name_h) = self.gen.func_namespace_name(func, true, true); + let (namespace, func_name_h) = self.r#gen.func_namespace_name(func, true, true); if matches!(func.kind, FunctionKind::Method(_)) { let this = operands.remove(0); uwrite!(self.src, "({this}).get()."); @@ -2953,7 +2953,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { assert!(*amt == operands.len()); match &func.kind { FunctionKind::Constructor(_) - if self.gen.gen.opts.is_only_handle(self.variant) => + if self.r#gen.r#gen.opts.is_only_handle(self.variant) => { // strange but works if matches!(self.variant, AbiVariant::GuestExport) { @@ -2990,7 +2990,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { ret_type: _cabi_post_type, }) = self.cabi_post.as_ref() { - let cabi_post_name = self.gen.declare_import( + let cabi_post_name = self.r#gen.declare_import( &format!("cabi_post_{func_module}"), func_name, &[WasmType::Pointer], @@ -2999,7 +2999,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { self.src.push_str(&format!(", ret, {})", cabi_post_name)); } if matches!(func.kind, FunctionKind::Constructor(_)) - && self.gen.gen.opts.is_only_handle(self.variant) + && self.r#gen.r#gen.opts.is_only_handle(self.variant) { // we wrapped the handle in an object, so unpack it @@ -3032,7 +3032,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { uwriteln!(self.src, "size_t {len} = {};", operands[1]); let i = self.tempname("i", tmp); uwriteln!(self.src, "for (size_t {i} = 0; {i} < {len}; {i}++) {{"); - let size = self.gen.sizes.size(element); + let size = self.r#gen.sizes.size(element); uwriteln!( self.src, "uint8_t* base = {ptr} + {i} * {size};", @@ -3061,14 +3061,14 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { self.src.push_str("}\n"); } abi::Instruction::PointerLoad { offset } => { - let ptr_type = self.gen.gen.opts.ptr_type(); + let ptr_type = self.r#gen.r#gen.opts.ptr_type(); self.load(ptr_type, *offset, operands, results) } abi::Instruction::LengthLoad { offset } => { self.load("size_t", *offset, operands, results) } abi::Instruction::PointerStore { offset } => { - let ptr_type = self.gen.gen.opts.ptr_type(); + let ptr_type = self.r#gen.r#gen.opts.ptr_type(); self.store(ptr_type, *offset, operands) } abi::Instruction::LengthStore { offset } => self.store("size_t", *offset, operands), @@ -3104,7 +3104,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { }, Alignment::Pointer => "uintptr_t", }; - let static_var = if self.gen.in_guest_import { + let static_var = if self.r#gen.in_guest_import { "" } else { "static " @@ -3116,7 +3116,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { uwriteln!( self.src, "{} ptr{tmp} = ({0})(&ret_area);", - self.gen.gen.opts.ptr_type(), + self.r#gen.r#gen.opts.ptr_type(), ); format!("ptr{}", tmp) @@ -3134,7 +3134,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { } fn sizes(&self) -> &wit_bindgen_core::wit_parser::SizeAlign { - &self.gen.sizes + &self.r#gen.sizes } fn is_list_canonical( @@ -3146,7 +3146,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> { return false; } match ty { - Type::Id(id) => !self.gen.gen.types.get(*id).has_resource, + Type::Id(id) => !self.r#gen.r#gen.types.get(*id).has_resource, _ => true, } } diff --git a/crates/csharp/src/function.rs b/crates/csharp/src/function.rs index 3272480f2..30c8763bf 100644 --- a/crates/csharp/src/function.rs +++ b/crates/csharp/src/function.rs @@ -163,7 +163,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { .drain(self.blocks.len() - cases.len()..) .collect::>(); let ty = self.interface_gen.type_name_with_qualifier(ty, true); - //let ty = self.gen.type_name(ty); + //let ty = self.r#gen.type_name(ty); let generics_position = ty.find('<'); let lifted = self.locals.tmp("lifted"); diff --git a/crates/csharp/src/world_generator.rs b/crates/csharp/src/world_generator.rs index e8a31fc98..79dffc4c8 100644 --- a/crates/csharp/src/world_generator.rs +++ b/crates/csharp/src/world_generator.rs @@ -104,13 +104,13 @@ impl WorldGenerator for CSharp { ) -> anyhow::Result<()> { let name = interface_name(self, resolve, key, Direction::Import); self.interface_names.insert(id, name.clone()); - let mut gen = self.interface(resolve, &name, Direction::Import); + let mut r#gen = self.interface(resolve, &name, Direction::Import); - let mut old_resources = mem::take(&mut gen.csharp_gen.all_resources); - gen.types(id); - let new_resources = mem::take(&mut gen.csharp_gen.all_resources); + let mut old_resources = mem::take(&mut r#gen.csharp_gen.all_resources); + r#gen.types(id); + let new_resources = mem::take(&mut r#gen.csharp_gen.all_resources); old_resources.extend(new_resources.clone()); - gen.csharp_gen.all_resources = old_resources; + r#gen.csharp_gen.all_resources = old_resources; for (resource, funcs) in by_resource( resolve.interfaces[id] @@ -120,23 +120,23 @@ impl WorldGenerator for CSharp { new_resources.keys().copied(), ) { if let Some(resource) = resource { - gen.start_resource(resource, Some(key)); + r#gen.start_resource(resource, Some(key)); } let import_module_name = &resolve.name_world_key(key); for func in funcs { - gen.import(import_module_name, func); + r#gen.import(import_module_name, func); } if resource.is_some() { - gen.end_resource(); + r#gen.end_resource(); } } // for anonymous types - gen.define_interface_types(id); + r#gen.define_interface_types(id); - gen.add_interface_fragment(false); + r#gen.add_interface_fragment(false); Ok(()) } @@ -152,26 +152,26 @@ impl WorldGenerator for CSharp { let name = &format!("{}-world", resolve.worlds[world].name).to_upper_camel_case(); let name = &format!("{name}.I{name}"); - let mut gen = self.interface(resolve, name, Direction::Import); + let mut r#gen = self.interface(resolve, name, Direction::Import); for (resource, funcs) in by_resource( funcs.iter().copied(), - gen.csharp_gen.world_resources.keys().copied(), + r#gen.csharp_gen.world_resources.keys().copied(), ) { if let Some(resource) = resource { - gen.start_resource(resource, None); + r#gen.start_resource(resource, None); } for func in funcs { - gen.import("$root", func); + r#gen.import("$root", func); } if resource.is_some() { - gen.end_resource(); + r#gen.end_resource(); } } - gen.add_world_fragment(); + r#gen.add_world_fragment(); } fn export_interface( @@ -183,13 +183,13 @@ impl WorldGenerator for CSharp { ) -> anyhow::Result<()> { let name = interface_name(self, resolve, key, Direction::Export); self.interface_names.insert(id, name.clone()); - let mut gen = self.interface(resolve, &name, Direction::Export); + let mut r#gen = self.interface(resolve, &name, Direction::Export); - let mut old_resources = mem::take(&mut gen.csharp_gen.all_resources); - gen.types(id); - let new_resources = mem::take(&mut gen.csharp_gen.all_resources); + let mut old_resources = mem::take(&mut r#gen.csharp_gen.all_resources); + r#gen.types(id); + let new_resources = mem::take(&mut r#gen.csharp_gen.all_resources); old_resources.extend(new_resources.clone()); - gen.csharp_gen.all_resources = old_resources; + r#gen.csharp_gen.all_resources = old_resources; for (resource, funcs) in by_resource( resolve.interfaces[id] @@ -199,22 +199,22 @@ impl WorldGenerator for CSharp { new_resources.keys().copied(), ) { if let Some(resource) = resource { - gen.start_resource(resource, Some(key)); + r#gen.start_resource(resource, Some(key)); } for func in funcs { - gen.export(func, Some(key)); + r#gen.export(func, Some(key)); } if resource.is_some() { - gen.end_resource(); + r#gen.end_resource(); } } // for anonymous types - gen.define_interface_types(id); + r#gen.define_interface_types(id); - gen.add_interface_fragment(true); + r#gen.add_interface_fragment(true); Ok(()) } @@ -227,23 +227,23 @@ impl WorldGenerator for CSharp { ) -> anyhow::Result<()> { let name = &format!("{}-world", resolve.worlds[world].name).to_upper_camel_case(); let name = &format!("{name}.I{name}"); - let mut gen = self.interface(resolve, name, Direction::Export); + let mut r#gen = self.interface(resolve, name, Direction::Export); for (resource, funcs) in by_resource(funcs.iter().copied(), iter::empty()) { if let Some(resource) = resource { - gen.start_resource(resource, None); + r#gen.start_resource(resource, None); } for func in funcs { - gen.export(func, None); + r#gen.export(func, None); } if resource.is_some() { - gen.end_resource(); + r#gen.end_resource(); } } - gen.add_world_fragment(); + r#gen.add_world_fragment(); Ok(()) } @@ -256,18 +256,18 @@ impl WorldGenerator for CSharp { ) { let name = &format!("{}-world", resolve.worlds[world].name).to_upper_camel_case(); let name = &format!("{name}.I{name}"); - let mut gen = self.interface(resolve, name, Direction::Import); + let mut r#gen = self.interface(resolve, name, Direction::Import); - let mut old_resources = mem::take(&mut gen.csharp_gen.all_resources); + let mut old_resources = mem::take(&mut r#gen.csharp_gen.all_resources); for (ty_name, ty) in types { - gen.define_type(ty_name, *ty); + r#gen.define_type(ty_name, *ty); } - let new_resources = mem::take(&mut gen.csharp_gen.all_resources); + let new_resources = mem::take(&mut r#gen.csharp_gen.all_resources); old_resources.extend(new_resources.clone()); - gen.csharp_gen.all_resources = old_resources; - gen.csharp_gen.world_resources = new_resources; + r#gen.csharp_gen.all_resources = old_resources; + r#gen.csharp_gen.world_resources = new_resources; - gen.add_world_fragment(); + r#gen.add_world_fragment(); } fn finish(&mut self, resolve: &Resolve, id: WorldId, files: &mut Files) -> anyhow::Result<()> { diff --git a/crates/markdown/src/lib.rs b/crates/markdown/src/lib.rs index c6cd78fb4..7485ae635 100644 --- a/crates/markdown/src/lib.rs +++ b/crates/markdown/src/lib.rs @@ -52,63 +52,63 @@ impl WorldGenerator for Markdown { format!("#{}", world.name.to_snake_case()), ); - let mut gen = self.interface(resolve); + let mut r#gen = self.interface(resolve); - gen.docs(&world.docs); - gen.push_str("\n"); + r#gen.docs(&world.docs); + r#gen.push_str("\n"); // Produce a table of contents for the world. let mut first = true; for (name, import) in &world.imports { if first { - gen.push_str(" - Imports:\n"); + r#gen.push_str(" - Imports:\n"); first = false; } let name = &resolve.name_world_key(name); match import { WorldItem::Interface { .. } => { - gen.push_str(" - interface `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - interface `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } WorldItem::Function(_) => { - gen.push_str(" - function `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - function `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } WorldItem::Type(_) => { - gen.push_str(" - type `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - type `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } } } let mut first = true; for (name, export) in &world.exports { if first { - gen.push_str(" - Exports:\n"); + r#gen.push_str(" - Exports:\n"); first = false; } let name = &resolve.name_world_key(name); match export { WorldItem::Interface { .. } => { - gen.push_str(" - interface `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - interface `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } WorldItem::Function(_) => { - gen.push_str(" - function `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - function `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } WorldItem::Type(_) => { - gen.push_str(" - type `"); - gen.push_str(name); - gen.push_str("`\n"); + r#gen.push_str(" - type `"); + r#gen.push_str(name); + r#gen.push_str("`\n"); } } } - gen.push_str("\n"); + r#gen.push_str("\n"); } fn import_interface( @@ -126,11 +126,11 @@ impl WorldGenerator for Markdown { ); self.hrefs .insert(name.to_string(), format!("#{}", name.to_snake_case())); - let mut gen = self.interface(resolve); - gen.docs(&resolve.interfaces[id].docs); - gen.push_str("\n"); - gen.types(id); - gen.funcs(id); + let mut r#gen = self.interface(resolve); + r#gen.docs(&resolve.interfaces[id].docs); + r#gen.push_str("\n"); + r#gen.types(id); + r#gen.funcs(id); Ok(()) } @@ -144,9 +144,9 @@ impl WorldGenerator for Markdown { ) { let name = &resolve.worlds[world].name; uwriteln!(self.src, "## Imported functions to world `{name}`\n"); - let mut gen = self.interface(resolve); + let mut r#gen = self.interface(resolve); for (_, func) in funcs { - gen.func(func); + r#gen.func(func); } } @@ -165,9 +165,9 @@ impl WorldGenerator for Markdown { ); self.hrefs .insert(name.to_string(), format!("#{}", name.to_snake_case())); - let mut gen = self.interface(resolve); - gen.types(id); - gen.funcs(id); + let mut r#gen = self.interface(resolve); + r#gen.types(id); + r#gen.funcs(id); Ok(()) } @@ -180,9 +180,9 @@ impl WorldGenerator for Markdown { ) -> Result<()> { let name = &resolve.worlds[world].name; uwriteln!(self.src, "## Exported functions from world `{name}`\n"); - let mut gen = self.interface(resolve); + let mut r#gen = self.interface(resolve); for (_, func) in funcs { - gen.func(func); + r#gen.func(func); } Ok(()) } @@ -196,9 +196,9 @@ impl WorldGenerator for Markdown { ) { let name = &resolve.worlds[world].name; uwriteln!(self.src, "## Exported types from world `{name}`\n"); - let mut gen = self.interface(resolve); + let mut r#gen = self.interface(resolve); for (name, ty) in types { - gen.define_type(name, *ty); + r#gen.define_type(name, *ty); } } @@ -237,7 +237,7 @@ impl WorldGenerator for Markdown { impl Markdown { fn interface<'a>(&'a mut self, resolve: &'a Resolve) -> InterfaceGenerator<'a> { InterfaceGenerator { - gen: self, + r#gen: self, resolve, types_header_printed: false, } @@ -245,7 +245,7 @@ impl Markdown { } struct InterfaceGenerator<'a> { - gen: &'a mut Markdown, + r#gen: &'a mut Markdown, resolve: &'a Resolve, types_header_printed: bool, } @@ -268,7 +268,7 @@ impl InterfaceGenerator<'_> { "#### `", func.name.to_snake_case() )); - self.gen + self.r#gen .hrefs .insert(func.name.clone(), format!("#{}", func.name.to_snake_case())); self.push_str(&func.name); @@ -305,7 +305,7 @@ impl InterfaceGenerator<'_> { } fn push_str(&mut self, s: &str) { - self.gen.src.push_str(s); + self.r#gen.src.push_str(s); } fn print_ty(&mut self, ty: &Type) { @@ -448,7 +448,7 @@ impl InterfaceGenerator<'_> { type_, name, )); - self.gen + self.r#gen .hrefs .insert(name.to_string(), format!("#{}", name.to_snake_case())); } @@ -471,16 +471,16 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { f = field.name.to_snake_case(), name = field.name, )); - self.gen.hrefs.insert( + self.r#gen.hrefs.insert( format!("{}::{}", name, field.name), format!("#{}.{}", name.to_snake_case(), field.name.to_snake_case()), ); self.print_ty(&field.ty); if field.docs.contents.is_some() { - self.gen.src.indent(1); + self.r#gen.src.indent(1); self.push_str("\n

"); self.docs(&field.docs); - self.gen.src.deindent(1); + self.r#gen.src.deindent(1); } self.push_str("\n"); } @@ -505,7 +505,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { f = i, name = i, )); - self.gen.hrefs.insert( + self.r#gen.hrefs.insert( format!("{}::{}", name, i), format!("#{}.{}", name.to_snake_case(), i), ); @@ -527,15 +527,15 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { f = flag.name.to_snake_case(), name = flag.name, )); - self.gen.hrefs.insert( + self.r#gen.hrefs.insert( format!("{}::{}", name, flag.name), format!("#{}.{}", name.to_snake_case(), flag.name.to_snake_case()), ); if flag.docs.contents.is_some() { - self.gen.src.indent(1); + self.r#gen.src.indent(1); self.push_str("\n

"); self.docs(&flag.docs); - self.gen.src.deindent(1); + self.r#gen.src.deindent(1); } self.push_str("\n"); } @@ -554,7 +554,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { c = case.name.to_snake_case(), name = case.name, )); - self.gen.hrefs.insert( + self.r#gen.hrefs.insert( format!("{}::{}", name, case.name), format!("#{}.{}", name.to_snake_case(), case.name.to_snake_case()), ); @@ -563,10 +563,10 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { self.print_ty(ty); } if case.docs.contents.is_some() { - self.gen.src.indent(1); + self.r#gen.src.indent(1); self.push_str("\n

"); self.docs(&case.docs); - self.gen.src.deindent(1); + self.r#gen.src.deindent(1); } self.push_str("\n"); } @@ -585,15 +585,15 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { c = case.name.to_snake_case(), name = case.name, )); - self.gen.hrefs.insert( + self.r#gen.hrefs.insert( format!("{}::{}", name, case.name), format!("#{}.{}", name.to_snake_case(), case.name.to_snake_case()), ); if case.docs.contents.is_some() { - self.gen.src.indent(1); + self.r#gen.src.indent(1); self.push_str("\n

"); self.docs(&case.docs); - self.gen.src.deindent(1); + self.r#gen.src.deindent(1); } self.push_str("\n"); } diff --git a/crates/moonbit/src/lib.rs b/crates/moonbit/src/lib.rs index bdc05de49..cba8437d0 100644 --- a/crates/moonbit/src/lib.rs +++ b/crates/moonbit/src/lib.rs @@ -25,7 +25,7 @@ use wit_bindgen_core::{ // - Lift/Lower list: T == Int/UInt/Int64/UInt64/Float/Double -> FixedArray[T], T == Byte -> Bytes, T == Char -> String // Organization: // - one package per interface (export and import are treated as different interfaces) -// - ffi utils are under `./ffi`, and the project entrance (package as link target) is under `./gen` +// - ffi utils are under `./ffi`, and the project entrance (package as link target) is under `./r#gen` // TODO: Export will share the type signatures with the import by using a newtype alias pub(crate) const FFI_DIR: &str = "ffi"; @@ -68,7 +68,7 @@ pub struct Opts { pub ignore_module_file: bool, /// The package/dir to generate the program entrance - #[cfg_attr(feature = "clap", arg(long, default_value = "gen"))] + #[cfg_attr(feature = "clap", arg(long, default_value = "r#gen"))] pub gen_dir: String, /// The project name ; or the package path prefix if the project is part of a larger project @@ -148,7 +148,7 @@ impl MoonBit { src: String::new(), stub: String::new(), ffi: String::new(), - gen: self, + r#gen: self, resolve, name, module, @@ -184,14 +184,14 @@ impl WorldGenerator for MoonBit { } let module = &resolve.name_world_key(key); - let mut gen = self.interface(resolve, &name, module, Direction::Import); - gen.types(id); + let mut r#gen = self.interface(resolve, &name, module, Direction::Import); + r#gen.types(id); for (_, func) in resolve.interfaces[id].functions.iter() { - gen.import(Some(key), func); + r#gen.import(Some(key), func); } - gen.add_interface_fragment(); + r#gen.add_interface_fragment(); Ok(()) } @@ -204,13 +204,13 @@ impl WorldGenerator for MoonBit { _files: &mut Files, ) { let name = world_name(resolve, world); - let mut gen = self.interface(resolve, &name, "$root", Direction::Import); + let mut r#gen = self.interface(resolve, &name, "$root", Direction::Import); for (_, func) in funcs { - gen.import(None, func); // None is "$root" + r#gen.import(None, func); // None is "$root" } - gen.add_world_fragment(); + r#gen.add_world_fragment(); } fn export_interface( @@ -234,14 +234,14 @@ impl WorldGenerator for MoonBit { } let module = &resolve.name_world_key(key); - let mut gen = self.interface(resolve, &name, module, Direction::Export); - gen.types(id); + let mut r#gen = self.interface(resolve, &name, module, Direction::Export); + r#gen.types(id); for (_, func) in resolve.interfaces[id].functions.iter() { - gen.export(Some(key), func, Some(name.clone())); + r#gen.export(Some(key), func, Some(name.clone())); } - gen.add_interface_fragment(); + r#gen.add_interface_fragment(); Ok(()) } @@ -253,13 +253,13 @@ impl WorldGenerator for MoonBit { _files: &mut Files, ) -> Result<()> { let name = format!("{}.{}", self.opts.gen_dir, world_name(resolve, world)); - let mut gen = self.interface(resolve, &name, "$root", Direction::Export); + let mut r#gen = self.interface(resolve, &name, "$root", Direction::Export); for (_, func) in funcs { - gen.export(None, func, Some(name.clone())); + r#gen.export(None, func, Some(name.clone())); } - gen.add_world_fragment(); + r#gen.add_world_fragment(); Ok(()) } @@ -271,13 +271,13 @@ impl WorldGenerator for MoonBit { _files: &mut Files, ) { let name = world_name(resolve, world); - let mut gen = self.interface(resolve, &name, "$root", Direction::Import); + let mut r#gen = self.interface(resolve, &name, "$root", Direction::Import); for (ty_name, ty) in types { - gen.define_type(ty_name, *ty); + r#gen.define_type(ty_name, *ty); } - gen.add_world_fragment(); + r#gen.add_world_fragment(); } fn finish(&mut self, resolve: &Resolve, id: WorldId, files: &mut Files) -> Result<()> { @@ -465,8 +465,8 @@ impl WorldGenerator for MoonBit { let export_dir = self.opts.gen_dir.clone(); // Export project entry point - let mut gen = self.interface(resolve, export_dir.as_str(), "", Direction::Export); - let ffi_qualifier = gen.qualify_package(FFI_DIR); + let mut r#gen = self.interface(resolve, export_dir.as_str(), "", Direction::Export); + let ffi_qualifier = r#gen.qualify_package(FFI_DIR); let mut body = Source::default(); wit_bindgen_core::generated_preamble(&mut body, version); @@ -556,7 +556,7 @@ struct InterfaceGenerator<'a> { src: String, stub: String, ffi: String, - gen: &'a mut MoonBit, + r#gen: &'a mut MoonBit, resolve: &'a Resolve, // The current interface getting generated name: &'a str, @@ -568,7 +568,7 @@ impl InterfaceGenerator<'_> { fn qualify_package(&mut self, name: &str) -> String { if name != self.name { let imports = self - .gen + .r#gen .package_import .entry(self.name.to_string()) .or_default(); @@ -590,11 +590,11 @@ impl InterfaceGenerator<'_> { } fn qualifier(&mut self, ty: &TypeDef) -> String { if let TypeOwner::Interface(id) = &ty.owner { - if let Some(name) = self.gen.export_interface_names.get(id) { + if let Some(name) = self.r#gen.export_interface_names.get(id) { if name != self.name { return self.qualify_package(&name.clone()); } - } else if let Some(name) = self.gen.import_interface_names.get(id) { + } else if let Some(name) = self.r#gen.import_interface_names.get(id) { if name != self.name { return self.qualify_package(&name.clone()); } @@ -612,7 +612,7 @@ impl InterfaceGenerator<'_> { fn add_interface_fragment(self) { match self.direction { Direction::Import => { - self.gen + self.r#gen .import_interface_fragments .entry(self.name.to_owned()) .or_default() @@ -623,7 +623,7 @@ impl InterfaceGenerator<'_> { }); } Direction::Export => { - self.gen + self.r#gen .export_interface_fragments .entry(self.name.to_owned()) .or_default() @@ -639,14 +639,14 @@ impl InterfaceGenerator<'_> { fn add_world_fragment(self) { match self.direction { Direction::Import => { - self.gen.import_world_fragments.push(InterfaceFragment { + self.r#gen.import_world_fragments.push(InterfaceFragment { src: self.src, stub: self.stub, ffi: self.ffi, }); } Direction::Export => { - self.gen.export_world_fragments.push(InterfaceFragment { + self.r#gen.export_world_fragments.push(InterfaceFragment { src: self.src, stub: self.stub, ffi: self.ffi, @@ -657,12 +657,12 @@ impl InterfaceGenerator<'_> { fn import(&mut self, module: Option<&WorldKey>, func: &Function) { let async_ = self - .gen + .r#gen .opts .async_ .is_async(self.resolve, module, func, false); if async_ { - self.gen.is_async = true; + self.r#gen.is_async = true; } let interface_name = match module { @@ -686,7 +686,7 @@ impl InterfaceGenerator<'_> { }; abi::call( - bindgen.gen.resolve, + bindgen.r#gen.resolve, AbiVariant::GuestImport, LiftLower::LowerArgsLiftResults, func, @@ -697,7 +697,7 @@ impl InterfaceGenerator<'_> { let mut src = bindgen.src.clone(); let cleanup_list = if bindgen.needs_cleanup_list { - self.gen.needs_cleanup = true; + self.r#gen.needs_cleanup = true; let ffi_qualifier = self.qualify_package(FFI_DIR); @@ -782,8 +782,8 @@ impl InterfaceGenerator<'_> { } multiple_params => { let params = multiple_params.iter().map(|(_, ty)| ty); - let offsets = self.gen.sizes.field_offsets(params.clone()); - let elem_info = self.gen.sizes.params(params); + let offsets = self.r#gen.sizes.field_offsets(params.clone()); + let elem_info = self.r#gen.sizes.params(params); body.push_str(&format!( r#" let _lower_ptr : Int = {ffi}malloc({}) @@ -812,7 +812,7 @@ impl InterfaceGenerator<'_> { } else { let mut f = FunctionBindgen::new(self, "INVALID", self.name, Box::new([])); for (name, ty) in mbt_sig.params.iter() { - lower_params.extend(abi::lower_flat(f.gen.resolve, &mut f, name.clone(), ty)); + lower_params.extend(abi::lower_flat(f.r#gen.resolve, &mut f, name.clone(), ty)); } lower_results.push(f.src.clone()); } @@ -872,12 +872,12 @@ impl InterfaceGenerator<'_> { fn export(&mut self, interface: Option<&WorldKey>, func: &Function, _: Option) { let async_ = self - .gen + .r#gen .opts .async_ .is_async(self.resolve, interface, func, false); if async_ { - self.gen.is_async = true; + self.r#gen.is_async = true; } let variant = if async_ { @@ -890,9 +890,9 @@ impl InterfaceGenerator<'_> { let mbt_sig = self.mbt_sig(func, false); let func_sig = self.sig_string(&mbt_sig, async_); - let export_dir = self.gen.opts.gen_dir.clone(); + let export_dir = self.r#gen.opts.gen_dir.clone(); - let mut toplevel_generator = self.gen.interface( + let mut toplevel_generator = self.r#gen.interface( self.resolve, export_dir.as_str(), self.module, @@ -907,7 +907,7 @@ impl InterfaceGenerator<'_> { ); abi::call( - bindgen.gen.resolve, + bindgen.r#gen.resolve, variant, LiftLower::LiftArgsLowerResults, func, @@ -933,7 +933,7 @@ impl InterfaceGenerator<'_> { let camel_name = func.name.to_upper_camel_case(); - let func_name = self.gen.export_ns.tmp(&format!("wasmExport{camel_name}")); + let func_name = self.r#gen.export_ns.tmp(&format!("wasmExport{camel_name}")); let params = sig .params @@ -967,14 +967,14 @@ impl InterfaceGenerator<'_> { "#, ); - self.gen + self.r#gen .export .insert(func_name, format!("{async_export_prefix}{export_name}")); if async_ { - let snake = self.gen.name.to_lower_camel_case(); + let snake = self.r#gen.name.to_lower_camel_case(); let export_func_name = self - .gen + .r#gen .export_ns .tmp(&format!("wasmExport{snake}Async{camel_name}")); let DeferredTaskReturn::Emitted { @@ -987,7 +987,7 @@ impl InterfaceGenerator<'_> { }; let func_name = func.name.clone(); let import_module = self.resolve.name_world_key(interface.unwrap()); - self.gen.export.insert( + self.r#gen.export.insert( export_func_name.clone(), format!("[callback]{async_export_prefix}{export_name}"), ); @@ -1052,12 +1052,12 @@ impl InterfaceGenerator<'_> { (0..sig.results.len()).map(|i| format!("p{i}")).collect(), ); - abi::post_return(bindgen.gen.resolve, func, &mut bindgen); + abi::post_return(bindgen.r#gen.resolve, func, &mut bindgen); let src = bindgen.src; let func_name = self - .gen + .r#gen .export_ns .tmp(&format!("wasmExport{camel_name}PostReturn")); @@ -1069,7 +1069,7 @@ impl InterfaceGenerator<'_> { }} "# ); - self.gen + self.r#gen .export .insert(func_name, format!("cabi_post_{export_name}")); } @@ -1271,18 +1271,18 @@ impl InterfaceGenerator<'_> { fn lift_from_memory(&mut self, address: &str, ty: &Type, module: &str) -> (String, String) { let mut f = FunctionBindgen::new(self, "INVALID", module, Box::new([])); - let result = abi::lift_from_memory(f.gen.resolve, &mut f, address.into(), ty); + let result = abi::lift_from_memory(f.r#gen.resolve, &mut f, address.into(), ty); (f.src, result) } fn lower_to_memory(&mut self, address: &str, value: &str, ty: &Type, module: &str) -> String { let mut f = FunctionBindgen::new(self, "INVALID", module, Box::new([])); - abi::lower_to_memory(f.gen.resolve, &mut f, address.into(), value.into(), ty); + abi::lower_to_memory(f.r#gen.resolve, &mut f, address.into(), value.into(), ty); f.src } fn malloc_memory(&mut self, address: &str, length: &str, ty: &Type) -> String { - let size = self.gen.sizes.size(ty).size_wasm32(); + let size = self.r#gen.sizes.size(ty).size_wasm32(); let ffi = self.qualify_package(FFI_DIR); format!("let {address} = {ffi}malloc({size} * {length});") } @@ -1318,7 +1318,7 @@ impl InterfaceGenerator<'_> { return format!("{ffi}ptr2{ty}_array({address}, {length})"); } - let size = self.gen.sizes.size(ty).size_wasm32(); + let size = self.r#gen.sizes.size(ty).size_wasm32(); format!( r#" FixedArray::makei( @@ -1351,7 +1351,7 @@ impl InterfaceGenerator<'_> { }; return format!("{ffi}{ty}_array2ptr({value})"); } - let size = self.gen.sizes.size(ty).size_wasm32(); + let size = self.r#gen.sizes.size(ty).size_wasm32(); format!( r#" let address = {ffi}malloc(({value}).length() * {size}); @@ -1414,13 +1414,13 @@ impl InterfaceGenerator<'_> { ty: TypeId, result_type: Option<&Type>, ) { - if let Some(set) = self.gen.futures.get(module) { + if let Some(set) = self.r#gen.futures.get(module) { if set.contains(&ty) { return; } } - self.gen + self.r#gen .futures .entry(module.to_string()) .or_default() @@ -1619,10 +1619,10 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { .join("; "); let mut deriviation: Vec<_> = Vec::new(); - if self.gen.opts.derive_show { + if self.r#gen.opts.derive_show { deriviation.push("Show") } - if self.gen.opts.derive_eq { + if self.r#gen.opts.derive_eq { deriviation.push("Eq") } @@ -1643,13 +1643,13 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { let name = name.to_moonbit_type_ident(); let mut deriviation: Vec<_> = Vec::new(); - if self.gen.opts.derive_show { + if self.r#gen.opts.derive_show { deriviation.push("Show") } - if self.gen.opts.derive_eq { + if self.r#gen.opts.derive_eq { deriviation.push("Eq") } - let declaration = if self.gen.opts.derive_error && name.contains("Error") { + let declaration = if self.r#gen.opts.derive_error && name.contains("Error") { "suberror" } else { "struct" @@ -1719,12 +1719,12 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { "# ); - let func_name = self.gen.export_ns.tmp(&format!("wasmExport{name}Dtor")); + let func_name = self.r#gen.export_ns.tmp(&format!("wasmExport{name}Dtor")); - let export_dir = self.gen.opts.gen_dir.clone(); + let export_dir = self.r#gen.opts.gen_dir.clone(); - let mut gen = - self.gen + let mut r#gen = + self.r#gen .interface(self.resolve, export_dir.as_str(), "", Direction::Export); uwrite!( @@ -1734,10 +1734,10 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { {}{name}::dtor(handle) }} "#, - gen.qualify_package(self.name) + r#gen.qualify_package(self.name) ); - self.gen + self.r#gen .export .insert(func_name, format!("{module}#[dtor]{type_name}")); } @@ -1784,13 +1784,13 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { .join("\n "); let mut deriviation: Vec<_> = Vec::new(); - if self.gen.opts.derive_show { + if self.r#gen.opts.derive_show { deriviation.push("Show") } - if self.gen.opts.derive_eq { + if self.r#gen.opts.derive_eq { deriviation.push("Eq") } - let declaration = if self.gen.opts.derive_error && name.contains("Error") { + let declaration = if self.r#gen.opts.derive_error && name.contains("Error") { "suberror" } else { "struct" @@ -1859,13 +1859,13 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { .join("\n "); let mut deriviation: Vec<_> = Vec::new(); - if self.gen.opts.derive_show { + if self.r#gen.opts.derive_show { deriviation.push("Show") } - if self.gen.opts.derive_eq { + if self.r#gen.opts.derive_eq { deriviation.push("Eq") } - let declaration = if self.gen.opts.derive_error && name.contains("Error") { + let declaration = if self.r#gen.opts.derive_error && name.contains("Error") { "suberror" } else { "enum" @@ -1904,13 +1904,13 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> { .join("; "); let mut deriviation: Vec<_> = Vec::new(); - if self.gen.opts.derive_show { + if self.r#gen.opts.derive_show { deriviation.push("Show") } - if self.gen.opts.derive_eq { + if self.r#gen.opts.derive_eq { deriviation.push("Eq") } - let declaration = if self.gen.opts.derive_error && name.contains("Error") { + let declaration = if self.r#gen.opts.derive_error && name.contains("Error") { "suberror" } else { "enum" @@ -2024,7 +2024,7 @@ enum DeferredTaskReturn { } struct FunctionBindgen<'a, 'b> { - gen: &'b mut InterfaceGenerator<'a>, + r#gen: &'b mut InterfaceGenerator<'a>, func_name: &'b str, func_interface: &'b str, params: Box<[String]>, @@ -2040,7 +2040,7 @@ struct FunctionBindgen<'a, 'b> { impl<'a, 'b> FunctionBindgen<'a, 'b> { fn new( - gen: &'b mut InterfaceGenerator<'a>, + r#gen: &'b mut InterfaceGenerator<'a>, func_name: &'b str, func_interface: &'b str, params: Box<[String]>, @@ -2050,7 +2050,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { locals.tmp(str); }); Self { - gen, + r#gen, func_name, func_interface, params, @@ -2104,7 +2104,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { .collect::>() .join(", "); - let payload = if self.gen.non_empty_type(ty.as_ref()).is_some() { + let payload = if self.r#gen.non_empty_type(ty.as_ref()).is_some() { payload } else if is_result { format!("_{payload}") @@ -2166,7 +2166,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { .collect::>(); // Hacky way to get the type name without type parameter - let ty = self.gen.type_name(ty, false); + let ty = self.r#gen.type_name(ty, false); let lifted = self.locals.tmp("lifted"); let cases = cases @@ -2174,7 +2174,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { .zip(blocks) .enumerate() .map(|(i, ((case_name, case_ty), Block { body, results, .. }))| { - let payload = if self.gen.non_empty_type(case_ty.as_ref()).is_some() { + let payload = if self.r#gen.non_empty_type(case_ty.as_ref()).is_some() { results.into_iter().next().unwrap() } else { String::new() @@ -2276,14 +2276,14 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::I32FromS8 => results.push(format!( "{}extend8({})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0] )), Instruction::S8FromI32 => results.push(format!("({} - 0x100)", operands[0])), Instruction::S16FromI32 => results.push(format!("({} - 0x10000)", operands[0])), Instruction::I32FromS16 => results.push(format!( "{}extend16({})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0] )), Instruction::U16FromI32 => results.push(format!( @@ -2313,7 +2313,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Int::U8 => { let op = &operands[0]; let flag = self.locals.tmp("flag"); - let ty = self.gen.type_name(&Type::Id(*ty), false); + let ty = self.r#gen.type_name(&Type::Id(*ty), false); uwriteln!( self.src, r#" @@ -2325,7 +2325,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Int::U16 | Int::U32 => { let op = &operands[0]; let flag = self.locals.tmp("flag"); - let ty = self.gen.type_name(&Type::Id(*ty), false); + let ty = self.r#gen.type_name(&Type::Id(*ty), false); uwriteln!( self.src, r#" @@ -2337,7 +2337,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Int::U64 => { let op = &operands[0]; let flag = self.locals.tmp("flag"); - let ty = self.gen.type_name(&Type::Id(*ty), false); + let ty = self.r#gen.type_name(&Type::Id(*ty), false); uwriteln!( self.src, r#" @@ -2353,21 +2353,21 @@ impl Bindgen for FunctionBindgen<'_, '_> { Int::U8 => { results.push(format!( "{}({}.to_byte())", - self.gen.type_name(&Type::Id(*ty), true), + self.r#gen.type_name(&Type::Id(*ty), true), operands[0] )); } Int::U16 | Int::U32 => { results.push(format!( "{}({}.reinterpret_as_uint())", - self.gen.type_name(&Type::Id(*ty), true), + self.r#gen.type_name(&Type::Id(*ty), true), operands[0] )); } Int::U64 => { results.push(format!( "{}(({}).reinterpret_as_uint().to_uint64() | (({}).reinterpret_as_uint().to_uint64() << 32))", - self.gen.type_name(&Type::Id(*ty), true), + self.r#gen.type_name(&Type::Id(*ty), true), operands[0], operands[1] )); @@ -2377,7 +2377,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::HandleLower { ty, .. } => { let op = &operands[0]; let handle = self.locals.tmp("handle"); - let ty = self.gen.type_name(&Type::Id(*ty), false); + let ty = self.r#gen.type_name(&Type::Id(*ty), false); uwrite!( self.src, r#" @@ -2388,7 +2388,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { } Instruction::HandleLift { ty, .. } => { let op = &operands[0]; - let ty = self.gen.type_name(&Type::Id(*ty), false); + let ty = self.r#gen.type_name(&Type::Id(*ty), false); results.push(format!( "{}::{}({})", @@ -2418,7 +2418,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { results.push(format!( "{}::{{{ops}}}", - self.gen.type_name(&Type::Id(*ty), true) + self.r#gen.type_name(&Type::Id(*ty), true) )); } @@ -2554,11 +2554,11 @@ impl Bindgen for FunctionBindgen<'_, '_> { let some = self.blocks.pop().unwrap(); let _none = self.blocks.pop().unwrap(); - let ty = self.gen.type_name(&Type::Id(*ty), true); + let ty = self.r#gen.type_name(&Type::Id(*ty), true); let lifted = self.locals.tmp("lifted"); let op = &operands[0]; - let payload = if self.gen.non_empty_type(Some(*payload)).is_some() { + let payload = if self.r#gen.non_empty_type(Some(*payload)).is_some() { some.results.into_iter().next().unwrap() } else { "None".into() @@ -2607,7 +2607,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::EnumLift { ty, .. } => results.push(format!( "{}::from({})", - self.gen.type_name(&Type::Id(*ty), true), + self.r#gen.type_name(&Type::Id(*ty), true), operands[0] )), @@ -2617,7 +2617,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { results.push(format!( "{}bytes2ptr({op})", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) )); results.push(format!("{op}.length()")); if realloc.is_none() { @@ -2639,7 +2639,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { results.push(format!( "{}{ty}_array2ptr({op})", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) )); results.push(format!("{op}.length()")); if realloc.is_none() { @@ -2660,7 +2660,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { " let {result} = {}ptr2bytes({address}, {length}) ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); results.push(result); @@ -2685,7 +2685,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { " let {result} = {}ptr2{ty}_array({address}, {length}) ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); results.push(result); @@ -2698,7 +2698,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { results.push(format!( "{}str2ptr({op})", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) )); results.push(format!("{op}.length()")); if realloc.is_none() { @@ -2716,7 +2716,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { " let {result} = {}ptr2str({address}, {length}) ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); results.push(result); @@ -2732,10 +2732,10 @@ impl Bindgen for FunctionBindgen<'_, '_> { assert!(block_results.is_empty()); let op = &operands[0]; - let size = self.gen.gen.sizes.size(element).size_wasm32(); - let align = self.gen.gen.sizes.align(element).align_wasm32(); + let size = self.r#gen.r#gen.sizes.size(element).size_wasm32(); + let align = self.r#gen.r#gen.sizes.align(element).align_wasm32(); let address = self.locals.tmp("address"); - let ty = self.gen.type_name(element, true); + let ty = self.r#gen.type_name(element, true); let index = self.locals.tmp("index"); uwrite!( @@ -2748,7 +2748,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { {body} }} ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); if realloc.is_none() { @@ -2773,9 +2773,9 @@ impl Bindgen for FunctionBindgen<'_, '_> { let address = &operands[0]; let length = &operands[1]; let array = self.locals.tmp("array"); - let ty = self.gen.type_name(element, true); - let size = self.gen.gen.sizes.size(element).size_wasm32(); - // let align = self.gen.gen.sizes.align(element); + let ty = self.r#gen.type_name(element, true); + let size = self.r#gen.r#gen.sizes.size(element).size_wasm32(); + // let align = self.r#gen.r#gen.sizes.align(element); let index = self.locals.tmp("index"); let result = match &block_results[..] { @@ -2794,7 +2794,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { }} {}free({address}) ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); results.push(array); @@ -2847,7 +2847,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { ) } FunctionKind::Constructor(ty) => { - let name = self.gen.type_name(&Type::Id(ty), false); + let name = self.r#gen.type_name(&Type::Id(ty), false); format!( "{}::{}", name, @@ -2858,7 +2858,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { | FunctionKind::Static(ty) | FunctionKind::AsyncMethod(ty) | FunctionKind::AsyncStatic(ty) => { - let name = self.gen.type_name(&Type::Id(ty), false); + let name = self.r#gen.type_name(&Type::Id(ty), false); format!( "{}::{}", name, @@ -2874,7 +2874,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { match func.result { Some(ty) => { let res = self.locals.tmp("return_result"); - (res.clone(), res, self.gen.type_name(&ty, true)) + (res.clone(), res, self.r#gen.type_name(&ty, true)) } None => ("_ignore".into(), "".into(), "Unit".into()), }; @@ -2882,7 +2882,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { if func.result.is_some() { results.push(async_func_result.clone()); } - let ffi = self.gen.qualify_package(FFI_DIR); + let ffi = self.r#gen.qualify_package(FFI_DIR); uwrite!( self.src, r#" @@ -2929,7 +2929,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { let assignment = match func.result { None => "let _ = ".into(), Some(ty) => { - let ty = format!("({})", self.gen.type_name(&ty, true)); + let ty = format!("({})", self.r#gen.type_name(&ty, true)); let result = self.locals.tmp("result"); if func.result.is_some() { results.push(result.clone()); @@ -2957,7 +2957,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { } => uwriteln!( self.src, "{}free({address})", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ), Cleanup::Object(obj) => uwriteln!(self.src, "ignore({obj})"), } @@ -2972,7 +2972,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { }}) ignore(ignoreList) ", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); } @@ -2990,56 +2990,56 @@ impl Bindgen for FunctionBindgen<'_, '_> { | Instruction::PointerLoad { offset } | Instruction::LengthLoad { offset } => results.push(format!( "{}load32(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::I32Load8U { offset } => results.push(format!( "{}load8_u(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::I32Load8S { offset } => results.push(format!( "{}load8(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::I32Load16U { offset } => results.push(format!( "{}load16_u(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::I32Load16S { offset } => results.push(format!( "{}load16(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::I64Load { offset } => results.push(format!( "{}load64(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::F32Load { offset } => results.push(format!( "{}loadf32(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), Instruction::F64Load { offset } => results.push(format!( "{}loadf64(({}) + {offset})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0], offset = offset.size_wasm32() )), @@ -3049,7 +3049,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { | Instruction::LengthStore { offset } => uwriteln!( self.src, "{}store32(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3058,7 +3058,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::I32Store8 { offset } => uwriteln!( self.src, "{}store8(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3067,7 +3067,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::I32Store16 { offset } => uwriteln!( self.src, "{}store16(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3076,7 +3076,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::I64Store { offset } => uwriteln!( self.src, "{}store64(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3085,7 +3085,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::F32Store { offset } => uwriteln!( self.src, "{}storef32(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3094,7 +3094,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::F64Store { offset } => uwriteln!( self.src, "{}storef64(({}) + {offset}, {})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[1], operands[0], offset = offset.size_wasm32() @@ -3104,7 +3104,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { uwriteln!( self.src, "{}malloc({})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), size.size_wasm32() ) } @@ -3113,7 +3113,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { uwriteln!( self.src, "{}free({})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0] ) } @@ -3122,7 +3122,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { uwriteln!( self.src, "{}free({})", - self.gen.qualify_package(FFI_DIR), + self.r#gen.qualify_package(FFI_DIR), operands[0] ) } @@ -3172,8 +3172,8 @@ impl Bindgen for FunctionBindgen<'_, '_> { let address = &operands[0]; let length = &operands[1]; - let size = self.gen.gen.sizes.size(element).size_wasm32(); - // let align = self.gen.gen.sizes.align(element); + let size = self.r#gen.r#gen.sizes.size(element).size_wasm32(); + // let align = self.r#gen.r#gen.sizes.align(element); if !body.trim().is_empty() { let index = self.locals.tmp("index"); @@ -3192,7 +3192,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { uwriteln!( self.src, "{}free({address})", - self.gen.qualify_package(FFI_DIR) + self.r#gen.qualify_package(FFI_DIR) ); } @@ -3204,8 +3204,8 @@ impl Bindgen for FunctionBindgen<'_, '_> { let result = self.locals.tmp("result"); let op = &operands[0]; // let qualifier = self.r#gen.qualify_package(self.func_interface); - let ty = self.gen.type_name(&Type::Id(*ty), true); - let ffi = self.gen.qualify_package(FFI_DIR); + let ty = self.r#gen.type_name(&Type::Id(*ty), true); + let ffi = self.r#gen.qualify_package(FFI_DIR); let snake_name = format!("static_{}_future_table", ty.to_snake_case(),); @@ -3254,8 +3254,8 @@ impl Bindgen for FunctionBindgen<'_, '_> { let result = self.locals.tmp("result"); let op = &operands[0]; let qualifier = self.r#gen.qualify_package(self.func_interface); - let ty = self.gen.type_name(&Type::Id(*ty), true); - let ffi = self.gen.qualify_package(FFI_DIR); + let ty = self.r#gen.type_name(&Type::Id(*ty), true); + let ffi = self.r#gen.qualify_package(FFI_DIR); let snake_name = format!( "static_{}_stream_table", ty.replace(&qualifier, "").to_snake_case(), @@ -3275,8 +3275,8 @@ impl Bindgen for FunctionBindgen<'_, '_> { } fn return_pointer(&mut self, size: ArchitectureSize, align: Alignment) -> String { - if self.gen.direction == Direction::Import { - let ffi_qualifier = self.gen.qualify_package(FFI_DIR); + if self.r#gen.direction == Direction::Import { + let ffi_qualifier = self.r#gen.qualify_package(FFI_DIR); let address = self.locals.tmp("return_area"); uwriteln!( self.src, @@ -3290,8 +3290,8 @@ impl Bindgen for FunctionBindgen<'_, '_> { }); address } else { - self.gen.gen.return_area_size = self.gen.gen.return_area_size.max(size); - self.gen.gen.return_area_align = self.gen.gen.return_area_align.max(align); + self.r#gen.r#gen.return_area_size = self.r#gen.r#gen.return_area_size.max(size); + self.r#gen.r#gen.return_area_align = self.r#gen.r#gen.return_area_align.max(align); "return_area".into() } } @@ -3342,7 +3342,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { } fn sizes(&self) -> &SizeAlign { - &self.gen.gen.sizes + &self.r#gen.r#gen.sizes } fn is_list_canonical(&self, _resolve: &Resolve, element: &Type) -> bool { diff --git a/crates/rust/src/bindgen.rs b/crates/rust/src/bindgen.rs index b83da0058..c069afd71 100644 --- a/crates/rust/src/bindgen.rs +++ b/crates/rust/src/bindgen.rs @@ -736,7 +736,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::ListLower { element, realloc } => { let alloc = self.r#gen.path_to_std_alloc_module(); - let rt = self.gen.gen.runtime_path().to_string(); + let rt = self.r#gen.r#gen.runtime_path().to_string(); let body = self.blocks.pop().unwrap(); let tmp = self.tmp(); let vec = format!("vec{tmp}"); diff --git a/crates/test/src/moonbit.rs b/crates/test/src/moonbit.rs index cde5f9cc8..f3d420408 100644 --- a/crates/test/src/moonbit.rs +++ b/crates/test/src/moonbit.rs @@ -55,7 +55,7 @@ impl LanguageMethods for MoonBit { // Build the component let artifact = compile .bindings_dir - .join("target/wasm/release/build/gen/gen.wasm"); + .join("target/wasm/release/build/r#gen/r#gen.wasm"); // Embed WIT files let manifest_dir = compile.component.path.parent().unwrap(); let mut cmd = Command::new("wasm-tools"); diff --git a/tests/runtime-async/async/future-cancel-read/test.mbt b/tests/runtime-async/async/future-cancel-read/test.mbt index bdb83de7b..e570d3685 100644 --- a/tests/runtime-async/async/future-cancel-read/test.mbt +++ b/tests/runtime-async/async/future-cancel-read/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/my/test_/i/stub.mbt' +//@ path = 'r#gen/interface/my/test_/i/stub.mbt' ///| pub async fn cancel_before_read( diff --git a/tests/runtime-async/async/future-cancel-write/test.mbt b/tests/runtime-async/async/future-cancel-write/test.mbt index 2b1f21e8d..36a40ab15 100644 --- a/tests/runtime-async/async/future-cancel-write/test.mbt +++ b/tests/runtime-async/async/future-cancel-write/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/my/test_/i/stub.mbt' +//@ path = 'r#gen/interface/my/test_/i/stub.mbt' ///| pub fn take_then_drop(x : @ffi.FutureReader[String]) -> Unit { diff --git a/tests/runtime-async/async/future-close-after-coming-back/test.mbt b/tests/runtime-async/async/future-close-after-coming-back/test.mbt index 9f6250656..650e7442d 100644 --- a/tests/runtime-async/async/future-close-after-coming-back/test.mbt +++ b/tests/runtime-async/async/future-close-after-coming-back/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/a/b/theTest/stub.mbt' +//@ path = 'r#gen/interface/a/b/theTest/stub.mbt' pub fn f(_param : @ffi.FutureReader[Unit]) -> @ffi.FutureReader[Unit] { _param diff --git a/tests/runtime-async/async/simple-future/test.mbt b/tests/runtime-async/async/simple-future/test.mbt index f4a0e49f0..1f1685255 100644 --- a/tests/runtime-async/async/simple-future/test.mbt +++ b/tests/runtime-async/async/simple-future/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/my/test_/i/stub.mbt' +//@ path = 'r#gen/interface/my/test_/i/stub.mbt' ///| pub async fn read_future( diff --git a/tests/runtime-async/async/simple-import-params-results/test.mbt b/tests/runtime-async/async/simple-import-params-results/test.mbt index ddaaac29a..dfcb106ef 100644 --- a/tests/runtime-async/async/simple-import-params-results/test.mbt +++ b/tests/runtime-async/async/simple-import-params-results/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/a/b/i/stub.mbt' +//@ path = 'r#gen/interface/a/b/i/stub.mbt' ///| pub async fn one_argument(x : UInt) -> Unit { diff --git a/tests/runtime-async/async/simple-stream-payload/test.mbt b/tests/runtime-async/async/simple-stream-payload/test.mbt index 31eb79be8..726b03423 100644 --- a/tests/runtime-async/async/simple-stream-payload/test.mbt +++ b/tests/runtime-async/async/simple-stream-payload/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/my/test_/i/stub.mbt' +//@ path = 'r#gen/interface/my/test_/i/stub.mbt' pub async fn read_stream(x : @ffi.StreamReader[Byte]) -> Unit raise { let task = @ffi.current_task() diff --git a/tests/runtime-async/async/simple-stream/test.mbt b/tests/runtime-async/async/simple-stream/test.mbt index c227a69c4..eeea09881 100644 --- a/tests/runtime-async/async/simple-stream/test.mbt +++ b/tests/runtime-async/async/simple-stream/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/my/test_/i/stub.mbt' +//@ path = 'r#gen/interface/my/test_/i/stub.mbt' pub async fn read_stream(x : @ffi.StreamReader[Unit]) -> Unit noraise { let task = @ffi.current_task() diff --git a/tests/runtime/demo/test.mbt b/tests/runtime/demo/test.mbt index 3b7ba8f8c..581decd1c 100644 --- a/tests/runtime/demo/test.mbt +++ b/tests/runtime/demo/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/a/b/theTest/stub.mbt' +//@ path = 'r#gen/interface/a/b/theTest/stub.mbt' ///| pub fn x() -> Unit { diff --git a/tests/runtime/flavorful/test.mbt b/tests/runtime/flavorful/test.mbt index f4b230ef4..3d6215eb0 100644 --- a/tests/runtime/flavorful/test.mbt +++ b/tests/runtime/flavorful/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/flavorful/toTest/stub.mbt' +//@ path = 'r#gen/interface/test_/flavorful/toTest/stub.mbt' ///| pub fn f_list_in_record1(_a : ListInRecord1) -> Unit { diff --git a/tests/runtime/lists/test.mbt b/tests/runtime/lists/test.mbt index 2ae06a18c..9f8224236 100644 --- a/tests/runtime/lists/test.mbt +++ b/tests/runtime/lists/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/lists/toTest/stub.mbt' +//@ path = 'r#gen/interface/test_/lists/toTest/stub.mbt' ///| pub fn empty_list_param(a : FixedArray[Byte]) -> Unit { diff --git a/tests/runtime/many-arguments/test.mbt b/tests/runtime/many-arguments/test.mbt index ce19472f8..2b8aa38ae 100644 --- a/tests/runtime/many-arguments/test.mbt +++ b/tests/runtime/many-arguments/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/many_arguments/toTest/stub.mbt' +//@ path = 'r#gen/interface/test_/many_arguments/toTest/stub.mbt' ///| pub fn many_arguments( _a1 : UInt64, diff --git a/tests/runtime/numbers/test.mbt b/tests/runtime/numbers/test.mbt index 2f2e94d6a..fd3863a5d 100644 --- a/tests/runtime/numbers/test.mbt +++ b/tests/runtime/numbers/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/numbers/numbers/stub.mbt' +//@ path = 'r#gen/interface/test_/numbers/numbers/stub.mbt' ///| pub fn roundtrip_u8(a : Byte) -> Byte { diff --git a/tests/runtime/results/leaf.mbt b/tests/runtime/results/leaf.mbt index 40fc74fd1..cbb031dae 100644 --- a/tests/runtime/results/leaf.mbt +++ b/tests/runtime/results/leaf.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/results/test/stub.mbt' +//@ path = 'r#gen/interface/test_/results/test/stub.mbt' ///| pub fn string_error(_a : Float) -> Result[Float, String] { diff --git a/tests/runtime/rust/with-only-affects-imports/test.rs b/tests/runtime/rust/with-only-affects-imports/test.rs index 433675b3d..0c97c446f 100644 --- a/tests/runtime/rust/with-only-affects-imports/test.rs +++ b/tests/runtime/rust/with-only-affects-imports/test.rs @@ -13,7 +13,7 @@ mod other { bar: func(a: a); } - world gen { + world r#gen { import foo; } ", diff --git a/tests/runtime/strings/test.mbt b/tests/runtime/strings/test.mbt index 66095b056..ba907aa2a 100644 --- a/tests/runtime/strings/test.mbt +++ b/tests/runtime/strings/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/strings/toTest/stub.mbt' +//@ path = 'r#gen/interface/test_/strings/toTest/stub.mbt' ///| pub fn take_basic(s : String) -> Unit { diff --git a/tests/runtime/variants/test.mbt b/tests/runtime/variants/test.mbt index 88ab721a4..6d90d4b80 100644 --- a/tests/runtime/variants/test.mbt +++ b/tests/runtime/variants/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'gen/interface/test_/variants/toTest/stub.mbt' +//@ path = 'r#gen/interface/test_/variants/toTest/stub.mbt' ///| pub fn roundtrip_option(a : Float?) -> Byte? { From d9bd9ea156d6d84caa747c0b1e4315527225ab5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Tue, 7 Oct 2025 18:10:39 +0000 Subject: [PATCH 3/7] Update resources --- Cargo.lock | 540 ++++++++++++++++++++++++----- Cargo.toml | 90 +++-- crates/c/Cargo.toml | 10 +- crates/core/Cargo.toml | 6 +- crates/cpp/Cargo.toml | 10 +- crates/csharp/Cargo.toml | 12 +- crates/guest-rust/Cargo.toml | 12 +- crates/guest-rust/macro/Cargo.toml | 4 +- crates/markdown/Cargo.toml | 4 +- crates/markdown/src/lib.rs | 4 +- crates/moonbit/Cargo.toml | 4 +- crates/rust/Cargo.toml | 7 +- crates/test/Cargo.toml | 22 +- 13 files changed, 533 insertions(+), 192 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 24d3850ff..0131b612d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,12 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + [[package]] name = "aho-corasick" version = "1.1.3" @@ -63,9 +69,21 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.98" +version = "1.0.100" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" + +[[package]] +name = "auditable-serde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7bf8143dfc3c0258df908843e169b5cc5fcf76c7718bd66135ef4a9cd558c5" +dependencies = [ + "semver", + "serde", + "serde_json", + "topological-sort", +] [[package]] name = "beef" @@ -75,9 +93,9 @@ checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" [[package]] name = "bitflags" -version = "2.9.1" +version = "2.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" +checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394" [[package]] name = "bitmaps" @@ -102,9 +120,9 @@ checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" [[package]] name = "clap" -version = "4.5.40" +version = "4.5.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40b6887a1d8685cebccf115538db5c0efe625ccac9696ad45c409d96566e910f" +checksum = "e2134bb3ea021b78629caa971416385309e0131b351b25e01dc16fb54e1b5fae" dependencies = [ "clap_builder", "clap_derive", @@ -112,9 +130,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.40" +version = "4.5.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0c66c08ce9f0c698cbce5c0279d0bb6ac936d8674174fe48f736533b964f59e" +checksum = "c2ba64afa3c0a6df7fa517765e31314e983f51dda798ffba27b988194fb65dc9" dependencies = [ "anstream", "anstyle", @@ -125,9 +143,9 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.40" +version = "4.5.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2c7947ae4cc3d851207c1adb5b5e260ff0cca11446b1d6d1423788e442257ce" +checksum = "bbfd7eae0b0f1a6e63d4b13c9c478de77c2eb546fba158ad50b4203dc24b9f9c" dependencies = [ "heck 0.5.0", "proc-macro2", @@ -155,6 +173,15 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + [[package]] name = "crossbeam-deque" version = "0.8.6" @@ -180,6 +207,17 @@ version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "either" version = "1.15.0" @@ -231,6 +269,16 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" +[[package]] +name = "flate2" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + [[package]] name = "fnv" version = "1.0.7" @@ -243,6 +291,15 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + [[package]] name = "futures" version = "0.3.31" @@ -354,12 +411,119 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "icu_collections" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + [[package]] name = "id-arena" version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + [[package]] name = "im-rc" version = "15.1.0" @@ -376,13 +540,14 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.9.0" +version = "2.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e" +checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5" dependencies = [ "equivalent", "hashbrown", "serde", + "serde_core", ] [[package]] @@ -427,12 +592,6 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "leb128" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" - [[package]] name = "leb128fmt" version = "0.1.0" @@ -451,11 +610,17 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" +[[package]] +name = "litemap" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" + [[package]] name = "log" -version = "0.4.27" +version = "0.4.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" [[package]] name = "logos" @@ -519,12 +684,28 @@ dependencies = [ "syn", ] +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + [[package]] name = "once_cell_polyfill" version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + [[package]] name = "petgraph" version = "0.6.5" @@ -562,11 +743,20 @@ dependencies = [ "portable-atomic", ] +[[package]] +name = "potential_utf" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a" +dependencies = [ + "zerovec", +] + [[package]] name = "prettyplease" -version = "0.2.35" +version = "0.2.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "061c1221631e079b26479d25bbf2275bfe5917ae8419cd7e34f13bfc2aa7539a" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", "syn", @@ -574,29 +764,36 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.95" +version = "1.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" dependencies = [ "unicode-ident", ] [[package]] name = "pulldown-cmark" -version = "0.9.6" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b" +checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0" dependencies = [ "bitflags", "memchr", + "pulldown-cmark-escape", "unicase", ] +[[package]] +name = "pulldown-cmark-escape" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae" + [[package]] name = "quote" -version = "1.0.40" +version = "1.0.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" dependencies = [ "proc-macro2", ] @@ -618,9 +815,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.10.0" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" dependencies = [ "either", "rayon-core", @@ -628,9 +825,9 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.12.1" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" dependencies = [ "crossbeam-deque", "crossbeam-utils", @@ -638,9 +835,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.11.1" +version = "1.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c" dependencies = [ "aho-corasick", "memchr", @@ -650,9 +847,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.9" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad" dependencies = [ "aho-corasick", "memchr", @@ -707,18 +904,28 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.219" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.219" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", @@ -727,23 +934,24 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.145" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" dependencies = [ "itoa", "memchr", "ryu", "serde", + "serde_core", ] [[package]] name = "serde_spanned" -version = "0.6.9" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -759,6 +967,12 @@ dependencies = [ "unsafe-libyaml", ] +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + [[package]] name = "sized-chunks" version = "0.6.5" @@ -790,6 +1004,12 @@ dependencies = [ "smallvec", ] +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + [[package]] name = "strsim" version = "0.11.1" @@ -798,15 +1018,26 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" [[package]] name = "syn" -version = "2.0.104" +version = "2.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" +checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "terminal_size" version = "0.4.2" @@ -848,46 +1079,60 @@ dependencies = [ "syn", ] +[[package]] +name = "tinystr" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +dependencies = [ + "displaydoc", + "zerovec", +] + [[package]] name = "toml" -version = "0.8.23" +version = "0.9.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0" dependencies = [ - "serde", + "indexmap", + "serde_core", "serde_spanned", "toml_datetime", - "toml_edit", + "toml_parser", + "toml_writer", + "winnow", ] [[package]] name = "toml_datetime" -version = "0.6.11" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1" dependencies = [ - "serde", + "serde_core", ] [[package]] -name = "toml_edit" -version = "0.22.27" +name = "toml_parser" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627" dependencies = [ - "indexmap", - "serde", - "serde_spanned", - "toml_datetime", - "toml_write", "winnow", ] [[package]] -name = "toml_write" -version = "0.1.2" +name = "toml_writer" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109" + +[[package]] +name = "topological-sort" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" +checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d" [[package]] name = "typenum" @@ -931,6 +1176,24 @@ version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" +[[package]] +name = "url" +version = "2.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + [[package]] name = "utf8parse" version = "0.2.2" @@ -945,9 +1208,9 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "wac-graph" -version = "0.6.1" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d94268a683b67ae20210565b5f91e106fe05034c36b931e739fe90377ed80b98" +checksum = "0d94f428d894714ffba71621dd5fde3b5a52feb6a0ec96aded6207f85057dffc" dependencies = [ "anyhow", "id-arena", @@ -957,16 +1220,16 @@ dependencies = [ "semver", "thiserror", "wac-types", - "wasm-encoder 0.202.0", - "wasm-metadata 0.202.0", - "wasmparser 0.202.0", + "wasm-encoder 0.235.0", + "wasm-metadata 0.235.0", + "wasmparser 0.235.0", ] [[package]] name = "wac-parser" -version = "0.6.1" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "616ec0c4f63641fa095b4a551263fe35a15c72c9680b650b8f08f70db0fdbd19" +checksum = "37077f3951f01f32c496a7f54ac93e9e26bf6860fe461552aab3f12d753ddf10" dependencies = [ "anyhow", "id-arena", @@ -978,30 +1241,30 @@ dependencies = [ "serde", "thiserror", "wac-graph", - "wasm-encoder 0.202.0", - "wasm-metadata 0.202.0", - "wasmparser 0.202.0", + "wasm-encoder 0.235.0", + "wasm-metadata 0.235.0", + "wasmparser 0.235.0", ] [[package]] name = "wac-types" -version = "0.6.1" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5028a15e266f4c8fed48beb95aebb76af5232dcd554fd849a305a4e5cce1563" +checksum = "6690e903d48e7258ea5e623c3269452c81ce1c9bfa8ffcb9c8909d77861fff6a" dependencies = [ "anyhow", "id-arena", "indexmap", "semver", - "wasm-encoder 0.202.0", - "wasmparser 0.202.0", + "wasm-encoder 0.235.0", + "wasmparser 0.235.0", ] [[package]] name = "wasi-preview1-component-adapter-provider" -version = "30.0.2" +version = "37.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddbd7f2a9e3635abe5d4df93b12cadc8d6818079785ee4fab3719ae3c85a064e" +checksum = "8d0fcd636ad2b29a7c0490799a23ad61d1c8dedfafdb970447fddd0549502b60" [[package]] name = "wasm-compose" @@ -1026,11 +1289,12 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.202.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfd106365a7f5f7aa3c1916a98cbb3ad477f5ff96ddb130285a91c6e7429e67a" +checksum = "b3bc393c395cb621367ff02d854179882b9a351b4e0c93d1397e6090b53a5c2a" dependencies = [ - "leb128", + "leb128fmt", + "wasmparser 0.235.0", ] [[package]] @@ -1045,18 +1309,21 @@ dependencies = [ [[package]] name = "wasm-metadata" -version = "0.202.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "094aea3cb90e09f16ee25a4c0e324b3e8c934e7fd838bfa039aef5352f44a917" +checksum = "b055604ba04189d54b8c0ab2c2fc98848f208e103882d5c0b984f045d5ea4d20" dependencies = [ "anyhow", + "auditable-serde", + "flate2", "indexmap", "serde", "serde_derive", "serde_json", "spdx", - "wasm-encoder 0.202.0", - "wasmparser 0.202.0", + "url", + "wasm-encoder 0.235.0", + "wasmparser 0.235.0", ] [[package]] @@ -1073,13 +1340,15 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.202.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6998515d3cf3f8b980ef7c11b29a9b1017d4cf86b99ae93b546992df9931413" +checksum = "161296c618fa2d63f6ed5fffd1112937e803cb9ec71b32b01a76321555660917" dependencies = [ "bitflags", + "hashbrown", "indexmap", "semver", + "serde", ] [[package]] @@ -1265,12 +1534,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" [[package]] name = "winnow" -version = "0.7.11" +version = "0.7.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd" -dependencies = [ - "memchr", -] +checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" [[package]] name = "wit-bindgen" @@ -1473,3 +1739,87 @@ dependencies = [ "unicode-xid", "wasmparser 0.239.0", ] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/Cargo.toml b/Cargo.toml index 3e106172d..9ce7d2552 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,34 +22,32 @@ repository = "https://github.com/bytecodealliance/wit-bindgen" # # rust-version = "1.82.0" [workspace.dependencies] -anyhow = "1.0.72" -bitflags = "2.3.3" -heck = { version = "0.5" } -pulldown-cmark = { version = "0.9", default-features = false } -serde = { version = "1.0.218", features = ["derive"] } -clap = { version = "4.3.19", features = ["derive"] } -indexmap = "2.0.0" -prettyplease = "0.2.20" -syn = { version = "2.0.89", features = ["printing"] } -futures = "0.3.31" - -wat = "1.239.0" -wasmparser = "0.239.0" -wasm-encoder = "0.239.0" -wasm-metadata = { version = "0.239.0", default-features = false } -wit-parser = "0.239.0" -wit-component = "0.239.0" -wasm-compose = "0.239.0" - -wit-bindgen-core = { path = 'crates/core', version = '0.46.0' } -wit-bindgen-c = { path = 'crates/c', version = '0.46.0' } -wit-bindgen-cpp = { path = 'crates/cpp', version = '0.46.0' } -wit-bindgen-rust = { path = "crates/rust", version = "0.46.0" } -wit-bindgen-csharp = { path = 'crates/csharp', version = '0.46.0' } -wit-bindgen-markdown = { path = 'crates/markdown', version = '0.46.0' } -wit-bindgen-moonbit = { path = 'crates/moonbit', version = '0.46.0' } -wit-bindgen = { path = 'crates/guest-rust', version = '0.46.0', default-features = false } -wit-bindgen-test = { path = 'crates/test', version = '0.46.0' } +anyhow = { version = "=1.0.100" } +bitflags = { version = "=2.9.4" } +clap = { version = "=4.5.48", features = ["derive"] } +futures = { version = "0.3.31" } +heck = { version = "=0.5.0" } +indexmap = { version = "=2.11.4" } +prettyplease = { version = "=0.2.37" } +pulldown-cmark = { version = "=0.13.0", default-features = false } +serde = { version = "=1.0.228", features = ["derive"] } +syn = { version = "=2.0.106", features = ["printing"] } +wasmparser = { version = "=0.239.0" } +wasm-compose = { version = "=0.239.0" } +wasm-encoder = { version = "=0.239.0" } +wasm-metadata = { version = "=0.239.0", default-features = false } +wat = { version = "=1.239.0" } +wit-bindgen = { path = 'crates/guest-rust', version = "=0.46.0", default-features = false } +wit-bindgen-c = { path = 'crates/c', version = "=0.46.0" } +wit-bindgen-core = { path = 'crates/core', version = "=0.46.0" } +wit-bindgen-cpp = { path = 'crates/cpp', version = "=0.46.0" } +wit-bindgen-csharp = { path = 'crates/csharp', version = "=0.46.0" } +wit-bindgen-markdown = { path = 'crates/markdown', version = "=0.46.0" } +wit-bindgen-moonbit = { path = 'crates/moonbit', version = "=0.46.0" } +wit-bindgen-rust = { path = "crates/rust", version = "=0.46.0" } +wit-bindgen-test = { path = 'crates/test', version = "=0.46.0" } +wit-component = { version = "=0.239.0" } +wit-parser = { version = "=0.239.0" } [[bin]] name = "wit-bindgen" @@ -57,36 +55,28 @@ name = "wit-bindgen" [dependencies] anyhow = { workspace = true } clap = { workspace = true, features = ['wrap_help'] } -wit-bindgen-core = { workspace = true } -wit-bindgen-rust = { workspace = true, features = ['clap'], optional = true } +env_logger = { version = "0.11.7" } +wasm-encoder = { workspace = true } wit-bindgen-c = { workspace = true, features = ['clap'], optional = true } +wit-bindgen-core = { workspace = true } wit-bindgen-cpp = { workspace = true, features = ['clap'], optional = true } -wit-bindgen-markdown = { workspace = true, features = ['clap'], optional = true } -wit-bindgen-moonbit = { workspace = true, features = ['clap'], optional = true } wit-bindgen-csharp = { workspace = true, features = ['clap'], optional = true } +wit-bindgen-markdown = { workspace = true, features = [ + 'clap', +], optional = true } +wit-bindgen-moonbit = { workspace = true, features = ['clap'], optional = true } +wit-bindgen-rust = { workspace = true, features = ['clap'], optional = true } wit-bindgen-test = { workspace = true } wit-component = { workspace = true } -wasm-encoder = { workspace = true } -env_logger = "0.11.7" [features] -default = [ - 'c', - 'rust', - 'markdown', - 'go', - 'csharp', - 'cpp', - 'moonbit', - 'async', -] +async = [] c = ['dep:wit-bindgen-c'] -cpp = ['dep:wit-bindgen-cpp'] -rust = ['dep:wit-bindgen-rust'] -markdown = ['dep:wit-bindgen-markdown'] -go = [] csharp = ['dep:wit-bindgen-csharp'] csharp-mono = ['csharp'] +cpp = ['dep:wit-bindgen-cpp'] +default = ['c', 'rust', 'markdown', 'go', 'csharp', 'cpp', 'moonbit', 'async'] +go = [] +markdown = ['dep:wit-bindgen-markdown'] moonbit = ['dep:wit-bindgen-moonbit'] -async = [] - +rust = ['dep:wit-bindgen-rust'] diff --git a/crates/c/Cargo.toml b/crates/c/Cargo.toml index de53ea094..2413d0bee 100644 --- a/crates/c/Cargo.toml +++ b/crates/c/Cargo.toml @@ -17,14 +17,14 @@ doctest = false test = false [dependencies] -wit-bindgen-core = { workspace = true } -wit-component = { workspace = true } -wasm-encoder = { workspace = true } -wasm-metadata = { workspace = true } anyhow = { workspace = true } -heck = { workspace = true } clap = { workspace = true, optional = true } +heck = { workspace = true } indexmap = { workspace = true } +wasm-encoder = { workspace = true } +wasm-metadata = { workspace = true } +wit-bindgen-core = { workspace = true } +wit-component = { workspace = true } [features] clap = ['dep:clap', 'wit-bindgen-core/clap'] diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 42f5549b5..798c9bfae 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -16,12 +16,12 @@ Low-level support for bindings generation based on WIT files for use with doctest = false [dependencies] -wit-parser = { workspace = true } anyhow = { workspace = true } +clap = { workspace = true, optional = true } heck = { workspace = true } serde = { workspace = true, optional = true } -clap = { workspace = true, optional = true } +wit-parser = { workspace = true } [features] -serde = ['dep:serde'] clap = ['dep:clap'] +serde = ['dep:serde'] diff --git a/crates/cpp/Cargo.toml b/crates/cpp/Cargo.toml index 9af7ac15d..a78db45f8 100644 --- a/crates/cpp/Cargo.toml +++ b/crates/cpp/Cargo.toml @@ -15,14 +15,14 @@ doctest = false test = false [dependencies] -wit-bindgen-core = { workspace = true } -wit-component = { workspace = true } +anyhow = { workspace = true } +clap = { workspace = true, optional = true } wasm-encoder = { workspace = true } wasm-metadata = { workspace = true } -wit-bindgen-c = { workspace = true } -anyhow = { workspace = true } heck = { workspace = true } -clap = { workspace = true, optional = true } +wit-bindgen-c = { workspace = true } +wit-bindgen-core = { workspace = true } +wit-component = { workspace = true } [dev-dependencies] test-helpers = { path = '../test-helpers' } diff --git a/crates/csharp/Cargo.toml b/crates/csharp/Cargo.toml index 3a4d992be..6fce17b68 100644 --- a/crates/csharp/Cargo.toml +++ b/crates/csharp/Cargo.toml @@ -17,16 +17,16 @@ doctest = false test = false [dependencies] +anyhow = { workspace = true } +clap = { workspace = true, optional = true } +heck = { workspace = true } +indexmap = { workspace = true } +wasm-metadata = { workspace = true } wit-bindgen-core = { workspace = true } wit-component = { workspace = true } wit-parser = { workspace = true } -wasm-metadata = { workspace = true } -heck = { workspace = true } -clap = { workspace = true, optional = true } -anyhow = { workspace = true } -indexmap = { workspace = true } [features] -default = ["aot"] aot = [] +default = ["aot"] mono = [] diff --git a/crates/guest-rust/Cargo.toml b/crates/guest-rust/Cargo.toml index 2e7387a6c..a62407448 100644 --- a/crates/guest-rust/Cargo.toml +++ b/crates/guest-rust/Cargo.toml @@ -16,22 +16,22 @@ Used when compiling Rust programs to the component model. all-features = true [dependencies] -wit-bindgen-rust-macro = { path = "./macro", optional = true, version = "0.46.0" } bitflags = { workspace = true, optional = true } -futures = { version = "0.3.30", optional = true } +futures = { workspace = true, optional = true } +wit-bindgen-rust-macro = { path = "./macro", optional = true, version = "0.46.0" } # When built as part of libstd -core = { version = "1.0", optional = true, package = "rustc-std-workspace-core" } alloc = { version = "1.0", optional = true, package = "rustc-std-workspace-alloc" } +core = { version = "1.0", optional = true, package = "rustc-std-workspace-core" } [features] +async = ["macros", "std", "wit-bindgen-rust-macro/async"] +async-spawn = ['async', 'dep:futures'] +bitflags = ["dep:bitflags"] default = ["macros", "realloc", "async", "std", "bitflags"] macros = ["dep:wit-bindgen-rust-macro"] realloc = [] std = [] -async = ["macros", "std", "wit-bindgen-rust-macro/async"] -bitflags = ["dep:bitflags"] -async-spawn = ['async', 'dep:futures'] # Unstable feature to support being a libstd dependency rustc-dep-of-std = ["dep:core", "dep:alloc"] diff --git a/crates/guest-rust/macro/Cargo.toml b/crates/guest-rust/macro/Cargo.toml index 5fb9c1ea6..ae03c70a0 100644 --- a/crates/guest-rust/macro/Cargo.toml +++ b/crates/guest-rust/macro/Cargo.toml @@ -16,8 +16,8 @@ doctest = false test = false [dependencies] -proc-macro2 = "1.0" -quote = "1" +proc-macro2 = {version = "=1.0.101"} +quote = {version = "=1.0.41"} wit-bindgen-core = { workspace = true } wit-bindgen-rust = { workspace = true } anyhow = { workspace = true } diff --git a/crates/markdown/Cargo.toml b/crates/markdown/Cargo.toml index cdb36f6d0..374e1a043 100644 --- a/crates/markdown/Cargo.toml +++ b/crates/markdown/Cargo.toml @@ -17,7 +17,7 @@ test = false [dependencies] anyhow = { workspace = true } -heck = { workspace = true } -pulldown-cmark = { workspace = true } clap = { workspace = true, optional = true } +heck = { workspace = true } +pulldown-cmark = { workspace = true, features = ['html'] } wit-bindgen-core = { workspace = true } diff --git a/crates/markdown/src/lib.rs b/crates/markdown/src/lib.rs index 7485ae635..a23968e35 100644 --- a/crates/markdown/src/lib.rs +++ b/crates/markdown/src/lib.rs @@ -209,10 +209,10 @@ impl WorldGenerator for Markdown { for event in parser { if let Event::Code(code) = &event { if let Some(dst) = self.hrefs.get(code.as_ref()) { - let tag = Tag::Link(LinkType::Inline, dst.as_str().into(), "".into()); + let tag = Tag::Link{link_type: LinkType::Inline, dest_url: dst.as_str().into(), title: "".into(), id: "".into()}; events.push(Event::Start(tag.clone())); events.push(event.clone()); - events.push(Event::End(tag)); + events.push(Event::End(tag.into())); continue; } } diff --git a/crates/moonbit/Cargo.toml b/crates/moonbit/Cargo.toml index 657ee9176..e8ae6ed8f 100644 --- a/crates/moonbit/Cargo.toml +++ b/crates/moonbit/Cargo.toml @@ -14,9 +14,9 @@ through the `wit-bindgen-cli` crate. [dependencies] anyhow = { workspace = true } -wit-bindgen-core = { workspace = true } -heck = { workspace = true } clap = { workspace = true, optional = true } +heck = { workspace = true } +wit-bindgen-core = { workspace = true } [features] clap = ['dep:clap', 'wit-bindgen-core/clap'] diff --git a/crates/rust/Cargo.toml b/crates/rust/Cargo.toml index 25a02ca5c..1e4253754 100644 --- a/crates/rust/Cargo.toml +++ b/crates/rust/Cargo.toml @@ -30,11 +30,12 @@ serde = { workspace = true, optional = true } [dev-dependencies] futures = { workspace = true } -wit-bindgen = { path = '../guest-rust', features = ['async'] } test-helpers = { path = '../test-helpers' } +wit-bindgen = { path = '../guest-rust', features = ['async'] } + # For use with the custom attributes test -serde_json = "1" +serde_json = { version = "=1.0.145" } [features] -serde = ['dep:serde', 'wit-bindgen-core/serde'] clap = ['dep:clap', 'wit-bindgen-core/clap'] +serde = ['dep:serde', 'wit-bindgen-core/serde'] diff --git a/crates/test/Cargo.toml b/crates/test/Cargo.toml index 381580a4c..1727b74d0 100644 --- a/crates/test/Cargo.toml +++ b/crates/test/Cargo.toml @@ -19,20 +19,20 @@ doctest = false anyhow = { workspace = true } clap = { workspace = true, features = ['env'] } heck = { workspace = true } -log = "0.4.26" -rayon = "1.10.0" -regex = "1.11.1" +indexmap = { workspace = true } +log = { version = "=0.4.28" } +rayon = { version = "=1.11.0" } +regex = { version = "=1.11.3" } serde = { workspace = true } -toml = "0.8.20" -wasi-preview1-component-adapter-provider = "30.0.2" -wac-parser = "0.6.1" -wac-types = "0.6.1" -wac-graph = "0.6.1" +toml = { version = "=0.9.7" } +wac-graph = { version = "=0.8.0" } +wac-parser = { version = "=0.8.0" } +wac-types = { version = "=0.8.0" } +wasmparser = { workspace = true, features = ["features"] } wasm-compose = { workspace = true } -indexmap = { workspace = true } wasm-encoder = { workspace = true } -wasmparser = { workspace = true, features = ["features"] } +wasi-preview1-component-adapter-provider = "37.0.2" wat = { workspace = true } +wit-bindgen-csharp = { workspace = true } wit-component = { workspace = true } wit-parser = { workspace = true } -wit-bindgen-csharp = { workspace = true } From 66dbf62ef869f7488175660d3a4031824a5e65e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Tue, 7 Oct 2025 18:36:06 +0000 Subject: [PATCH 4/7] fix - Add unsafe block --- crates/c/src/lib.rs | 4 ++-- crates/core/src/abi.rs | 9 ++++++--- crates/core/src/async_.rs | 2 +- crates/core/src/source.rs | 2 +- crates/cpp/src/lib.rs | 12 +++++++---- crates/csharp/src/function.rs | 2 +- crates/csharp/src/interface.rs | 4 ++-- crates/csharp/src/world_generator.rs | 2 +- crates/guest-rust/macro/src/lib.rs | 4 ++-- crates/guest-rust/src/lib.rs | 6 +++--- crates/guest-rust/src/rt/async_support.rs | 20 +++++++++++-------- .../src/rt/async_support/abi_buffer.rs | 2 +- .../src/rt/async_support/future_support.rs | 4 ++-- .../src/rt/async_support/stream_support.rs | 2 +- .../src/rt/async_support/subtask.rs | 2 +- .../src/rt/async_support/waitable.rs | 4 ++-- crates/guest-rust/src/rt/mod.rs | 10 +++++----- .../src/rt/wit_bindgen_cabi_realloc.rs | 2 +- crates/markdown/src/lib.rs | 11 +++++++--- crates/moonbit/src/lib.rs | 4 ++-- crates/rust/src/bindgen.rs | 6 +++--- crates/rust/src/interface.rs | 8 ++++---- crates/rust/src/lib.rs | 6 +++--- crates/test/src/config.rs | 2 +- crates/test/src/custom.rs | 2 +- crates/test/src/lib.rs | 2 +- crates/test/src/runner.rs | 2 +- src/bin/wit-bindgen.rs | 13 ++++++++---- 28 files changed, 85 insertions(+), 64 deletions(-) diff --git a/crates/c/src/lib.rs b/crates/c/src/lib.rs index af885abdd..9a3e481ee 100644 --- a/crates/c/src/lib.rs +++ b/crates/c/src/lib.rs @@ -10,8 +10,8 @@ use wit_bindgen_core::abi::{ self, AbiVariant, Bindgen, Bitcast, Instruction, LiftLower, WasmSignature, WasmType, }; use wit_bindgen_core::{ - dealias, uwrite, uwriteln, wit_parser::*, AnonymousTypeGenerator, AsyncFilterSet, Direction, - Files, InterfaceGenerator as _, Ns, WorldGenerator, + AnonymousTypeGenerator, AsyncFilterSet, Direction, Files, InterfaceGenerator as _, Ns, + WorldGenerator, dealias, uwrite, uwriteln, wit_parser::*, }; use wit_component::StringEncoding; diff --git a/crates/core/src/abi.rs b/crates/core/src/abi.rs index 02da00e68..236644a85 100644 --- a/crates/core/src/abi.rs +++ b/crates/core/src/abi.rs @@ -3,8 +3,8 @@ use std::iter; pub use wit_parser::abi::{AbiVariant, FlatTypes, WasmSignature, WasmType}; use wit_parser::{ - align_to_arch, Alignment, ArchitectureSize, ElementInfo, Enum, Flags, FlagsRepr, Function, - Handle, Int, Record, Resolve, Result_, SizeAlign, Tuple, Type, TypeDefKind, TypeId, Variant, + Alignment, ArchitectureSize, ElementInfo, Enum, Flags, FlagsRepr, Function, Handle, Int, + Record, Resolve, Result_, SizeAlign, Tuple, Type, TypeDefKind, TypeId, Variant, align_to_arch, }; // Helper macro for defining instructions without having to have tons of @@ -1134,7 +1134,10 @@ impl<'a, B: Bindgen> Generator<'a, B> { for (param_name, ty) in func.params.iter() { let Some(types) = flat_types(self.resolve, ty, Some(max_flat_params)) else { - panic!("failed to flatten types during direct parameter lifting ('{param_name}' in func '{}')", func.name); + panic!( + "failed to flatten types during direct parameter lifting ('{param_name}' in func '{}')", + func.name + ); }; for _ in 0..types.len() { self.emit(&Instruction::GetArg { nth: offset }); diff --git a/crates/core/src/async_.rs b/crates/core/src/async_.rs index 11ce54055..e801e2ea3 100644 --- a/crates/core/src/async_.rs +++ b/crates/core/src/async_.rs @@ -1,4 +1,4 @@ -use anyhow::{bail, Result}; +use anyhow::{Result, bail}; use std::collections::HashSet; use std::fmt; use wit_parser::{Function, FunctionKind, Resolve, WorldKey}; diff --git a/crates/core/src/source.rs b/crates/core/src/source.rs index fb2bfd2e7..3c40b0fc7 100644 --- a/crates/core/src/source.rs +++ b/crates/core/src/source.rs @@ -1,5 +1,5 @@ -use std::collections::btree_map::Entry; use std::collections::BTreeMap; +use std::collections::btree_map::Entry; use std::fmt::{self, Write}; use std::ops::Deref; diff --git a/crates/cpp/src/lib.rs b/crates/cpp/src/lib.rs index f9ef7a8c0..c1db4e428 100644 --- a/crates/cpp/src/lib.rs +++ b/crates/cpp/src/lib.rs @@ -11,6 +11,7 @@ use std::{ use symbol_name::{make_external_component, make_external_symbol}; use wit_bindgen_c::to_c_ident; use wit_bindgen_core::{ + Files, InterfaceGenerator, Source, Types, WorldGenerator, abi::{self, AbiVariant, Bindgen, Bitcast, LiftLower, WasmSignature, WasmType}, uwrite, uwriteln, wit_parser::{ @@ -18,7 +19,6 @@ use wit_bindgen_core::{ Resolve, SizeAlign, Stability, Type, TypeDef, TypeDefKind, TypeId, TypeOwner, WorldId, WorldKey, }, - Files, InterfaceGenerator, Source, Types, WorldGenerator, }; // mod wamr; @@ -1595,8 +1595,9 @@ impl CppInterfaceGenerator<'_> { variant: AbiVariant, ) -> (String, String) { let extern_name = make_external_symbol(module_name, name, variant); - let import = format!("extern \"C\" __attribute__((import_module(\"{module_name}\")))\n __attribute__((import_name(\"{name}\")))\n {result} {extern_name}({args});\n") - ; + let import = format!( + "extern \"C\" __attribute__((import_module(\"{module_name}\")))\n __attribute__((import_name(\"{name}\")))\n {result} {extern_name}({args});\n" + ); (extern_name, import) } @@ -1938,7 +1939,10 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a> } uwriteln!(self.r#gen.h_src.src, "}};"); } - uwriteln!(self.r#gen.h_src.src, " std::variant<{all_types}> variants;"); + uwriteln!( + self.r#gen.h_src.src, + " std::variant<{all_types}> variants;" + ); uwriteln!(self.r#gen.h_src.src, "}};"); self.r#gen.dependencies.needs_variant = true; } diff --git a/crates/csharp/src/function.rs b/crates/csharp/src/function.rs index 30c8763bf..3c1192391 100644 --- a/crates/csharp/src/function.rs +++ b/crates/csharp/src/function.rs @@ -6,7 +6,7 @@ use std::fmt::Write; use std::mem; use std::ops::Deref; use wit_bindgen_core::abi::{Bindgen, Bitcast, Instruction}; -use wit_bindgen_core::{uwrite, uwriteln, Direction, Ns}; +use wit_bindgen_core::{Direction, Ns, uwrite, uwriteln}; use wit_parser::abi::WasmType; use wit_parser::{ Alignment, ArchitectureSize, Docs, FunctionKind, Handle, Resolve, SizeAlign, Type, TypeDefKind, diff --git a/crates/csharp/src/interface.rs b/crates/csharp/src/interface.rs index 2f23c5487..5c688c317 100644 --- a/crates/csharp/src/interface.rs +++ b/crates/csharp/src/interface.rs @@ -8,7 +8,7 @@ use std::fmt::Write; use std::ops::Deref; use wit_bindgen_core::abi::LiftLower; use wit_bindgen_core::{ - abi, uwrite, uwriteln, Direction, InterfaceGenerator as CoreInterfaceGenerator, + Direction, InterfaceGenerator as CoreInterfaceGenerator, abi, uwrite, uwriteln, }; use wit_parser::abi::AbiVariant; use wit_parser::{ @@ -552,7 +552,7 @@ impl InterfaceGenerator<'_> { match &ty.kind { TypeDefKind::Type(ty) => self.is_primative_list(ty), TypeDefKind::List(ty) if crate::world_generator::is_primitive(ty) => { - return true + return true; } _ => false, } diff --git a/crates/csharp/src/world_generator.rs b/crates/csharp/src/world_generator.rs index 79dffc4c8..7d7cb67eb 100644 --- a/crates/csharp/src/world_generator.rs +++ b/crates/csharp/src/world_generator.rs @@ -8,7 +8,7 @@ use std::collections::{HashMap, HashSet}; use std::fmt::Write; use std::ops::Deref; use std::{iter, mem}; -use wit_bindgen_core::{uwrite, Direction, Files, InterfaceGenerator as _, WorldGenerator}; +use wit_bindgen_core::{Direction, Files, InterfaceGenerator as _, WorldGenerator, uwrite}; use wit_component::WitPrinter; use wit_parser::abi::WasmType; use wit_parser::{ diff --git a/crates/guest-rust/macro/src/lib.rs b/crates/guest-rust/macro/src/lib.rs index ef23291f9..c2b616f97 100644 --- a/crates/guest-rust/macro/src/lib.rs +++ b/crates/guest-rust/macro/src/lib.rs @@ -6,9 +6,9 @@ use std::sync::atomic::{AtomicUsize, Ordering::Relaxed}; use syn::parse::{Error, Parse, ParseStream, Result}; use syn::punctuated::Punctuated; use syn::spanned::Spanned; -use syn::{braced, token, LitStr, Token}; -use wit_bindgen_core::wit_parser::{PackageId, Resolve, UnresolvedPackageGroup, WorldId}; +use syn::{LitStr, Token, braced, token}; use wit_bindgen_core::AsyncFilterSet; +use wit_bindgen_core::wit_parser::{PackageId, Resolve, UnresolvedPackageGroup, WorldId}; use wit_bindgen_rust::{Opts, Ownership, WithOption}; #[proc_macro] diff --git a/crates/guest-rust/src/lib.rs b/crates/guest-rust/src/lib.rs index 02db6c725..8d724f050 100644 --- a/crates/guest-rust/src/lib.rs +++ b/crates/guest-rust/src/lib.rs @@ -880,7 +880,7 @@ pub use rt::async_support::backpressure_set; pub use rt::async_support::spawn; #[cfg(feature = "async")] pub use rt::async_support::{ - backpressure_dec, backpressure_inc, block_on, yield_async, yield_blocking, AbiBuffer, - FutureRead, FutureReader, FutureWrite, FutureWriteCancel, FutureWriteError, FutureWriter, - StreamRead, StreamReader, StreamResult, StreamWrite, StreamWriter, + AbiBuffer, FutureRead, FutureReader, FutureWrite, FutureWriteCancel, FutureWriteError, + FutureWriter, StreamRead, StreamReader, StreamResult, StreamWrite, StreamWriter, + backpressure_dec, backpressure_inc, block_on, yield_async, yield_blocking, }; diff --git a/crates/guest-rust/src/rt/async_support.rs b/crates/guest-rust/src/rt/async_support.rs index 287871593..40b42691c 100644 --- a/crates/guest-rust/src/rt/async_support.rs +++ b/crates/guest-rust/src/rt/async_support.rs @@ -260,20 +260,24 @@ unsafe extern "C" fn waitable_register( ) -> *mut c_void { let ptr = ptr.cast::>(); assert!(!ptr.is_null()); - (*ptr).add_waitable(waitable); - match (*ptr).waitables.insert(waitable, (callback_ptr, callback)) { - Some((prev, _)) => prev, - None => ptr::null_mut(), + unsafe { + (*ptr).add_waitable(waitable); + match (*ptr).waitables.insert(waitable, (callback_ptr, callback)) { + Some((prev, _)) => prev, + None => ptr::null_mut(), + } } } unsafe extern "C" fn waitable_unregister(ptr: *mut c_void, waitable: u32) -> *mut c_void { let ptr = ptr.cast::>(); assert!(!ptr.is_null()); - (*ptr).remove_waitable(waitable); - match (*ptr).waitables.remove(&waitable) { - Some((prev, _)) => prev, - None => ptr::null_mut(), + unsafe { + (*ptr).remove_waitable(waitable); + match (*ptr).waitables.remove(&waitable) { + Some((prev, _)) => prev, + None => ptr::null_mut(), + } } } diff --git a/crates/guest-rust/src/rt/async_support/abi_buffer.rs b/crates/guest-rust/src/rt/async_support/abi_buffer.rs index fb48b1c3f..22b91c43b 100644 --- a/crates/guest-rust/src/rt/async_support/abi_buffer.rs +++ b/crates/guest-rust/src/rt/async_support/abi_buffer.rs @@ -1,5 +1,5 @@ -use crate::rt::async_support::StreamVtable; use crate::rt::Cleanup; +use crate::rt::async_support::StreamVtable; use std::alloc::Layout; use std::mem::{self, MaybeUninit}; use std::ptr; diff --git a/crates/guest-rust/src/rt/async_support/future_support.rs b/crates/guest-rust/src/rt/async_support/future_support.rs index d18798549..1e469b3a1 100644 --- a/crates/guest-rust/src/rt/async_support/future_support.rs +++ b/crates/guest-rust/src/rt/async_support/future_support.rs @@ -111,9 +111,9 @@ //! alive until that write completes but otherwise shouldn't hinder anything //! else. -use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation}; -use crate::rt::async_support::ReturnCode; use crate::rt::Cleanup; +use crate::rt::async_support::ReturnCode; +use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation}; use std::alloc::Layout; use std::fmt; use std::future::{Future, IntoFuture}; diff --git a/crates/guest-rust/src/rt/async_support/stream_support.rs b/crates/guest-rust/src/rt/async_support/stream_support.rs index 597850cc3..f7af91eac 100644 --- a/crates/guest-rust/src/rt/async_support/stream_support.rs +++ b/crates/guest-rust/src/rt/async_support/stream_support.rs @@ -2,7 +2,7 @@ //! module documentation in `future_support.rs`. use crate::rt::async_support::waitable::{WaitableOp, WaitableOperation}; -use crate::rt::async_support::{AbiBuffer, ReturnCode, DROPPED}; +use crate::rt::async_support::{AbiBuffer, DROPPED, ReturnCode}; use { crate::rt::Cleanup, std::{ diff --git a/crates/guest-rust/src/rt/async_support/subtask.rs b/crates/guest-rust/src/rt/async_support/subtask.rs index b902a1f34..d198dc155 100644 --- a/crates/guest-rust/src/rt/async_support/subtask.rs +++ b/crates/guest-rust/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; diff --git a/crates/guest-rust/src/rt/async_support/waitable.rs b/crates/guest-rust/src/rt/async_support/waitable.rs index 603dfb689..91053c31c 100644 --- a/crates/guest-rust/src/rt/async_support/waitable.rs +++ b/crates/guest-rust/src/rt/async_support/waitable.rs @@ -204,7 +204,7 @@ where } unsafe extern "C" fn cabi_wake(ptr: *mut c_void, code: u32) { - let ptr: &mut CompletionStatus = &mut *ptr.cast::(); + let ptr: &mut CompletionStatus = unsafe { &mut *ptr.cast::() }; ptr.code = Some(code); ptr.waker.take().unwrap().wake() } @@ -397,7 +397,7 @@ where // situation no cancellation is necessary, the async // operation is now inert, and we can immediately return. Poll::Ready(result) => { - return self.as_mut().pin_project().0.result_into_cancel(result) + return self.as_mut().pin_project().0.result_into_cancel(result); } // The operation, despite receiving an update via a code, diff --git a/crates/guest-rust/src/rt/mod.rs b/crates/guest-rust/src/rt/mod.rs index 099297d2f..d9ba151b6 100644 --- a/crates/guest-rust/src/rt/mod.rs +++ b/crates/guest-rust/src/rt/mod.rs @@ -117,19 +117,19 @@ pub unsafe fn cabi_realloc( align: usize, new_len: usize, ) -> *mut u8 { - use alloc::alloc::{alloc as allocate, handle_alloc_error, realloc, Layout}; + use alloc::alloc::{Layout, alloc as allocate, handle_alloc_error, realloc}; let layout; let ptr = if old_len == 0 { if new_len == 0 { return align as *mut u8; } - layout = Layout::from_size_align_unchecked(new_len, align); - allocate(layout) + layout = unsafe { Layout::from_size_align_unchecked(new_len, align) }; + unsafe { allocate(layout) } } else { debug_assert_ne!(new_len, 0, "non-zero old_len requires non-zero new_len!"); - layout = Layout::from_size_align_unchecked(old_len, align); - realloc(old_ptr, layout, new_len) + layout = unsafe { Layout::from_size_align_unchecked(old_len, align) }; + unsafe { realloc(old_ptr, layout, new_len) } }; if ptr.is_null() { // Print a nice message in debug mode, but in release mode don't diff --git a/crates/guest-rust/src/rt/wit_bindgen_cabi_realloc.rs b/crates/guest-rust/src/rt/wit_bindgen_cabi_realloc.rs index ad7ff90b8..0e52b29c2 100644 --- a/crates/guest-rust/src/rt/wit_bindgen_cabi_realloc.rs +++ b/crates/guest-rust/src/rt/wit_bindgen_cabi_realloc.rs @@ -7,5 +7,5 @@ pub unsafe extern "C" fn cabi_realloc_wit_bindgen_0_46_0( align: usize, new_len: usize, ) -> *mut u8 { - crate::rt::cabi_realloc(old_ptr, old_len, align, new_len) + unsafe { crate::rt::cabi_realloc(old_ptr, old_len, align, new_len) } } diff --git a/crates/markdown/src/lib.rs b/crates/markdown/src/lib.rs index a23968e35..6d5fa4c60 100644 --- a/crates/markdown/src/lib.rs +++ b/crates/markdown/src/lib.rs @@ -1,10 +1,10 @@ use anyhow::Result; use heck::*; -use pulldown_cmark::{html, Event, LinkType, Parser, Tag}; +use pulldown_cmark::{Event, LinkType, Parser, Tag, html}; use std::collections::HashMap; use std::fmt::Write; use wit_bindgen_core::{ - uwriteln, wit_parser, Files, InterfaceGenerator as _, Source, WorldGenerator, + Files, InterfaceGenerator as _, Source, WorldGenerator, uwriteln, wit_parser, }; use wit_parser::*; @@ -209,7 +209,12 @@ impl WorldGenerator for Markdown { for event in parser { if let Event::Code(code) = &event { if let Some(dst) = self.hrefs.get(code.as_ref()) { - let tag = Tag::Link{link_type: LinkType::Inline, dest_url: dst.as_str().into(), title: "".into(), id: "".into()}; + let tag = Tag::Link { + link_type: LinkType::Inline, + dest_url: dst.as_str().into(), + title: "".into(), + id: "".into(), + }; events.push(Event::Start(tag.clone())); events.push(event.clone()); events.push(Event::End(tag.into())); diff --git a/crates/moonbit/src/lib.rs b/crates/moonbit/src/lib.rs index cba8437d0..c8a4ece68 100644 --- a/crates/moonbit/src/lib.rs +++ b/crates/moonbit/src/lib.rs @@ -8,6 +8,8 @@ use std::{ ops::Deref, }; use wit_bindgen_core::{ + AsyncFilterSet, Direction, Files, InterfaceGenerator as CoreInterfaceGenerator, Ns, Source, + WorldGenerator, abi::{self, AbiVariant, Bindgen, Bitcast, Instruction, LiftLower, WasmSignature, WasmType}, dealias, uwrite, uwriteln, wit_parser::{ @@ -15,8 +17,6 @@ use wit_bindgen_core::{ Int, InterfaceId, Record, Resolve, Result_, SizeAlign, Tuple, Type, TypeDef, TypeDefKind, TypeId, TypeOwner, Variant, WorldId, WorldKey, }, - AsyncFilterSet, Direction, Files, InterfaceGenerator as CoreInterfaceGenerator, Ns, Source, - WorldGenerator, }; // Assumptions: diff --git a/crates/rust/src/bindgen.rs b/crates/rust/src/bindgen.rs index c069afd71..4aab0433e 100644 --- a/crates/rust/src/bindgen.rs +++ b/crates/rust/src/bindgen.rs @@ -1,12 +1,12 @@ use crate::{ - classify_constructor_return_type, int_repr, to_rust_ident, ConstructorReturnType, Identifier, - InterfaceGenerator, RustFlagsRepr, + ConstructorReturnType, Identifier, InterfaceGenerator, RustFlagsRepr, + classify_constructor_return_type, int_repr, to_rust_ident, }; use heck::*; use std::fmt::Write as _; use std::mem; use wit_bindgen_core::abi::{Bindgen, Instruction, LiftLower, WasmType}; -use wit_bindgen_core::{dealias, uwrite, uwriteln, wit_parser::*, Source}; +use wit_bindgen_core::{Source, dealias, uwrite, uwriteln, wit_parser::*}; pub(super) struct FunctionBindgen<'a, 'b> { pub r#gen: &'b mut InterfaceGenerator<'a>, diff --git a/crates/rust/src/interface.rs b/crates/rust/src/interface.rs index 91462bdd3..be1422e98 100644 --- a/crates/rust/src/interface.rs +++ b/crates/rust/src/interface.rs @@ -1,8 +1,8 @@ use crate::bindgen::{FunctionBindgen, POINTER_SIZE_EXPRESSION}; use crate::{ - classify_constructor_return_type, full_wit_type_name, int_repr, to_rust_ident, - to_upper_camel_case, wasm_type, ConstructorReturnType, FnSig, Identifier, InterfaceName, - Ownership, RuntimeItem, RustFlagsRepr, RustWasm, TypeGeneration, + ConstructorReturnType, FnSig, Identifier, InterfaceName, Ownership, RuntimeItem, RustFlagsRepr, + RustWasm, TypeGeneration, classify_constructor_return_type, full_wit_type_name, int_repr, + to_rust_ident, to_upper_camel_case, wasm_type, }; use anyhow::Result; use heck::*; @@ -11,7 +11,7 @@ use std::fmt::Write as _; use std::mem; use wit_bindgen_core::abi::{self, AbiVariant, LiftLower}; use wit_bindgen_core::{ - dealias, uwrite, uwriteln, wit_parser::*, AnonymousTypeGenerator, Source, TypeInfo, + AnonymousTypeGenerator, Source, TypeInfo, dealias, uwrite, uwriteln, wit_parser::*, }; pub struct InterfaceGenerator<'a> { diff --git a/crates/rust/src/lib.rs b/crates/rust/src/lib.rs index fd92b1953..dece973ba 100644 --- a/crates/rust/src/lib.rs +++ b/crates/rust/src/lib.rs @@ -1,5 +1,5 @@ use crate::interface::InterfaceGenerator; -use anyhow::{bail, Result}; +use anyhow::{Result, bail}; use core::panic; use heck::*; use indexmap::{IndexMap, IndexSet}; @@ -9,8 +9,8 @@ use std::mem; use std::str::FromStr; use wit_bindgen_core::abi::{Bitcast, WasmType}; use wit_bindgen_core::{ - dealias, name_package_module, uwrite, uwriteln, wit_parser::*, AsyncFilterSet, Files, - InterfaceGenerator as _, Source, Types, WorldGenerator, + AsyncFilterSet, Files, InterfaceGenerator as _, Source, Types, WorldGenerator, dealias, + name_package_module, uwrite, uwriteln, wit_parser::*, }; mod bindgen; diff --git a/crates/test/src/config.rs b/crates/test/src/config.rs index b2bf7e190..03fc4f928 100644 --- a/crates/test/src/config.rs +++ b/crates/test/src/config.rs @@ -28,8 +28,8 @@ use anyhow::Context; use anyhow::Result; -use serde::de::DeserializeOwned; use serde::Deserialize; +use serde::de::DeserializeOwned; use std::collections::HashMap; /// Configuration that can be placed at the top of runtime tests in source diff --git a/crates/test/src/custom.rs b/crates/test/src/custom.rs index c260d8640..7abc9e09b 100644 --- a/crates/test/src/custom.rs +++ b/crates/test/src/custom.rs @@ -1,5 +1,5 @@ use crate::{Bindgen, Compile, LanguageMethods, Runner, Verify}; -use anyhow::{bail, Context, Result}; +use anyhow::{Context, Result, bail}; use clap::Parser; use std::env; use std::path::Path; diff --git a/crates/test/src/lib.rs b/crates/test/src/lib.rs index 59c2482a0..e046d05a7 100644 --- a/crates/test/src/lib.rs +++ b/crates/test/src/lib.rs @@ -1,4 +1,4 @@ -use anyhow::{anyhow, bail, Context, Result}; +use anyhow::{Context, Result, anyhow, bail}; use clap::Parser; use rayon::prelude::*; use std::borrow::Cow; diff --git a/crates/test/src/runner.rs b/crates/test/src/runner.rs index fe5c48ac4..b5706331c 100644 --- a/crates/test/src/runner.rs +++ b/crates/test/src/runner.rs @@ -17,7 +17,7 @@ impl TestRunner { return Ok(TestRunner { path: runner.clone(), args: Vec::new(), - }) + }); } Err(e) => e, }; diff --git a/src/bin/wit-bindgen.rs b/src/bin/wit-bindgen.rs index d1d3666a8..97305acb9 100644 --- a/src/bin/wit-bindgen.rs +++ b/src/bin/wit-bindgen.rs @@ -1,8 +1,8 @@ -use anyhow::{bail, Context, Error, Result}; +use anyhow::{Context, Error, Result, bail}; use clap::Parser; use std::path::PathBuf; use std::str; -use wit_bindgen_core::{wit_parser, Files, WorldGenerator}; +use wit_bindgen_core::{Files, WorldGenerator, wit_parser}; use wit_parser::Resolve; /// Helper for passing VERSION to opt. @@ -146,7 +146,9 @@ fn main() -> Result<()> { Opt::Rust { opts, args } => (opts.build(), args), #[cfg(feature = "go")] Opt::TinyGo { args: _ } => { - bail!("Go bindgen has been moved to a separate repository. Please visit https://github.com/bytecodealliance/go-modules for the new Go bindings generator `wit-bindgen-go`.") + bail!( + "Go bindgen has been moved to a separate repository. Please visit https://github.com/bytecodealliance/go-modules for the new Go bindings generator `wit-bindgen-go`." + ) } #[cfg(feature = "csharp")] Opt::Csharp { opts, args } => (opts.build(), args), @@ -176,7 +178,10 @@ fn main() -> Result<()> { .any(|c| c.is_control() && !matches!(c, '\n' | '\r' | '\t')) && utf8_prev.lines().eq(utf8_contents.lines()) { - bail!("{} differs only in line endings (CRLF vs. LF). If this is a text file, configure git to mark the file as `text eol=lf`.", dst.display()); + bail!( + "{} differs only in line endings (CRLF vs. LF). If this is a text file, configure git to mark the file as `text eol=lf`.", + dst.display() + ); } } // The contents are binary or there are other differences; just From d39be3010f95783216c2dc07cbfe6526a71490e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Wed, 8 Oct 2025 11:10:05 +0000 Subject: [PATCH 5/7] Unsafe block at wasm32 target --- .devcontainer/Dockerfile | 6 ++++-- .devcontainer/devcontainer.json | 12 +++--------- .devcontainer/setup.sh | 4 ++-- crates/guest-rust/src/rt/async_support.rs | 14 +++++++------- .../src/rt/async_support/error_context.rs | 2 +- crates/guest-rust/src/rt/async_support/subtask.rs | 2 +- .../src/rt/async_support/waitable_set.rs | 2 +- crates/guest-rust/src/rt/mod.rs | 2 +- crates/test/src/cpp.rs | 2 +- rust-toolchain.toml | 4 ++-- 10 files changed, 23 insertions(+), 27 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 571b3e51e..b3331cfff 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,7 +1,9 @@ +# Use an official base image as a parent image +FROM rust:latest + # FROM mcr.microsoft.com/devcontainers/rust -FROM rust:trixie # COPY .devcontainer/setup.sh /tmp/setup.sh # RUN chmod +x /tmp/setup.sh # USER vscode -# RUN /tmp/setup.sh \ No newline at end of file +# RUN /tmp/setup.sh diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 49cbc67c4..7f781cd92 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -14,8 +14,7 @@ "installOhMyZsh": false, "upgradePackages": true, "nonFreePackages": false - }, - "ghcr.io/devcontainers-extra/features/zig:1.1.2": {} + } }, "customizations": { "vscode": { @@ -29,11 +28,7 @@ // "rust-analyzer.check.command": "clippy", "explorer.compactFolders": false, "rust-analyzer.inlayHints.implicitDrops.enable": true, - "editor.fontWeight": "bold", - "workbench.colorTheme": "Default Dark Modern", - "workbench.preferredDarkColorTheme": "Monokai", - "workbench.activityBar.location": "top", - "workbench.sideBar.location": "right" + "editor.fontWeight": "bold" }, "extensions": [ "ms-azuretools.vscode-docker", @@ -43,8 +38,7 @@ "tamasfe.even-better-toml", "vadimcn.vscode-lldb", "skellock.just", - "ms-vscode-remote.remote-containers", - "ziglang.vscode-zig" + "ms-vscode-remote.remote-containers" ] } }, diff --git a/.devcontainer/setup.sh b/.devcontainer/setup.sh index 202d431bb..226a1b85b 100755 --- a/.devcontainer/setup.sh +++ b/.devcontainer/setup.sh @@ -9,9 +9,9 @@ curl https://wasmtime.dev/install.sh -sSf | bash rustup target add wasm32-wasip2 # C/C++ -WASI_SDK_PATH="$HOME/wasi-sdk-25.0" +WASI_SDK_PATH="$HOME/wasi-sdk-27.0" mkdir -p "$WASI_SDK_PATH" -curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-25/wasi-sdk-25.0-x86_64-linux.tar.gz | tar -xz -C "$WASI_SDK_PATH" --strip-components=1 +curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-x86_64-linux.tar.gz | tar -xz -C "$WASI_SDK_PATH" --strip-components=1 echo "export WASI_SDK_PATH=$WASI_SDK_PATH" >> ~/.bashrc echo "alias clang=$WASI_SDK_PATH/bin/clang" >> ~/.bashrc echo "alias clang++=$WASI_SDK_PATH/bin/clang++" >> ~/.bashrc diff --git a/crates/guest-rust/src/rt/async_support.rs b/crates/guest-rust/src/rt/async_support.rs index 40b42691c..97b093668 100644 --- a/crates/guest-rust/src/rt/async_support.rs +++ b/crates/guest-rust/src/rt/async_support.rs @@ -458,7 +458,7 @@ pub fn yield_blocking() -> bool { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[thread-yield]"] fn yield_() -> bool; } @@ -519,7 +519,7 @@ pub fn backpressure_set(enabled: bool) { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[backpressure-set]"] fn backpressure_set(_: i32); } @@ -536,7 +536,7 @@ pub fn backpressure_inc() { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[backpressure-inc]"] fn backpressure_inc(); } @@ -553,7 +553,7 @@ pub fn backpressure_dec() { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[backpressure-dec]"] fn backpressure_dec(); } @@ -569,7 +569,7 @@ fn context_get() -> *mut u8 { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[context-get-0]"] fn get() -> *mut u8; } @@ -585,7 +585,7 @@ unsafe fn context_set(value: *mut u8) { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[context-set-0]"] fn set(value: *mut u8); } @@ -619,7 +619,7 @@ impl Drop for TaskCancelOnDrop { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "[export]$root")] - extern "C" { + unsafe extern "C" { #[link_name = "[task-cancel]"] fn cancel(); } diff --git a/crates/guest-rust/src/rt/async_support/error_context.rs b/crates/guest-rust/src/rt/async_support/error_context.rs index 6f3c3c97e..1d7f8c8cc 100644 --- a/crates/guest-rust/src/rt/async_support/error_context.rs +++ b/crates/guest-rust/src/rt/async_support/error_context.rs @@ -84,7 +84,7 @@ fn debug_message(_: u32, _: &mut RetPtr) { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] -extern "C" { +unsafe extern "C" { #[link_name = "[error-context-new-utf8]"] fn new(_: *const u8, _: usize) -> u32; #[link_name = "[error-context-drop]"] diff --git a/crates/guest-rust/src/rt/async_support/subtask.rs b/crates/guest-rust/src/rt/async_support/subtask.rs index d198dc155..c055d5cd7 100644 --- a/crates/guest-rust/src/rt/async_support/subtask.rs +++ b/crates/guest-rust/src/rt/async_support/subtask.rs @@ -284,7 +284,7 @@ unsafe fn cancel(_: u32) -> u32 { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] -extern "C" { +unsafe extern "C" { #[link_name = "[subtask-cancel]"] fn cancel(handle: u32) -> u32; #[link_name = "[subtask-drop]"] diff --git a/crates/guest-rust/src/rt/async_support/waitable_set.rs b/crates/guest-rust/src/rt/async_support/waitable_set.rs index 8f4237591..0c37faa8b 100644 --- a/crates/guest-rust/src/rt/async_support/waitable_set.rs +++ b/crates/guest-rust/src/rt/async_support/waitable_set.rs @@ -86,7 +86,7 @@ unsafe fn poll(_: u32, _: *mut [u32; 2]) -> u32 { #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "$root")] -extern "C" { +unsafe extern "C" { #[link_name = "[waitable-set-new]"] fn new() -> u32; #[link_name = "[waitable-set-drop]"] diff --git a/crates/guest-rust/src/rt/mod.rs b/crates/guest-rust/src/rt/mod.rs index d9ba151b6..3a1540638 100644 --- a/crates/guest-rust/src/rt/mod.rs +++ b/crates/guest-rust/src/rt/mod.rs @@ -164,7 +164,7 @@ pub fn run_ctors_once() { // exported function to (unconditionally) run ctors. By using // this function, the linked module is opting into "manually" // running ctors. - extern "C" { + unsafe extern "C" { fn __wasm_call_ctors(); } __wasm_call_ctors(); diff --git a/crates/test/src/cpp.rs b/crates/test/src/cpp.rs index b5f21fd72..52129def2 100644 --- a/crates/test/src/cpp.rs +++ b/crates/test/src/cpp.rs @@ -17,7 +17,7 @@ struct LangConfig { /// Space-separated list or array of compiler flags to pass. #[serde(default)] cflags: StringList, -} +} fn clangpp(runner: &Runner<'_>) -> PathBuf { match &runner.opts.c.wasi_sdk_path { diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 6c0101fb7..c12bee481 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,5 +1,5 @@ [toolchain] channel = "stable" -components = [ "rustfmt", "clippy", "rustc-dev" ] -targets = [ "x86_64-unknown-linux-gnu" ] +components = [ "rustfmt", "clippy", "rustc-dev", "rust-analyzer" ] +targets = [ "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-wasip1", "wasm32-wasip2" ] profile = "minimal" From 60b3ca17bbba6cefbc10a7e6a26fd3a2154052fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Wed, 8 Oct 2025 14:59:42 +0000 Subject: [PATCH 6/7] Remove some settings at devcontainer, fix unsafe block and cargo fmt --- .devcontainer/devcontainer.json | 11 +---------- Cargo.toml | 2 -- crates/c/Cargo.toml | 1 - crates/core/Cargo.toml | 1 - crates/csharp/Cargo.toml | 1 - crates/guest-rust/Cargo.toml | 1 - crates/guest-rust/src/rt/async_support/cabi.rs | 2 +- crates/guest-rust/src/rt/mod.rs | 2 +- crates/markdown/Cargo.toml | 1 - crates/moonbit/Cargo.toml | 1 - crates/rust/Cargo.toml | 1 - crates/test/Cargo.toml | 1 - crates/test/src/cpp.rs | 2 +- tests/runtime/rust/with-only-affects-imports/test.rs | 2 +- 14 files changed, 5 insertions(+), 24 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 7f781cd92..595edd9ba 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -20,29 +20,20 @@ "vscode": { "settings": { "lldb.executable": "/usr/bin/lldb", - // VS Code don't watch files under ./target "files.watcherExclude": { "**/target/**": true - }, - "rust-analyzer.checkOnSave": true, - // "rust-analyzer.check.command": "clippy", - "explorer.compactFolders": false, - "rust-analyzer.inlayHints.implicitDrops.enable": true, - "editor.fontWeight": "bold" + } }, "extensions": [ "ms-azuretools.vscode-docker", "rust-lang.rust-analyzer", "fill-labs.dependi", - "BytecodeAlliance.wit-idl", "tamasfe.even-better-toml", "vadimcn.vscode-lldb", - "skellock.just", "ms-vscode-remote.remote-containers" ] } }, "postCreateCommand": "sh .devcontainer/setup.sh", - // Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root. "remoteUser": "vscode" } \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 9ce7d2552..6abcfbd4d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ CLI tool to generate bindings for WIT documents and the component model. @@ -19,7 +18,6 @@ edition = "2024" version = "0.46.0" license = "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT" repository = "https://github.com/bytecodealliance/wit-bindgen" -# # rust-version = "1.82.0" [workspace.dependencies] anyhow = { version = "=1.0.100" } diff --git a/crates/c/Cargo.toml b/crates/c/Cargo.toml index 2413d0bee..472001e75 100644 --- a/crates/c/Cargo.toml +++ b/crates/c/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ C bindings generator for WIT and the component model, typically used through the diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml index 798c9bfae..e2731cb1d 100644 --- a/crates/core/Cargo.toml +++ b/crates/core/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Low-level support for bindings generation based on WIT files for use with diff --git a/crates/csharp/Cargo.toml b/crates/csharp/Cargo.toml index 6fce17b68..fa518d2c8 100644 --- a/crates/csharp/Cargo.toml +++ b/crates/csharp/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ C# bindings generator for WIT and the component model, typically used diff --git a/crates/guest-rust/Cargo.toml b/crates/guest-rust/Cargo.toml index a62407448..2b3c069c0 100644 --- a/crates/guest-rust/Cargo.toml +++ b/crates/guest-rust/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Rust bindings generator and runtime support for WIT and the component model. diff --git a/crates/guest-rust/src/rt/async_support/cabi.rs b/crates/guest-rust/src/rt/async_support/cabi.rs index be9945de9..b3d098201 100644 --- a/crates/guest-rust/src/rt/async_support/cabi.rs +++ b/crates/guest-rust/src/rt/async_support/cabi.rs @@ -47,7 +47,7 @@ use core::ffi::c_void; #[cfg(target_family = "wasm")] -extern "C" { +unsafe extern "C" { /// Sets the global task pointer to `ptr` provided. Returns the previous /// value. /// diff --git a/crates/guest-rust/src/rt/mod.rs b/crates/guest-rust/src/rt/mod.rs index 3a1540638..0acbe814d 100644 --- a/crates/guest-rust/src/rt/mod.rs +++ b/crates/guest-rust/src/rt/mod.rs @@ -81,7 +81,7 @@ mod wit_bindgen_cabi_realloc; pub fn maybe_link_cabi_realloc() { #[cfg(all(target_family = "wasm", not(target_env = "p2")))] { - extern "C" { + unsafe extern "C" { fn cabi_realloc( old_ptr: *mut u8, old_len: usize, diff --git a/crates/markdown/Cargo.toml b/crates/markdown/Cargo.toml index 374e1a043..10ebcc4ce 100644 --- a/crates/markdown/Cargo.toml +++ b/crates/markdown/Cargo.toml @@ -4,7 +4,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Markdown generator for WIT and the component model, typically used diff --git a/crates/moonbit/Cargo.toml b/crates/moonbit/Cargo.toml index e8ae6ed8f..f65275d48 100644 --- a/crates/moonbit/Cargo.toml +++ b/crates/moonbit/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ MoonBit bindings generator for WIT and the component model, typically used diff --git a/crates/rust/Cargo.toml b/crates/rust/Cargo.toml index 1e4253754..f89bf6046 100644 --- a/crates/rust/Cargo.toml +++ b/crates/rust/Cargo.toml @@ -5,7 +5,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Rust bindings generator for WIT and the component model, typically used through diff --git a/crates/test/Cargo.toml b/crates/test/Cargo.toml index 1727b74d0..de8e6b90a 100644 --- a/crates/test/Cargo.toml +++ b/crates/test/Cargo.toml @@ -4,7 +4,6 @@ version = { workspace = true } edition = { workspace = true } repository = { workspace = true } license = { workspace = true } -# rust-version = { workspace = true } homepage = 'https://github.com/bytecodealliance/wit-bindgen' description = """ Backend of the `wit-bindgen test` subcommand diff --git a/crates/test/src/cpp.rs b/crates/test/src/cpp.rs index 52129def2..b5f21fd72 100644 --- a/crates/test/src/cpp.rs +++ b/crates/test/src/cpp.rs @@ -17,7 +17,7 @@ struct LangConfig { /// Space-separated list or array of compiler flags to pass. #[serde(default)] cflags: StringList, -} +} fn clangpp(runner: &Runner<'_>) -> PathBuf { match &runner.opts.c.wasi_sdk_path { diff --git a/tests/runtime/rust/with-only-affects-imports/test.rs b/tests/runtime/rust/with-only-affects-imports/test.rs index 0c97c446f..433675b3d 100644 --- a/tests/runtime/rust/with-only-affects-imports/test.rs +++ b/tests/runtime/rust/with-only-affects-imports/test.rs @@ -13,7 +13,7 @@ mod other { bar: func(a: a); } - world r#gen { + world gen { import foo; } ", From e6128bed4ae1d5ca610e5aafa88f2fa99aaad723 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Alves?= <120682244+JADSN1894@users.noreply.github.com> Date: Fri, 10 Oct 2025 12:02:30 +0000 Subject: [PATCH 7/7] Update resources and fix r#gen wrong replacement --- Cargo.lock | 92 +++++++++---------- Cargo.toml | 14 +-- README.md | 8 +- crates/csharp/src/function.rs | 2 +- crates/moonbit/src/lib.rs | 10 +- crates/test-helpers/codegen-macro/Cargo.toml | 2 +- crates/test/Cargo.toml | 2 +- .../async/future-cancel-read/test.mbt | 2 +- .../async/future-cancel-write/test.mbt | 2 +- .../future-close-after-coming-back/test.mbt | 2 +- .../async/simple-future/test.mbt | 2 +- .../simple-import-params-results/test.mbt | 2 +- .../async/simple-stream-payload/test.mbt | 2 +- .../async/simple-stream/test.mbt | 2 +- tests/runtime/demo/test.mbt | 2 +- tests/runtime/flavorful/test.mbt | 2 +- tests/runtime/lists/test.mbt | 2 +- tests/runtime/many-arguments/test.mbt | 2 +- tests/runtime/numbers/test.mbt | 2 +- tests/runtime/results/leaf.mbt | 2 +- tests/runtime/strings/test.mbt | 2 +- tests/runtime/variants/test.mbt | 2 +- 22 files changed, 80 insertions(+), 80 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0131b612d..619777c5a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -947,9 +947,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee" +checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392" dependencies = [ "serde_core", ] @@ -1053,7 +1053,7 @@ name = "test-helpers" version = "0.0.0" dependencies = [ "codegen-macro", - "wasm-encoder 0.239.0", + "wasm-encoder 0.240.0", "wit-bindgen-core", "wit-component", "wit-parser", @@ -1091,9 +1091,9 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.7" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00e5e5d9bf2475ac9d4f0d9edab68cc573dc2fd644b0dba36b0c30a92dd9eaa0" +checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8" dependencies = [ "indexmap", "serde_core", @@ -1106,27 +1106,27 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "0.7.2" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1" +checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" dependencies = [ "serde_core", ] [[package]] name = "toml_parser" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627" +checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" dependencies = [ "winnow", ] [[package]] name = "toml_writer" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d163a63c116ce562a22cda521fcc4d79152e7aba014456fb5eb442f6d6a10109" +checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2" [[package]] name = "topological-sort" @@ -1268,9 +1268,9 @@ checksum = "8d0fcd636ad2b29a7c0490799a23ad61d1c8dedfafdb970447fddd0549502b60" [[package]] name = "wasm-compose" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0ec5bc51a265c73434ede0659536ac9af486eebf0397ff073bfb19093421cd8" +checksum = "feeb9a231e63bd5d5dfe07e9f8daa53d5c85e4f7de5ef756d3b4e6a5f501c578" dependencies = [ "anyhow", "heck 0.4.1", @@ -1282,8 +1282,8 @@ dependencies = [ "serde_derive", "serde_yaml", "smallvec", - "wasm-encoder 0.239.0", - "wasmparser 0.239.0", + "wasm-encoder 0.240.0", + "wasmparser 0.240.0", "wat", ] @@ -1299,12 +1299,12 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5be00faa2b4950c76fe618c409d2c3ea5a3c9422013e079482d78544bb2d184c" +checksum = "06d642d8c5ecc083aafe9ceb32809276a304547a3a6eeecceb5d8152598bc71f" dependencies = [ "leb128fmt", - "wasmparser 0.239.0", + "wasmparser 0.240.0", ] [[package]] @@ -1328,14 +1328,14 @@ dependencies = [ [[package]] name = "wasm-metadata" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20b3ec880a9ac69ccd92fbdbcf46ee833071cf09f82bb005b2327c7ae6025ae2" +checksum = "ee093e1e1ccffa005b9b778f7a10ccfd58e25a20eccad294a1a93168d076befb" dependencies = [ "anyhow", "indexmap", - "wasm-encoder 0.239.0", - "wasmparser 0.239.0", + "wasm-encoder 0.240.0", + "wasmparser 0.240.0", ] [[package]] @@ -1353,9 +1353,9 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c9d90bb93e764f6beabf1d02028c70a2156a6583e63ac4218dd07ef733368b0" +checksum = "b722dcf61e0ea47440b53ff83ccb5df8efec57a69d150e4f24882e4eba7e24a4" dependencies = [ "bitflags", "hashbrown", @@ -1366,22 +1366,22 @@ dependencies = [ [[package]] name = "wast" -version = "239.0.0" +version = "240.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9139176fe8a2590e0fb174cdcaf373b224cb93c3dde08e4297c1361d2ba1ea5d" +checksum = "b0efe1c93db4ac562b9733e3dca19ed7fc878dba29aef22245acf84f13da4a19" dependencies = [ "bumpalo", "leb128fmt", "memchr", "unicode-width 0.2.1", - "wasm-encoder 0.239.0", + "wasm-encoder 0.240.0", ] [[package]] name = "wat" -version = "1.239.0" +version = "1.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e1c941927d34709f255558166f8901a2005f8ab4a9650432e9281b7cc6f3b75" +checksum = "4ec9b6eab7ecd4d639d78515e9ea491c9bacf494aa5eda10823bd35992cf8c1e" dependencies = [ "wast", ] @@ -1557,8 +1557,8 @@ dependencies = [ "clap", "heck 0.5.0", "indexmap", - "wasm-encoder 0.239.0", - "wasm-metadata 0.239.0", + "wasm-encoder 0.240.0", + "wasm-metadata 0.240.0", "wit-bindgen-core", "wit-component", ] @@ -1570,7 +1570,7 @@ dependencies = [ "anyhow", "clap", "env_logger", - "wasm-encoder 0.239.0", + "wasm-encoder 0.240.0", "wit-bindgen-c", "wit-bindgen-core", "wit-bindgen-cpp", @@ -1601,8 +1601,8 @@ dependencies = [ "clap", "heck 0.5.0", "test-helpers", - "wasm-encoder 0.239.0", - "wasm-metadata 0.239.0", + "wasm-encoder 0.240.0", + "wasm-metadata 0.240.0", "wit-bindgen-c", "wit-bindgen-core", "wit-component", @@ -1616,7 +1616,7 @@ dependencies = [ "clap", "heck 0.5.0", "indexmap", - "wasm-metadata 0.239.0", + "wasm-metadata 0.240.0", "wit-bindgen-core", "wit-component", "wit-parser", @@ -1657,7 +1657,7 @@ dependencies = [ "serde_json", "syn", "test-helpers", - "wasm-metadata 0.239.0", + "wasm-metadata 0.240.0", "wit-bindgen", "wit-bindgen-core", "wit-component", @@ -1694,8 +1694,8 @@ dependencies = [ "wac-types", "wasi-preview1-component-adapter-provider", "wasm-compose", - "wasm-encoder 0.239.0", - "wasmparser 0.239.0", + "wasm-encoder 0.240.0", + "wasmparser 0.240.0", "wat", "wit-bindgen-csharp", "wit-component", @@ -1704,9 +1704,9 @@ dependencies = [ [[package]] name = "wit-component" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88a866b19dba2c94d706ec58c92a4c62ab63e482b4c935d2a085ac94caecb136" +checksum = "7dc5474b078addc5fe8a72736de8da3acfb3ff324c2491133f8b59594afa1a20" dependencies = [ "anyhow", "bitflags", @@ -1715,18 +1715,18 @@ dependencies = [ "serde", "serde_derive", "serde_json", - "wasm-encoder 0.239.0", - "wasm-metadata 0.239.0", - "wasmparser 0.239.0", + "wasm-encoder 0.240.0", + "wasm-metadata 0.240.0", + "wasmparser 0.240.0", "wat", "wit-parser", ] [[package]] name = "wit-parser" -version = "0.239.0" +version = "0.240.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55c92c939d667b7bf0c6bf2d1f67196529758f99a2a45a3355cc56964fd5315d" +checksum = "9875ea3fa272f57cc1fc50f225a7b94021a7878c484b33792bccad0d93223439" dependencies = [ "anyhow", "id-arena", @@ -1737,7 +1737,7 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser 0.239.0", + "wasmparser 0.240.0", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 6abcfbd4d..cc7bba553 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,11 +30,11 @@ prettyplease = { version = "=0.2.37" } pulldown-cmark = { version = "=0.13.0", default-features = false } serde = { version = "=1.0.228", features = ["derive"] } syn = { version = "=2.0.106", features = ["printing"] } -wasmparser = { version = "=0.239.0" } -wasm-compose = { version = "=0.239.0" } -wasm-encoder = { version = "=0.239.0" } -wasm-metadata = { version = "=0.239.0", default-features = false } -wat = { version = "=1.239.0" } +wasmparser = { version = "=0.240.0" } +wasm-compose = { version = "=0.240.0" } +wasm-encoder = { version = "=0.240.0" } +wasm-metadata = { version = "=0.240.0", default-features = false } +wat = { version = "=1.240.0" } wit-bindgen = { path = 'crates/guest-rust', version = "=0.46.0", default-features = false } wit-bindgen-c = { path = 'crates/c', version = "=0.46.0" } wit-bindgen-core = { path = 'crates/core', version = "=0.46.0" } @@ -44,8 +44,8 @@ wit-bindgen-markdown = { path = 'crates/markdown', version = "=0.46.0" } wit-bindgen-moonbit = { path = 'crates/moonbit', version = "=0.46.0" } wit-bindgen-rust = { path = "crates/rust", version = "=0.46.0" } wit-bindgen-test = { path = 'crates/test', version = "=0.46.0" } -wit-component = { version = "=0.239.0" } -wit-parser = { version = "=0.239.0" } +wit-component = { version = "=0.240.0" } +wit-parser = { version = "=0.240.0" } [[bin]] name = "wit-bindgen" diff --git a/README.md b/README.md index 0100a7808..afdee28e0 100644 --- a/README.md +++ b/README.md @@ -406,14 +406,14 @@ MoonBit can be compiled to WebAssembly using [its toolchain](https://moonbitlang moon build --target wasm # --debug to keep symbols ``` -The generated core wasm will be found under `target/wasm/release/build/r#gen/r#gen.wasm` by default. Then you can use `wasm-tools` to componentize the module: +The generated core wasm will be found under `target/wasm/release/build/gen/gen.wasm` by default. Then you can use `wasm-tools` to componentize the module: ``` -wasm-tools component embed wit target/wasm/release/build/r#gen/r#gen.wasm -o target/r#gen.wasm -wasm-tools component new target/r#gen.wasm -o target/r#gen.component.wasm +wasm-tools component embed wit target/wasm/release/build/gen/gen.wasm -o target/gen.wasm +wasm-tools component new target/gen.wasm -o target/gen.component.wasm ``` -You may use `--r#gen-dir` to specify which package should be responsible for the exportation. The default is `r#gen` as mentioned above. +You may use `--gen-dir` to specify which package should be responsible for the exportation. The default is `gen` as mentioned above. This can be useful having one project that exports multiple worlds. When using `wit-bindgen moonbit`, you may use `--derive-show` or `--derive-eq` to derive `Show` or `Eq` traits for all types. diff --git a/crates/csharp/src/function.rs b/crates/csharp/src/function.rs index 3c1192391..6b88df398 100644 --- a/crates/csharp/src/function.rs +++ b/crates/csharp/src/function.rs @@ -163,7 +163,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> { .drain(self.blocks.len() - cases.len()..) .collect::>(); let ty = self.interface_gen.type_name_with_qualifier(ty, true); - //let ty = self.r#gen.type_name(ty); + //let ty = self.gen.type_name(ty); let generics_position = ty.find('<'); let lifted = self.locals.tmp("lifted"); diff --git a/crates/moonbit/src/lib.rs b/crates/moonbit/src/lib.rs index c8a4ece68..adb022c23 100644 --- a/crates/moonbit/src/lib.rs +++ b/crates/moonbit/src/lib.rs @@ -25,7 +25,7 @@ use wit_bindgen_core::{ // - Lift/Lower list: T == Int/UInt/Int64/UInt64/Float/Double -> FixedArray[T], T == Byte -> Bytes, T == Char -> String // Organization: // - one package per interface (export and import are treated as different interfaces) -// - ffi utils are under `./ffi`, and the project entrance (package as link target) is under `./r#gen` +// - ffi utils are under `./ffi`, and the project entrance (package as link target) is under `./gen` // TODO: Export will share the type signatures with the import by using a newtype alias pub(crate) const FFI_DIR: &str = "ffi"; @@ -68,7 +68,7 @@ pub struct Opts { pub ignore_module_file: bool, /// The package/dir to generate the program entrance - #[cfg_attr(feature = "clap", arg(long, default_value = "r#gen"))] + #[cfg_attr(feature = "clap", arg(long, default_value = "gen"))] pub gen_dir: String, /// The project name ; or the package path prefix if the project is part of a larger project @@ -2775,7 +2775,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { let array = self.locals.tmp("array"); let ty = self.r#gen.type_name(element, true); let size = self.r#gen.r#gen.sizes.size(element).size_wasm32(); - // let align = self.r#gen.r#gen.sizes.align(element); + // let align = self.gen.gen.sizes.align(element); let index = self.locals.tmp("index"); let result = match &block_results[..] { @@ -3173,7 +3173,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { let length = &operands[1]; let size = self.r#gen.r#gen.sizes.size(element).size_wasm32(); - // let align = self.r#gen.r#gen.sizes.align(element); + // let align = self.gen.gen.sizes.align(element); if !body.trim().is_empty() { let index = self.locals.tmp("index"); @@ -3203,7 +3203,7 @@ impl Bindgen for FunctionBindgen<'_, '_> { Instruction::FutureLift { ty, .. } => { let result = self.locals.tmp("result"); let op = &operands[0]; - // let qualifier = self.r#gen.qualify_package(self.func_interface); + // let qualifier = self.gen.qualify_package(self.func_interface); let ty = self.r#gen.type_name(&Type::Id(*ty), true); let ffi = self.r#gen.qualify_package(FFI_DIR); diff --git a/crates/test-helpers/codegen-macro/Cargo.toml b/crates/test-helpers/codegen-macro/Cargo.toml index ba1b684e1..099024579 100644 --- a/crates/test-helpers/codegen-macro/Cargo.toml +++ b/crates/test-helpers/codegen-macro/Cargo.toml @@ -11,4 +11,4 @@ test = false [dependencies] heck = { workspace = true } -quote = "1.0.32" +quote = "=1.0.41" diff --git a/crates/test/Cargo.toml b/crates/test/Cargo.toml index de8e6b90a..1abe484b9 100644 --- a/crates/test/Cargo.toml +++ b/crates/test/Cargo.toml @@ -23,7 +23,7 @@ log = { version = "=0.4.28" } rayon = { version = "=1.11.0" } regex = { version = "=1.11.3" } serde = { workspace = true } -toml = { version = "=0.9.7" } +toml = { version = "=0.9.8" } wac-graph = { version = "=0.8.0" } wac-parser = { version = "=0.8.0" } wac-types = { version = "=0.8.0" } diff --git a/tests/runtime-async/async/future-cancel-read/test.mbt b/tests/runtime-async/async/future-cancel-read/test.mbt index e570d3685..bdb83de7b 100644 --- a/tests/runtime-async/async/future-cancel-read/test.mbt +++ b/tests/runtime-async/async/future-cancel-read/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/my/test_/i/stub.mbt' +//@ path = 'gen/interface/my/test_/i/stub.mbt' ///| pub async fn cancel_before_read( diff --git a/tests/runtime-async/async/future-cancel-write/test.mbt b/tests/runtime-async/async/future-cancel-write/test.mbt index 36a40ab15..2b1f21e8d 100644 --- a/tests/runtime-async/async/future-cancel-write/test.mbt +++ b/tests/runtime-async/async/future-cancel-write/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/my/test_/i/stub.mbt' +//@ path = 'gen/interface/my/test_/i/stub.mbt' ///| pub fn take_then_drop(x : @ffi.FutureReader[String]) -> Unit { diff --git a/tests/runtime-async/async/future-close-after-coming-back/test.mbt b/tests/runtime-async/async/future-close-after-coming-back/test.mbt index 650e7442d..9f6250656 100644 --- a/tests/runtime-async/async/future-close-after-coming-back/test.mbt +++ b/tests/runtime-async/async/future-close-after-coming-back/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/a/b/theTest/stub.mbt' +//@ path = 'gen/interface/a/b/theTest/stub.mbt' pub fn f(_param : @ffi.FutureReader[Unit]) -> @ffi.FutureReader[Unit] { _param diff --git a/tests/runtime-async/async/simple-future/test.mbt b/tests/runtime-async/async/simple-future/test.mbt index 1f1685255..f4a0e49f0 100644 --- a/tests/runtime-async/async/simple-future/test.mbt +++ b/tests/runtime-async/async/simple-future/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/my/test_/i/stub.mbt' +//@ path = 'gen/interface/my/test_/i/stub.mbt' ///| pub async fn read_future( diff --git a/tests/runtime-async/async/simple-import-params-results/test.mbt b/tests/runtime-async/async/simple-import-params-results/test.mbt index dfcb106ef..ddaaac29a 100644 --- a/tests/runtime-async/async/simple-import-params-results/test.mbt +++ b/tests/runtime-async/async/simple-import-params-results/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/a/b/i/stub.mbt' +//@ path = 'gen/interface/a/b/i/stub.mbt' ///| pub async fn one_argument(x : UInt) -> Unit { diff --git a/tests/runtime-async/async/simple-stream-payload/test.mbt b/tests/runtime-async/async/simple-stream-payload/test.mbt index 726b03423..31eb79be8 100644 --- a/tests/runtime-async/async/simple-stream-payload/test.mbt +++ b/tests/runtime-async/async/simple-stream-payload/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/my/test_/i/stub.mbt' +//@ path = 'gen/interface/my/test_/i/stub.mbt' pub async fn read_stream(x : @ffi.StreamReader[Byte]) -> Unit raise { let task = @ffi.current_task() diff --git a/tests/runtime-async/async/simple-stream/test.mbt b/tests/runtime-async/async/simple-stream/test.mbt index eeea09881..c227a69c4 100644 --- a/tests/runtime-async/async/simple-stream/test.mbt +++ b/tests/runtime-async/async/simple-stream/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/my/test_/i/stub.mbt' +//@ path = 'gen/interface/my/test_/i/stub.mbt' pub async fn read_stream(x : @ffi.StreamReader[Unit]) -> Unit noraise { let task = @ffi.current_task() diff --git a/tests/runtime/demo/test.mbt b/tests/runtime/demo/test.mbt index 581decd1c..3b7ba8f8c 100644 --- a/tests/runtime/demo/test.mbt +++ b/tests/runtime/demo/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/a/b/theTest/stub.mbt' +//@ path = 'gen/interface/a/b/theTest/stub.mbt' ///| pub fn x() -> Unit { diff --git a/tests/runtime/flavorful/test.mbt b/tests/runtime/flavorful/test.mbt index 3d6215eb0..f4b230ef4 100644 --- a/tests/runtime/flavorful/test.mbt +++ b/tests/runtime/flavorful/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/flavorful/toTest/stub.mbt' +//@ path = 'gen/interface/test_/flavorful/toTest/stub.mbt' ///| pub fn f_list_in_record1(_a : ListInRecord1) -> Unit { diff --git a/tests/runtime/lists/test.mbt b/tests/runtime/lists/test.mbt index 9f8224236..2ae06a18c 100644 --- a/tests/runtime/lists/test.mbt +++ b/tests/runtime/lists/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/lists/toTest/stub.mbt' +//@ path = 'gen/interface/test_/lists/toTest/stub.mbt' ///| pub fn empty_list_param(a : FixedArray[Byte]) -> Unit { diff --git a/tests/runtime/many-arguments/test.mbt b/tests/runtime/many-arguments/test.mbt index 2b8aa38ae..ce19472f8 100644 --- a/tests/runtime/many-arguments/test.mbt +++ b/tests/runtime/many-arguments/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/many_arguments/toTest/stub.mbt' +//@ path = 'gen/interface/test_/many_arguments/toTest/stub.mbt' ///| pub fn many_arguments( _a1 : UInt64, diff --git a/tests/runtime/numbers/test.mbt b/tests/runtime/numbers/test.mbt index fd3863a5d..2f2e94d6a 100644 --- a/tests/runtime/numbers/test.mbt +++ b/tests/runtime/numbers/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/numbers/numbers/stub.mbt' +//@ path = 'gen/interface/test_/numbers/numbers/stub.mbt' ///| pub fn roundtrip_u8(a : Byte) -> Byte { diff --git a/tests/runtime/results/leaf.mbt b/tests/runtime/results/leaf.mbt index cbb031dae..40fc74fd1 100644 --- a/tests/runtime/results/leaf.mbt +++ b/tests/runtime/results/leaf.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/results/test/stub.mbt' +//@ path = 'gen/interface/test_/results/test/stub.mbt' ///| pub fn string_error(_a : Float) -> Result[Float, String] { diff --git a/tests/runtime/strings/test.mbt b/tests/runtime/strings/test.mbt index ba907aa2a..66095b056 100644 --- a/tests/runtime/strings/test.mbt +++ b/tests/runtime/strings/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/strings/toTest/stub.mbt' +//@ path = 'gen/interface/test_/strings/toTest/stub.mbt' ///| pub fn take_basic(s : String) -> Unit { diff --git a/tests/runtime/variants/test.mbt b/tests/runtime/variants/test.mbt index 6d90d4b80..88ab721a4 100644 --- a/tests/runtime/variants/test.mbt +++ b/tests/runtime/variants/test.mbt @@ -1,5 +1,5 @@ //@ [lang] -//@ path = 'r#gen/interface/test_/variants/toTest/stub.mbt' +//@ path = 'gen/interface/test_/variants/toTest/stub.mbt' ///| pub fn roundtrip_option(a : Float?) -> Byte? {