Add --type-section-suffix to the Rust generator (#859)

Same motivation as the C generator, just for a different one.

Author: alexcrichton

crates/guest-rust/src/lib.rs

@@ -274,6 +274,13 @@ use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
 ///     // case above if possible.
 ///     ownership: Borrowing { duplicate_if_necessary: false },
 ///
+///     // This will suffix the custom section containing component type
+///     // information with the specified string. This is not required by
+///     // default but if the same world is generated in two different locations
+///     // in the crate then one bindings generation location will need this
+///     // suffix to avoid having the custom sections corrupt each other.
+///     type_section_suffix: "suffix",
+///
 ///     // Configures the path to the `wit-bindgen` crate itself. By default
 ///     // this is `wit_bindgen` assuming that your crate depends on the
 ///     // `wit-bindgen` crate itself.

crates/rust-macro/src/lib.rs

@@ -103,6 +103,9 @@ impl Parse for Config {
                             .collect()
                     }
                     Opt::With(with) => opts.with.extend(with),
+                    Opt::TypeSectionSuffix(suffix) => {
+                        opts.type_section_suffix = Some(suffix.value())
+                    }
                 }
             }
         } else {
@@ -216,6 +219,7 @@ mod kw {
     syn::custom_keyword!(export_prefix);
     syn::custom_keyword!(additional_derives);
     syn::custom_keyword!(with);
+    syn::custom_keyword!(type_section_suffix);
 }
 
 #[derive(Clone)]
@@ -276,6 +280,7 @@ enum Opt {
     // Parse as paths so we can take the concrete types/macro names rather than raw strings
     AdditionalDerives(Vec<syn::Path>),
     With(HashMap<String, String>),
+    TypeSectionSuffix(syn::LitStr),
 }
 
 impl Parse for Opt {
@@ -381,6 +386,10 @@ impl Parse for Opt {
             let fields: Punctuated<_, Token![,]> =
                 contents.parse_terminated(with_field_parse, Token![,])?;
             Ok(Opt::With(HashMap::from_iter(fields.into_iter())))
+        } else if l.peek(kw::type_section_suffix) {
+            input.parse::<kw::type_section_suffix>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::TypeSectionSuffix(input.parse()?))
         } else {
             Err(l.error())
         }

crates/rust/src/lib.rs

@@ -171,6 +171,11 @@ pub struct Opts {
     /// Remapping of interface names to rust module names.
     #[cfg_attr(feature = "clap", arg(long, value_parser = parse_with, default_value = ""))]
     pub with: HashMap<String, String>,
+
+    /// Add the specified suffix to the name of the custome section containing
+    /// the component type.
+    #[cfg_attr(feature = "clap", arg(long))]
+    pub type_section_suffix: Option<String>,
 }
 
 impl Opts {
@@ -533,8 +538,10 @@ impl WorldGenerator for RustWasm {
         // otherwise is attempted to be unique here to ensure that this doesn't get
         // concatenated to other custom sections by LLD by accident since LLD will
         // concatenate custom sections of the same name.
-        self.src
-            .push_str(&format!("#[link_section = \"component-type:{}\"]\n", name,));
+        let suffix = self.opts.type_section_suffix.as_deref().unwrap_or("");
+        self.src.push_str(&format!(
+            "#[link_section = \"component-type:{name}{suffix}\"]\n"
+        ));
 
         let mut producers = wasm_metadata::Producers::empty();
         producers.add(

crates/test-rust-wasm/Cargo.toml

@@ -102,3 +102,7 @@ test = false
 [[bin]]
 name = "resource_borrow_simple"
 test = false
+
+[[bin]]
+name = "type_section_suffix"
+test = false

crates/test-rust-wasm/src/bin/type_section_suffix.rs

@@ -0,0 +1,3 @@
+include!("../../../../tests/runtime/type_section_suffix/wasm.rs");
+
+fn main() {}

tests/runtime/main.rs

@@ -35,6 +35,7 @@ mod resource_with_lists;
 mod resources;
 mod smoke;
 mod strings;
+mod type_section_suffix;
 mod variants;
 mod versions;
 

tests/runtime/type_section_suffix.rs

@@ -0,0 +1,29 @@
+use anyhow::{Ok, Result};
+use wasmtime::Store;
+
+wasmtime::component::bindgen!("required-exports" in "tests/runtime/type_section_suffix");
+use self::test::suffix::imports::Host;
+
+#[derive(Default)]
+pub struct MyFoo;
+
+impl Host for MyFoo {
+    fn foo(&mut self) -> wasmtime::Result<()> {
+        Ok(())
+    }
+}
+
+#[test]
+fn run() -> Result<()> {
+    crate::run_test(
+        "type_section_suffix",
+        |linker| RequiredExports::add_to_linker(linker, |x| &mut x.0),
+        |store, component, linker| RequiredExports::instantiate(store, component, linker),
+        run_test,
+    )
+}
+
+fn run_test(exports: RequiredExports, store: &mut Store<crate::Wasi<MyFoo>>) -> Result<()> {
+    exports.call_run(&mut *store)?;
+    Ok(())
+}

tests/runtime/type_section_suffix/wasm.rs

@@ -0,0 +1,33 @@
+wit_bindgen::generate!({
+    path: "../../tests/runtime/type_section_suffix",
+    world: "required-exports",
+    exports: {
+        world: Exports
+    }
+});
+
+// generate bindings once here
+mod a {
+    wit_bindgen::generate!(
+        "available-imports" in "../../tests/runtime/type_section_suffix"
+    );
+}
+
+// generate bindings again for the same world, this time using a different
+// suffix
+mod b {
+    wit_bindgen::generate!({
+        world: "available-imports",
+        path: "../../tests/runtime/type_section_suffix",
+        type_section_suffix: "hello i am a suffix how are you doing today",
+    });
+}
+
+struct Exports;
+
+impl Guest for Exports {
+    fn run() {
+        a::test::suffix::imports::foo();
+        b::test::suffix::imports::foo();
+    }
+}

tests/runtime/type_section_suffix/world.wit

@@ -0,0 +1,15 @@
+package test:suffix;
+
+interface imports {
+  foo: func();
+}
+
+world available-imports {
+  import imports;
+}
+
+world required-exports {
+  include available-imports;
+
+  export run: func();
+}

tests/runtime/versions/wasm.rs

@@ -24,23 +24,23 @@ impl Guest for Component {
 }
 
 struct Component1;
-impl v1 for Component1{ 
+impl v1 for Component1 {
     fn x() -> f32 {
         1.0
     }
 
     fn y(a: f32) -> f32 {
-        1.0+a
+        1.0 + a
     }
 }
 
 struct Component2;
-impl v2 for Component2{ 
+impl v2 for Component2 {
     fn x() -> f32 {
         2.0
     }
 
     fn z(a: f32, b: f32) -> f32 {
-        2.0+a+b
+        2.0 + a + b
     }
 }