fix(rust): Restrict equal types to the current world (#1549)

* move name_interface to preprocess phase; restrict equal types to the current world

* add test

* remove stale failed tests

* include primitive types

* add back wasi-http-borrowed

* comments

* use LiveTypes

* fix

Author: chenyan2002

crates/core/src/types.rs

@@ -95,8 +95,7 @@ impl Types {
         }
     }
 
-    /// Populates the return value of [`Types::get_representative_type`] with
-    /// the `resolve` passed in.
+    /// Identify all the structurally equal types reachable from the `world_id`.
     ///
     /// The `may_alias_another_type` closure is used to determine whether the
     /// language's definition of the provided `TypeId` might possibly alias
@@ -109,19 +108,22 @@ impl Types {
     pub fn collect_equal_types(
         &mut self,
         resolve: &Resolve,
+        world_id: WorldId,
         may_alias_another_type: &dyn Fn(TypeId) -> bool,
     ) {
-        for (i, (ty, _)) in resolve.types.iter().enumerate() {
+        let mut live_types = wit_parser::LiveTypes::default();
+        live_types.add_world(resolve, world_id);
+        for (i, ty) in live_types.iter().enumerate() {
             if !may_alias_another_type(ty) {
                 continue;
             }
             // TODO: we could define a hash function for TypeDefKind to prevent the inner loop.
-            for (earlier, _) in resolve.types.iter().take(i) {
+            for earlier in live_types.iter().take(i) {
                 if self.equal_types.find(ty) == self.equal_types.find(earlier) {
                     continue;
                 }
                 // The correctness of is_structurally_equal relies on the fact
-                // that resolve.types.iter() is in topological order.
+                // that live_types.iter() is in topological order.
                 if self.is_structurally_equal(resolve, ty, earlier) {
                     self.equal_types.union(ty, earlier);
                     break;

crates/rust/src/interface.rs

@@ -556,10 +556,7 @@ macro_rules! {macro_name} {{
         }
 
         // Use the original (non-canonicalized) type for generating the
-        // type name and code. The canonical representative may belong to
-        // an interface that hasn't been processed yet (when world import
-        // order differs from WIT definition order), which would cause
-        // `path_to_interface` to panic. Since structurally equal types
+        // type name and code. Since structurally equal types
         // resolve to the same Rust type, it doesn't matter which alias
         // path we use in the generated `impl`.
         let payload_type = match payload_type {
@@ -2431,7 +2428,11 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
     }
 
     fn path_to_interface(&self, interface: InterfaceId) -> Option<String> {
-        let InterfaceName { path, remapped } = &self.r#gen.interface_names[&interface];
+        let Some(InterfaceName { path, remapped }) = &self.r#gen.interface_names.get(&interface)
+        else {
+            let name = self.resolve.interfaces[interface].name.as_ref().unwrap();
+            panic!("Cannot find interface {interface:?}: {name}");
+        };
         if *remapped {
             let mut path_to_root = self.path_to_root();
             path_to_root.push_str(path);

crates/rust/src/lib.rs

@@ -1129,7 +1129,7 @@ impl WorldGenerator for RustWasm {
             uwriteln!(self.src_preamble, "//   * async: {opt}");
         }
         self.types.analyze(resolve);
-        self.types.collect_equal_types(resolve, &|a| {
+        self.types.collect_equal_types(resolve, world, &|a| {
             // If `--merge-structurally-equal-types` is enabled then any type
             // anywhere can be generated as a type alias to anything else.
             if self.opts.merge_structurally_equal_types() {
@@ -1194,6 +1194,16 @@ impl WorldGenerator for RustWasm {
             self.with.insert(k.clone(), v.clone().into());
         }
         self.with.generate_by_default = self.opts.generate_all;
+        for (key, item) in world.imports.iter() {
+            if let WorldItem::Interface { id, .. } = item {
+                self.name_interface(resolve, *id, &key, false).unwrap();
+            }
+        }
+        for (key, item) in world.exports.iter() {
+            if let WorldItem::Interface { id, .. } = item {
+                self.name_interface(resolve, *id, &key, true).unwrap();
+            }
+        }
     }
 
     fn import_interface(
@@ -1225,7 +1235,7 @@ impl WorldGenerator for RustWasm {
             true,
         );
         let (snake, module_path) = r#gen.start_append_submodule(name);
-        if r#gen.r#gen.name_interface(resolve, id, name, false)? {
+        if r#gen.r#gen.interface_names[&id].remapped {
             return Ok(());
         }
 
@@ -1281,7 +1291,7 @@ impl WorldGenerator for RustWasm {
             false,
         );
         let (snake, module_path) = r#gen.start_append_submodule(name);
-        if r#gen.r#gen.name_interface(resolve, id, name, true)? {
+        if r#gen.r#gen.interface_names[&id].remapped {
             return Ok(());
         }
 

crates/test/src/rust.rs

@@ -76,12 +76,6 @@ impl LanguageMethods for Rust {
             return true;
         }
 
-        // The merge-structurally-equal-types flag panics on wasi-filesystem
-        // due to missing interface_names entries after type merging.
-        if name == "wasi-filesystem-merge-equal" {
-            return true;
-        }
-
         // Named fixed-length lists don't work with async yet.
         if name == "named-fixed-length-list.wit-async" {
             return true;

tests/codegen/merge-structurally-equal-types.wit

@@ -1,5 +1,14 @@
 package test:merge-equal;
 
+// This interface is not reachable from the test world,
+// so it cannot be used as a representative type
+interface unreachable {
+    record payload {
+        data: list<u8>,
+        tag: string,
+    }
+}
+
 interface importer {
     record payload {
         data: list<u8>,