fix: handle versioned import name collisions

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

Author: jsturtevant

src/hyperlight_component_util/src/emit.rs

@@ -15,7 +15,7 @@ limitations under the License.
  */
 
 //! A bunch of utilities used by the actual code emit functions
-use std::collections::{BTreeMap, BTreeSet, HashSet, VecDeque};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 use std::vec::Vec;
 
 use proc_macro2::TokenStream;
@@ -26,35 +26,95 @@ 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 the set of interface names that appear more than once.
-pub fn find_colliding_import_names(imports: &[ExternDecl]) -> HashSet<String> {
-    let mut counts = std::collections::HashMap::<String, usize>::new();
+/// 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);
-            *counts.entry(wn.name.to_string()).or_default() += 1;
+            *short_counts.entry(wn.name.to_string()).or_default() += 1;
+            *qualified_counts
+                .entry(qualified_import_key(&wn))
+                .or_default() += 1;
         }
     }
-    counts
+    let short_names = short_counts
         .into_iter()
         .filter(|(_, c)| *c > 1)
         .map(|(n, _)| n)
-        .collect()
+        .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: &HashSet<String>) -> (Ident, Ident) {
+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 qualified = format!("{}-{}", prefix, wn.name);
+        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))
@@ -325,7 +385,7 @@ pub struct State<'a, 'b> {
     /// (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: HashSet<String>,
+    pub colliding_import_names: ImportNameCollisions,
 }
 
 /// Create a State with all of its &mut references pointing to
@@ -378,7 +438,7 @@ impl<'a, 'b> State<'a, 'b> {
             is_guest,
             is_wasmtime_guest,
             is_export: false,
-            colliding_import_names: HashSet::new(),
+            colliding_import_names: ImportNameCollisions::default(),
         }
     }
     pub fn clone<'c>(&'c mut self) -> State<'c, 'b> {
@@ -968,7 +1028,7 @@ mod tests {
     #[test]
     fn no_collision_uses_short_name() {
         let wn = split_wit_name("wasi:http/types");
-        let collisions = HashSet::new();
+        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");
@@ -977,17 +1037,21 @@ mod tests {
     #[test]
     fn collision_prepends_parent_namespace() {
         let wn = split_wit_name("wasi:http/types");
-        let mut collisions = HashSet::new();
-        collisions.insert("types".to_string());
+        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 mut collisions = HashSet::new();
-        collisions.insert("types".to_string());
+        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);
@@ -1003,8 +1067,10 @@ mod tests {
 
     #[test]
     fn collision_same_parent_different_package_produces_different_names() {
-        let mut collisions = HashSet::new();
-        collisions.insert("types".to_string());
+        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);
@@ -1020,11 +1086,44 @@ mod tests {
     #[test]
     fn collision_simple_name_uses_name_as_parent() {
         let wn = split_wit_name("types");
-        let mut collisions = HashSet::new();
-        collisions.insert("types".to_string());
+        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");
+    }
 }