Redefine with in the Rust generator to only apply to imports (#1367)

This commit avoids looking at `--with` for exports, for example, to fix
situations where an interface is imported and exported and only the
import types should be reused from elsewhere. I'm not aware of any cases
where exports want to be reused, so there's effectively no more support
for that.

Author: alexcrichton

.github/workflows/main.yml

@@ -152,6 +152,7 @@ jobs:
     - run: cargo test
     - run: cargo test -p wit-bindgen-core
     - run: cargo test -p wit-bindgen
+    - run: cargo test -p wit-bindgen-rust
     - run: cargo test --workspace --exclude 'wit-bindgen*'
     - run: cargo test -p wit-bindgen-rt --all-features
     - run: rustup update nightly --no-self-update

crates/rust/src/lib.rs

@@ -221,7 +221,8 @@ pub struct Opts {
     #[cfg_attr(feature = "clap", arg(long, value_name = "NAME"))]
     pub additional_derive_ignore: Vec<String>,
 
-    /// Remapping of wit interface and type names to Rust module names and types.
+    /// Remapping of wit import interface and type names to Rust module names
+    /// and types.
     ///
     /// Argument must be of the form `k=v` and this option can be passed
     /// multiple times or one option can be comma separated, for example
@@ -384,8 +385,13 @@ impl RustWasm {
         is_export: bool,
     ) -> Result<bool> {
         let with_name = resolve.name_world_key(name);
-        let Some(remapping) = self.with.get(&with_name) else {
-            bail!(MissingWith(with_name));
+        let remapping = if is_export {
+            &TypeGeneration::Generate
+        } else {
+            match self.with.get(&with_name) {
+                Some(remapping) => remapping,
+                None => bail!(MissingWith(with_name)),
+            }
         };
         self.generated_types.insert(with_name);
         let entry = match remapping {
@@ -1066,8 +1072,9 @@ impl WorldGenerator for RustWasm {
         self.world = Some(world);
 
         let world = &resolve.worlds[world];
-        // Specify that all imports local to the world's package should be generated
-        for (key, item) in world.imports.iter().chain(world.exports.iter()) {
+        // Specify that all imports local to the world's package should be
+        // generated
+        for (key, item) in world.imports.iter() {
             if let WorldItem::Interface { id, .. } = item {
                 if resolve.interfaces[*id].package == world.package {
                     let name = resolve.name_world_key(key);
@@ -1158,14 +1165,7 @@ impl WorldGenerator for RustWasm {
         let mut to_define = Vec::new();
         for (name, ty_id) in resolve.interfaces[id].types.iter() {
             let full_name = full_wit_type_name(resolve, *ty_id);
-            if let Some(type_gen) = self.with.get(&full_name) {
-                // skip type definition generation for remapped types
-                if type_gen.generated() {
-                    to_define.push((name, ty_id));
-                }
-            } else {
-                to_define.push((name, ty_id));
-            }
+            to_define.push((name, ty_id));
             self.generated_types.insert(full_name);
         }
 

crates/rust/tests/wit/path3/package.wit

@@ -0,0 +1,3 @@
+package test:inline-and-path;
+
+interface bar {}

crates/test/src/c.rs

@@ -21,8 +21,6 @@ pub struct COpts {
 
 pub struct C;
 
-pub struct Cpp;
-
 /// C/C++-specific configuration of component files
 #[derive(Default, Deserialize)]
 #[serde(deny_unknown_fields)]
@@ -40,14 +38,6 @@ fn clang(runner: &Runner<'_>) -> PathBuf {
     }
 }
 
-fn clangpp(runner: &Runner<'_>) -> PathBuf {
-    let target = &runner.opts.c.c_target;
-    match &runner.opts.c.wasi_sdk_path {
-        Some(path) => path.join(format!("bin/{target}-clang++")),
-        None => format!("{target}-clang++").into(),
-    }
-}
-
 impl LanguageMethods for C {
     fn display(&self) -> &str {
         "c"
@@ -87,41 +77,6 @@ impl LanguageMethods for C {
     }
 }
 
-impl LanguageMethods for Cpp {
-    fn display(&self) -> &str {
-        "cpp"
-    }
-
-    fn bindgen_name(&self) -> Option<&str> {
-        Some("c")
-    }
-
-    fn comment_prefix_for_test_config(&self) -> Option<&str> {
-        Some("//@")
-    }
-
-    fn should_fail_verify(
-        &self,
-        name: &str,
-        config: &crate::config::WitConfig,
-        args: &[String],
-    ) -> bool {
-        C.should_fail_verify(name, config, args)
-    }
-
-    fn prepare(&self, runner: &mut Runner<'_>) -> Result<()> {
-        prepare(runner, clangpp(runner))
-    }
-
-    fn compile(&self, runner: &Runner<'_>, c: &Compile<'_>) -> Result<()> {
-        compile(runner, c, clangpp(runner))
-    }
-
-    fn verify(&self, runner: &Runner<'_>, v: &Verify<'_>) -> Result<()> {
-        verify(runner, v, clangpp(runner))
-    }
-}
-
 fn prepare(runner: &mut Runner<'_>, compiler: PathBuf) -> Result<()> {
     let cwd = env::current_dir()?;
     let dir = cwd.join(&runner.opts.artifacts).join("c");

tests/runtime/rust/with-only-affects-imports/compose.wac

@@ -0,0 +1,13 @@
+package example:composition;
+
+let leaf = new test:leaf { ... };
+let intermediate = new test:test {
+  foo: leaf.foo,
+  ...
+};
+let runner = new test:runner {
+  foo: intermediate.foo,
+  ...
+};
+
+export runner...;

tests/runtime/rust/with-only-affects-imports/leaf.rs

@@ -0,0 +1,13 @@
+include!(env!("BINDINGS"));
+
+struct Component;
+
+export!(Component);
+
+use crate::exports::my::inline::foo::{Guest, A};
+
+impl Guest for Component {
+    fn bar(a: A) {
+        assert_eq!(a.b, 2);
+    }
+}

tests/runtime/rust/with-only-affects-imports/runner.rs

@@ -0,0 +1,5 @@
+include!(env!("BINDINGS"));
+
+fn main() {
+    my::inline::foo::bar(my::inline::foo::A { b: 2 });
+}

tests/runtime/rust/with-only-affects-imports/test.rs

@@ -0,0 +1,40 @@
+//@ args = '--with my:inline/foo=other::my::inline::foo'
+
+#![expect(
+    unused_imports,
+    reason = "using `with` is known to produce possibly dead imports"
+)]
+
+include!(env!("BINDINGS"));
+
+mod other {
+    wit_bindgen::generate!({
+        inline: "
+            package my:inline;
+
+            interface foo {
+                record a { b: u8 }
+
+                bar: func(a: a);
+            }
+
+            world gen {
+                import foo;
+            }
+        ",
+    });
+}
+
+struct Component;
+
+export!(Component);
+
+use crate::exports::my::inline::foo::{Guest, A};
+use std::any::TypeId;
+
+impl Guest for Component {
+    fn bar(a: A) {
+        assert!(TypeId::of::<A>() != TypeId::of::<other::my::inline::foo::A>());
+        other::my::inline::foo::bar(other::my::inline::foo::A { b: a.b })
+    }
+}

tests/runtime/rust/with-only-affects-imports/test.wit

@@ -0,0 +1,25 @@
+//@ dependencies = ['test', 'leaf']
+//@ wac = 'compose.wac'
+
+package my:inline;
+
+interface foo {
+    record a {
+      b: u8,
+    }
+
+    bar: func(a: a);
+}
+
+world leaf {
+    export foo;
+}
+
+world test {
+    import foo;
+    export foo;
+}
+
+world runner {
+    import foo;
+}