fix: disambiguate colliding WIT import interface names

When multiple WIT packages export an interface with the same name
(e.g. a:pkg/types and b:pkg/types), the generated Rust traits have
duplicate associated types and getters, causing compilation to fail.

Add collision detection that scans import declarations for duplicate
interface names. When a collision is found, the full namespace path is
prepended to produce unique names (e.g. APkgTypes vs BPkgTypes).
Apply this to host, guest, and runtime type generation, and extend it
to handle versioned import name collisions where two versioned imports
share the same namespace path.

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Author: jsturtevant

src/hyperlight_component_util/src/emit.rs

@@ -15,14 +15,111 @@ limitations under the License.
  */
 
 //! A bunch of utilities used by the actual code emit functions
-use std::collections::{BTreeMap, BTreeSet, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 use std::vec::Vec;
 
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::Ident;
 
-use crate::etypes::{BoundedTyvar, Defined, Handleable, ImportExport, TypeBound, Tyvar};
+use crate::etypes::{
+    BoundedTyvar, Defined, ExternDecl, ExternDesc, Handleable, ImportExport, TypeBound, Tyvar,
+};
+
+/// Import interface names that need generated trait member disambiguation.
+#[derive(Clone, Debug, Default)]
+pub struct ImportNameCollisions {
+    short_names: HashSet<String>,
+    qualified_names: HashSet<(Vec<String>, String)>,
+}
+impl ImportNameCollisions {
+    pub fn is_empty(&self) -> bool {
+        self.short_names.is_empty() && self.qualified_names.is_empty()
+    }
+    pub fn len(&self) -> usize {
+        self.short_names.len()
+    }
+    pub fn contains(&self, name: &str) -> bool {
+        self.short_names.contains(name)
+    }
+    fn qualified_contains(&self, wn: &WitName) -> bool {
+        self.qualified_names.contains(&qualified_import_key(wn))
+    }
+}
+
+fn qualified_import_key(wn: &WitName) -> (Vec<String>, String) {
+    (
+        wn.namespaces.iter().map(|ns| ns.to_string()).collect(),
+        wn.name.to_string(),
+    )
+}
+
+fn version_to_kebab(version: &[&str]) -> String {
+    version
+        .join("-")
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() {
+                c.to_ascii_lowercase()
+            } else {
+                '-'
+            }
+        })
+        .collect()
+}
+
+/// Scan a list of import extern decls for interface name collisions.
+/// Returns import names that need disambiguating, tracking when the
+/// namespace-qualified name still collides and must include the version.
+pub fn find_colliding_import_names(imports: &[ExternDecl]) -> ImportNameCollisions {
+    let mut short_counts = HashMap::<String, usize>::new();
+    let mut qualified_counts = HashMap::<(Vec<String>, String), usize>::new();
+    for ed in imports {
+        if let ExternDesc::Instance(_) = &ed.desc {
+            let wn = split_wit_name(ed.kebab_name);
+            *short_counts.entry(wn.name.to_string()).or_default() += 1;
+            *qualified_counts
+                .entry(qualified_import_key(&wn))
+                .or_default() += 1;
+        }
+    }
+    let short_names = short_counts
+        .into_iter()
+        .filter(|(_, c)| *c > 1)
+        .map(|(n, _)| n)
+        .collect();
+    let qualified_names = qualified_counts
+        .into_iter()
+        .filter(|(_, c)| *c > 1)
+        .map(|(n, _)| n)
+        .collect();
+    ImportNameCollisions {
+        short_names,
+        qualified_names,
+    }
+}
+
+/// Get the disambiguated type and getter names for an import instance.
+/// If the interface name collides with another import, prepend the full
+/// kebab-joined namespace path to disambiguate
+/// (e.g. "types" from "wasi:http" becomes "WasiHttpTypes"/"wasi_http_types").
+pub fn import_member_names(wn: &WitName, collisions: &ImportNameCollisions) -> (Ident, Ident) {
+    if collisions.contains(wn.name) {
+        let prefix = if wn.namespaces.is_empty() {
+            wn.name.to_string()
+        } else {
+            wn.namespaces.join("-")
+        };
+        let mut qualified = format!("{}-{}", prefix, wn.name);
+        if collisions.qualified_contains(wn) && !wn._version.is_empty() {
+            qualified.push_str("-v");
+            qualified.push_str(&version_to_kebab(&wn._version));
+        }
+        (kebab_to_type(&qualified), kebab_to_getter(&qualified))
+    } else {
+        (kebab_to_type(wn.name), kebab_to_getter(wn.name))
+    }
+}
 
 /// A representation of a trait definition that we will eventually
 /// emit. This is used to allow easily adding onto the trait each time
@@ -284,6 +381,11 @@ pub struct State<'a, 'b> {
     pub is_wasmtime_guest: bool,
     /// Are we working on an export or an import of the component type?
     pub is_export: bool,
+    /// Set of interface names that collide across different packages
+    /// (e.g. "types" appears in both wasi:filesystem/types and wasi:http/types).
+    /// When a name is in this set, the parent namespace is prepended to
+    /// disambiguate the trait member name.
+    pub colliding_import_names: ImportNameCollisions,
 }
 
 /// Create a State with all of its &mut references pointing to
@@ -336,6 +438,7 @@ impl<'a, 'b> State<'a, 'b> {
             is_guest,
             is_wasmtime_guest,
             is_export: false,
+            colliding_import_names: ImportNameCollisions::default(),
         }
     }
     pub fn clone<'c>(&'c mut self) -> State<'c, 'b> {
@@ -357,6 +460,7 @@ impl<'a, 'b> State<'a, 'b> {
             is_guest: self.is_guest,
             is_wasmtime_guest: self.is_wasmtime_guest,
             is_export: self.is_export,
+            colliding_import_names: self.colliding_import_names.clone(),
         }
     }
     /// Obtain a reference to the [`Mod`] that we are currently
@@ -437,10 +541,12 @@ impl<'a, 'b> State<'a, 'b> {
     /// variable, given its absolute index (i.e. ignoring
     /// [`State::var_offset`])
     pub fn noff_var_id(&self, n: u32) -> Ident {
-        let Some(n) = self.bound_vars[n as usize].origin.last_name() else {
+        let Some(name) = self.bound_vars[n as usize].origin.last_name() else {
             panic!("missing origin on tyvar in rust emit")
         };
-        kebab_to_type(n)
+        let wn = split_wit_name(name);
+        let (tn, _) = import_member_names(&wn, &self.colliding_import_names);
+        tn
     }
     /// Copy the state, changing it to emit into the helper module of
     /// the current trait
@@ -803,3 +909,221 @@ pub fn kebab_to_fn(n: &str) -> FnName {
     }
     FnName::Plain(kebab_to_snake(n))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::etypes::{ExternDecl, ExternDesc, Instance};
+
+    /// Helper to build a minimal `ExternDecl` whose desc is an Instance.
+    fn instance_decl(kebab_name: &str) -> ExternDecl<'_> {
+        ExternDecl {
+            kebab_name,
+            desc: ExternDesc::Instance(Instance {
+                exports: Vec::new(),
+            }),
+        }
+    }
+
+    /// Helper to build a minimal `ExternDecl` whose desc is a Func (not an Instance).
+    fn func_decl(kebab_name: &str) -> ExternDecl<'_> {
+        ExternDecl {
+            kebab_name,
+            desc: ExternDesc::Func(crate::etypes::Func {
+                params: Vec::new(),
+                result: None,
+            }),
+        }
+    }
+
+    // --- split_wit_name tests ---
+
+    #[test]
+    fn split_wit_name_simple() {
+        let wn = split_wit_name("my-interface");
+        assert_eq!(wn.name, "my-interface");
+        assert!(wn.namespaces.is_empty());
+    }
+
+    #[test]
+    fn split_wit_name_with_package() {
+        let wn = split_wit_name("wasi:http/types");
+        assert_eq!(wn.name, "types");
+        assert_eq!(wn.namespaces, vec!["wasi", "http"]);
+    }
+
+    #[test]
+    fn split_wit_name_with_version() {
+        let wn = split_wit_name("wasi:http/types@0.2.0");
+        assert_eq!(wn.name, "types");
+        assert_eq!(wn.namespaces, vec!["wasi", "http"]);
+    }
+
+    #[test]
+    fn split_wit_name_nested_package() {
+        let wn = split_wit_name("wasi:filesystem/types");
+        assert_eq!(wn.name, "types");
+        assert_eq!(wn.namespaces, vec!["wasi", "filesystem"]);
+    }
+
+    // --- find_colliding_import_names tests ---
+
+    #[test]
+    fn no_collisions_with_distinct_names() {
+        let imports = vec![
+            instance_decl("wasi:http/types"),
+            instance_decl("wasi:filesystem/preopens"),
+        ];
+        let collisions = find_colliding_import_names(&imports);
+        assert!(collisions.is_empty());
+    }
+
+    #[test]
+    fn detects_collision_on_same_short_name() {
+        let imports = vec![
+            instance_decl("wasi:http/types"),
+            instance_decl("wasi:filesystem/types"),
+        ];
+        let collisions = find_colliding_import_names(&imports);
+        assert_eq!(collisions.len(), 1);
+        assert!(collisions.contains("types"));
+    }
+
+    #[test]
+    fn no_collision_for_non_instance_decls() {
+        let imports = vec![instance_decl("wasi:http/types"), func_decl("types")];
+        let collisions = find_colliding_import_names(&imports);
+        assert!(collisions.is_empty());
+    }
+
+    #[test]
+    fn multiple_collisions() {
+        let imports = vec![
+            instance_decl("a:foo/types"),
+            instance_decl("b:bar/types"),
+            instance_decl("a:foo/handler"),
+            instance_decl("c:baz/handler"),
+        ];
+        let collisions = find_colliding_import_names(&imports);
+        assert_eq!(collisions.len(), 2);
+        assert!(collisions.contains("types"));
+        assert!(collisions.contains("handler"));
+    }
+
+    #[test]
+    fn single_import_no_collision() {
+        let imports = vec![instance_decl("wasi:http/types")];
+        let collisions = find_colliding_import_names(&imports);
+        assert!(collisions.is_empty());
+    }
+
+    #[test]
+    fn empty_imports_no_collision() {
+        let collisions = find_colliding_import_names(&[]);
+        assert!(collisions.is_empty());
+    }
+
+    // --- import_member_names tests ---
+
+    #[test]
+    fn no_collision_uses_short_name() {
+        let wn = split_wit_name("wasi:http/types");
+        let collisions = ImportNameCollisions::default();
+        let (ty, getter) = import_member_names(&wn, &collisions);
+        assert_eq!(ty.to_string(), "Types");
+        assert_eq!(getter.to_string(), "r#types");
+    }
+
+    #[test]
+    fn collision_prepends_parent_namespace() {
+        let wn = split_wit_name("wasi:http/types");
+        let collisions = find_colliding_import_names(&[
+            instance_decl("wasi:http/types"),
+            instance_decl("wasi:filesystem/types"),
+        ]);
+        let (ty, getter) = import_member_names(&wn, &collisions);
+        assert_eq!(ty.to_string(), "WasiHttpTypes");
+        assert_eq!(getter.to_string(), "r#wasi_http_types");
+    }
+
+    #[test]
+    fn collision_different_parents_produce_different_names() {
+        let collisions = find_colliding_import_names(&[
+            instance_decl("wasi:http/types"),
+            instance_decl("wasi:filesystem/types"),
+        ]);
+
+        let wn_http = split_wit_name("wasi:http/types");
+        let (ty_http, getter_http) = import_member_names(&wn_http, &collisions);
+
+        let wn_fs = split_wit_name("wasi:filesystem/types");
+        let (ty_fs, getter_fs) = import_member_names(&wn_fs, &collisions);
+
+        assert_eq!(ty_http.to_string(), "WasiHttpTypes");
+        assert_eq!(ty_fs.to_string(), "WasiFilesystemTypes");
+        assert_ne!(ty_http.to_string(), ty_fs.to_string());
+        assert_ne!(getter_http.to_string(), getter_fs.to_string());
+    }
+
+    #[test]
+    fn collision_same_parent_different_package_produces_different_names() {
+        let collisions = find_colliding_import_names(&[
+            instance_decl("a:pkg/types"),
+            instance_decl("b:pkg/types"),
+        ]);
+
+        let wn_a = split_wit_name("a:pkg/types");
+        let (ty_a, _) = import_member_names(&wn_a, &collisions);
+
+        let wn_b = split_wit_name("b:pkg/types");
+        let (ty_b, _) = import_member_names(&wn_b, &collisions);
+
+        assert_eq!(ty_a.to_string(), "APkgTypes");
+        assert_eq!(ty_b.to_string(), "BPkgTypes");
+        assert_ne!(ty_a.to_string(), ty_b.to_string());
+    }
+
+    #[test]
+    fn collision_simple_name_uses_name_as_parent() {
+        let wn = split_wit_name("types");
+        let collisions =
+            find_colliding_import_names(&[instance_decl("types"), instance_decl("pkg:types")]);
+        let (ty, getter) = import_member_names(&wn, &collisions);
+        // When there are no namespaces, the name itself is used as prefix
+        assert_eq!(ty.to_string(), "TypesTypes");
+        assert_eq!(getter.to_string(), "r#types_types");
+    }
+
+    #[test]
+    fn versioned_collision_adds_version_after_namespace() {
+        let collisions = find_colliding_import_names(&[
+            instance_decl("a:pkg/types@1.0.0"),
+            instance_decl("a:pkg/types@2.0.0"),
+        ]);
+
+        let wn_v1 = split_wit_name("a:pkg/types@1.0.0");
+        let (ty_v1, getter_v1) = import_member_names(&wn_v1, &collisions);
+
+        let wn_v2 = split_wit_name("a:pkg/types@2.0.0");
+        let (ty_v2, getter_v2) = import_member_names(&wn_v2, &collisions);
+
+        assert_eq!(ty_v1.to_string(), "APkgTypesV100");
+        assert_eq!(ty_v2.to_string(), "APkgTypesV200");
+        assert_eq!(getter_v1.to_string(), "r#a_pkg_types_v1_0_0");
+        assert_eq!(getter_v2.to_string(), "r#a_pkg_types_v2_0_0");
+    }
+
+    #[test]
+    fn version_is_not_added_when_namespace_disambiguates() {
+        let collisions = find_colliding_import_names(&[
+            instance_decl("a:pkg/types@1.0.0"),
+            instance_decl("b:pkg/types@1.0.0"),
+        ]);
+
+        let wn = split_wit_name("a:pkg/types@1.0.0");
+        let (ty, getter) = import_member_names(&wn, &collisions);
+
+        assert_eq!(ty.to_string(), "APkgTypes");
+        assert_eq!(getter.to_string(), "r#a_pkg_types");
+    }
+}