Generate nominal IDs for all bindings generation

crates/c/src/lib.rs

@@ -186,13 +186,18 @@ impl WorldGenerator for C {
         let world = &resolve.worlds[world];
         for (key, _item) in world.imports.iter().chain(world.exports.iter()) {
             let name = resolve.name_world_key(key);
-            interfaces.insert(name, key.clone());
+            interfaces
+                .entry(name)
+                .or_insert(Vec::new())
+                .push(key.clone());
         }
 
         for (from, to) in self.opts.rename.iter() {
             match interfaces.get(from) {
-                Some(key) => {
-                    self.renamed_interfaces.insert(key.clone(), to.clone());
+                Some(keys) => {
+                    for key in keys {
+                        self.renamed_interfaces.insert(key.clone(), to.clone());
+                    }
                 }
                 None => {
                     eprintln!("warning: rename of `{from}` did not match any interfaces");

crates/core/src/lib.rs

@@ -23,7 +23,10 @@ pub enum Direction {
 }
 
 pub trait WorldGenerator {
-    fn generate(&mut self, resolve: &Resolve, id: WorldId, files: &mut Files) -> Result<()> {
+    fn generate(&mut self, resolve: &mut Resolve, id: WorldId, files: &mut Files) -> Result<()> {
+        if self.uses_nominal_type_ids() {
+            resolve.generate_nominal_type_ids(id);
+        }
         let world = &resolve.worlds[id];
         self.preprocess(resolve, id);
 
@@ -81,6 +84,13 @@ pub trait WorldGenerator {
         self.finish(resolve, id, files)
     }
 
+    /// Whether or not this bindings generator expects
+    /// [`Resolve::generate_nominal_type_ids`] to be used before generating
+    /// bindings.
+    fn uses_nominal_type_ids(&self) -> bool {
+        true
+    }
+
     fn finish_imports(&mut self, resolve: &Resolve, world: WorldId, files: &mut Files) {
         let _ = (resolve, world, files);
     }

crates/go/src/lib.rs

@@ -661,6 +661,14 @@ func Lift{upper_kind}{camel}(handle int32) *wit_types.{upper_kind}Reader[{payloa
 }
 
 impl WorldGenerator for Go {
+    // FIXME(#1527): this caused failures in CI at
+    // https://github.com/bytecodealliance/wit-bindgen/actions/runs/21880247244/job/63160400774?pr=1526
+    // and should be fixed at some point by deleting this method and getting
+    // tests passing again.
+    fn uses_nominal_type_ids(&self) -> bool {
+        false
+    }
+
     fn preprocess(&mut self, resolve: &Resolve, world: WorldId) {
         _ = world;
         self.sizes.fill(resolve);
@@ -1718,7 +1726,7 @@ for index, {ITER_ELEMENT} := range {slice} {{
 for index := 0; index < int({length}); index++ {{
         {ITER_BASE_POINTER} := unsafe.Add(unsafe.Pointer({value}), index * {size})
         {body}
-        {result} = append({result}, {body_result})        
+        {result} = append({result}, {body_result})
 }}
 "
                 );
@@ -2514,7 +2522,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
             self.src,
             "
 {docs}type {name} struct {{
-        {fields} 
+        {fields}
 }}"
         )
     }

crates/guest-rust/macro/src/lib.rs

@@ -242,11 +242,11 @@ fn parse_source(
 }
 
 impl Config {
-    fn expand(self) -> Result<TokenStream> {
+    fn expand(mut self) -> Result<TokenStream> {
         let mut files = Default::default();
         let mut generator = self.opts.build();
         generator
-            .generate(&self.resolve, self.world, &mut files)
+            .generate(&mut self.resolve, self.world, &mut files)
             .map_err(|e| anyhow_to_syn(Span::call_site(), e))?;
         let (_, src) = files.iter().next().unwrap();
         let mut src = std::str::from_utf8(src).unwrap().to_string();

crates/rust/src/interface.rs

@@ -2441,23 +2441,7 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
 
     pub fn is_exported_resource(&self, ty: TypeId) -> bool {
         let ty = dealias(self.resolve, ty);
-        let ty = &self.resolve.types[ty];
-        match &ty.kind {
-            TypeDefKind::Resource => {}
-            _ => return false,
-        }
-
-        match ty.owner {
-            // Worlds cannot export types of any kind as of this writing.
-            TypeOwner::World(_) => false,
-
-            // Interfaces are "stateful" currently where whatever we last saw
-            // them as dictates whether it's exported or not.
-            TypeOwner::Interface(i) => !self.r#gen.interface_last_seen_as_import[&i],
-
-            // Shouldn't be the case for resources
-            TypeOwner::None => unreachable!(),
-        }
+        self.r#gen.exported_resources.contains(&ty)
     }
 
     fn push_string_name(&mut self) {

crates/rust/src/lib.rs

@@ -36,8 +36,7 @@ pub struct RustWasm {
     export_modules: Vec<(String, Vec<String>)>,
     skip: HashSet<String>,
     interface_names: HashMap<InterfaceId, InterfaceName>,
-    /// Each imported and exported interface is stored in this map. Value indicates if last use was import.
-    interface_last_seen_as_import: HashMap<InterfaceId, bool>,
+    exported_resources: HashSet<TypeId>,
     import_funcs_called: bool,
     with_name_counter: usize,
     // Track which interfaces and types are generated. Remapped interfaces and types provided via `with`
@@ -302,7 +301,7 @@ impl RustWasm {
         let world = resolve.select_world(&main_packages, world)?;
 
         let mut files = Files::default();
-        self.generate(&resolve, world, &mut files)?;
+        self.generate(&mut resolve, world, &mut files)?;
         let out_dir = std::env::var("OUT_DIR").expect("cargo sets OUT_DIR");
         let (name, contents) = files
             .iter()
@@ -446,7 +445,8 @@ impl RustWasm {
         };
 
         let remapped = entry.remapped;
-        self.interface_names.insert(id, entry);
+        let prev = self.interface_names.insert(id, entry);
+        assert!(prev.is_none());
 
         Ok(remapped)
     }
@@ -1117,6 +1117,18 @@ impl WorldGenerator for RustWasm {
             }
         }
 
+        for item in world.exports.values() {
+            let WorldItem::Interface { id, .. } = item else {
+                continue;
+            };
+            for id in resolve.interfaces[*id].types.values().copied() {
+                let TypeDefKind::Resource = &resolve.types[id].kind else {
+                    continue;
+                };
+                assert!(self.exported_resources.insert(id));
+            }
+        }
+
         for (k, v) in self.opts.with.iter() {
             self.with.insert(k.clone(), v.clone().into());
         }
@@ -1144,7 +1156,6 @@ impl WorldGenerator for RustWasm {
             self.generated_types.insert(full_name);
         }
 
-        self.interface_last_seen_as_import.insert(id, true);
         let wasm_import_module = resolve.name_world_key(name);
         let mut r#gen = self.interface(
             Identifier::Interface(id, name),
@@ -1201,7 +1212,6 @@ impl WorldGenerator for RustWasm {
             self.generated_types.insert(full_name);
         }
 
-        self.interface_last_seen_as_import.insert(id, false);
         let wasm_import_module = format!("[export]{}", resolve.name_world_key(name));
         let mut r#gen = self.interface(
             Identifier::Interface(id, name),

src/bin/wit-bindgen.rs

@@ -232,7 +232,7 @@ fn gen_world(
         main_packages.push(pkg);
     }
     let world = resolve.select_world(&main_packages, opts.world.as_deref())?;
-    generator.generate(&resolve, world, files)?;
+    generator.generate(&mut resolve, world, files)?;
 
     Ok(())
 }