rust: qualify world-owned type paths so future/stream payload vtables resolve

Author: mattwilkinsonn

crates/rust/src/interface.rs

@@ -1882,12 +1882,16 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
     }
 
     fn type_path_with_name(&self, id: TypeId, name: String) -> String {
-        if let TypeOwner::Interface(id) = self.resolve.types[id].owner {
-            if let Some(path) = self.path_to_interface(id) {
-                return format!("{path}::{name}");
-            }
+        match self.resolve.types[id].owner {
+            TypeOwner::Interface(iface) => match self.path_to_interface(iface) {
+                Some(path) => format!("{path}::{name}"),
+                None => name,
+            },
+            // World-level aliases live at macro root. `path_to_root()` is
+            // `""` at root, `"super::super::"` in stream/future payload mode.
+            TypeOwner::World(_) => format!("{}{name}", self.path_to_root()),
+            TypeOwner::None => name,
         }
-        name
     }
 
     fn print_tyid(&mut self, id: TypeId, mode: TypeMode) {

crates/rust/tests/codegen.rs

@@ -235,3 +235,25 @@ mod method_chaining {
         enable_method_chaining: true
     });
 }
+
+// Regression for #1598: world-level `use t.{r};` inside
+// `future<result<r, _>>` used to emit unresolved bare `R` in vtable{N}.
+#[allow(unused, reason = "testing codegen, not functionality")]
+mod issue_1598_future_result_use {
+    wit_bindgen::generate!({
+        inline: r#"
+        package a:b;
+
+        world w {
+            use t.{r};
+            export f: func() -> future<result<r, string>>;
+        }
+
+        interface t {
+            record r {
+                x: u32,
+            }
+        }
+        "#,
+    });
+}