Generate nominal IDs for all bindings generation (#1526)

* Generate nominal IDs for all bindings generation

This commit leverages bytecodealliance/wasm-tools#2447 to make many
existing and future problems much easier in `wit-bindgen`. Namely a
`TypeId` now uniquely identifies a type to be generated rather than
simultaneously representing both an import and an export in some
situations. This isn't immediately leveraged in bindings generators just
yet but it's intended to open up the doors to benefitting from this in
the future.

* Rely on nominal type ids in the rust generator

No major changes just yet, but this shows some examples of removing
non-obvious logic in bindings generation enabled by nominal type ids.

* Fix Go CI

Author: alexcrichton

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(())
 }