fix: preserve hyphens in qualified import names

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

Author: jsturtevant

src/hyperlight_component_util/src/emit.rs

@@ -64,36 +64,36 @@ pub fn find_colliding_import_names(imports: &[ExternDecl]) -> HashSet<String> {
 /// `wasi:http/types` -> `WasiHttpTypes` / `wasi_http_types`.
 pub fn import_member_names(wn: &WitName, collisions: &HashSet<String>) -> (Ident, Ident) {
     if collisions.contains(wn.name) {
-        // Preserve namespace component boundaries so `a:b-c/types` and
-        // `a-b:c/types` do not both flatten to `a_b_c_types`.
+        // Preserve namespace component and hyphen boundaries so `a:bc/types`
+        // and `a:b-c/types` do not both flatten to `a_bc_types`.
         let getter_prefix = if wn.namespaces.is_empty() {
             wn.name.to_string()
         } else {
             wn.namespaces
                 .iter()
-                .map(|ns| ns.replace('-', ""))
+                .map(|ns| namespace_component_to_getter_part(ns))
                 .collect::<Vec<_>>()
                 .join("_")
         };
         let mut qualified_getter = format!("{}-{}", getter_prefix, wn.name);
 
         // Use the same boundary-preserving approach for type names.
         let type_prefix: String = if wn.namespaces.is_empty() {
-            component_first_camel(wn.name)
+            collapsed_kebab_to_camel(wn.name)
         } else {
             wn.namespaces
                 .iter()
-                .map(|ns| component_first_camel(ns))
+                .map(|ns| namespace_component_to_type_part(ns))
                 .collect()
         };
-        let mut type_name = format!("{}{}", type_prefix, component_first_camel(wn.name));
+        let mut type_name = format!("{}{}", type_prefix, collapsed_kebab_to_camel(wn.name));
 
         if !wn._version.is_empty() {
             let v = version_to_kebab(&wn._version);
             qualified_getter.push_str("-v");
             qualified_getter.push_str(&v);
             type_name.push('V');
-            type_name.push_str(&component_first_camel(&v));
+            type_name.push_str(&collapsed_kebab_to_camel(&v));
         }
         (
             format_ident!("{}", type_name),
@@ -104,12 +104,28 @@ pub fn import_member_names(wn: &WitName, collisions: &HashSet<String>) -> (Ident
     }
 }
 
-/// Capitalize only the first letter of a kebab component, removing hyphens
-/// without capitalizing subsequent sub-words. This preserves namespace-boundary
-/// information when concatenating multiple components into a type identifier:
-/// "b-c" → "Bc" and "a-b" → "Ab" remain distinguishable when prefixed,
-/// whereas full camel-casing gives "BC" and "AB" which collapse on concatenation.
-fn component_first_camel(s: &str) -> String {
+fn namespace_component_to_getter_part(s: &str) -> String {
+    s.replace('-', "_dash_")
+}
+
+fn namespace_component_to_type_part(s: &str) -> String {
+    let mut result = String::new();
+    let mut capitalize_next = true;
+    for c in s.chars() {
+        if c == '-' {
+            result.push_str("Dash");
+            capitalize_next = true;
+        } else if capitalize_next {
+            result.extend(c.to_uppercase());
+            capitalize_next = false;
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
+fn collapsed_kebab_to_camel(s: &str) -> String {
     let mut result = String::new();
     let mut chars = s.chars();
     if let Some(first) = chars.next() {
@@ -1139,9 +1155,27 @@ mod tests {
         let (ty1, getter1) = import_member_names(&wn1, &collisions);
         let (ty2, getter2) = import_member_names(&wn2, &collisions);
 
-        assert_eq!(ty1.to_string(), "ABcTypes");
-        assert_eq!(getter1.to_string(), "r#a_bc_types");
-        assert_eq!(ty2.to_string(), "AbCTypes");
-        assert_eq!(getter2.to_string(), "r#ab_c_types");
+        assert_eq!(ty1.to_string(), "ABDashCTypes");
+        assert_eq!(getter1.to_string(), "r#a_b_dash_c_types");
+        assert_eq!(ty2.to_string(), "ADashBCTypes");
+        assert_eq!(getter2.to_string(), "r#a_dash_b_c_types");
+    }
+
+    #[test]
+    fn plain_and_hyphenated_namespace_components_produce_distinct_type_names() {
+        let collisions = find_colliding_import_names(&[
+            instance_decl("a:bc/types"),
+            instance_decl("a:b-c/types"),
+        ]);
+
+        let wn_plain = split_wit_name("a:bc/types");
+        let wn_hyphenated = split_wit_name("a:b-c/types");
+        let (ty_plain, getter_plain) = import_member_names(&wn_plain, &collisions);
+        let (ty_hyphenated, getter_hyphenated) = import_member_names(&wn_hyphenated, &collisions);
+
+        assert_eq!(ty_plain.to_string(), "ABcTypes");
+        assert_eq!(getter_plain.to_string(), "r#a_bc_types");
+        assert_eq!(ty_hyphenated.to_string(), "ABDashCTypes");
+        assert_eq!(getter_hyphenated.to_string(), "r#a_b_dash_c_types");
     }
 }