fix(rust): dealias stream/future types

crates/rust/src/interface.rs

@@ -1753,7 +1753,16 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
         }
 
         match ty {
-            Type::Id(t) => self.print_tyid(*t, mode),
+            Type::Id(t) => {
+                // When generating names for stream/future payload types, dealias
+                // all inner type references so that `use`d type aliases from
+                // different interfaces resolve to the same canonical type
+                let t = match self.identifier {
+                    Identifier::StreamOrFuturePayload => dealias(self.resolve, *t),
+                    _ => *t,
+                };
+                self.print_tyid(t, mode)
+            }
             Type::Bool => self.push_str("bool"),
             Type::U8 => self.push_str("u8"),
             Type::U16 => self.push_str("u16"),

crates/rust/tests/codegen.rs

@@ -172,3 +172,4 @@ mod retyped_list {
         }
     });
 }
+

tests/codegen/import-export-future.wit

@@ -5,13 +5,28 @@ package a:b;
 world w {
     import i;
     export i;
+    import j;
+    import k;
 }
 
 interface i {
     use t.{r};
     f: func(p: future<r>);
 }
 
+// Multiple interfaces `use`-ing the same type from a shared interface
+// and wrapping it in an anonymous type (result<_, r>) ensures that
+// dealiasing resolves inner types, not just top-level payload types.
+interface j {
+    use t.{r};
+    f: func() -> future<result<_, r>>;
+}
+
+interface k {
+    use t.{r};
+    f: func() -> future<result<_, r>>;
+}
+
 interface t {
     record r {
         x: u32,

tests/codegen/import-export-stream.wit

@@ -5,13 +5,28 @@ package a:b;
 world w {
     import i;
     export i;
+    import j;
+    import k;
 }
 
 interface i {
     use t.{r};
     f: func(p: stream<r>);
 }
 
+// Multiple interfaces `use`-ing the same type from a shared interface
+// and wrapping it in an anonymous type (result<_, r>) ensures that
+// dealiasing resolves inner types, not just top-level payload types.
+interface j {
+    use t.{r};
+    f: func() -> stream<result<_, r>>;
+}
+
+interface k {
+    use t.{r};
+    f: func() -> stream<result<_, r>>;
+}
+
 interface t {
     record r {
         x: u32,