Add tests for WitMap trait and map_type codegen option

- Unit tests for WitMap trait impls (BTreeMap, HashMap, reference blanket)
- Proc-macro integration tests exercising map_type with HashMap and default
- Codegen test variant running all .wit files with --map-type=HashMap

Author: yordis

crates/guest-rust/src/rt/mod.rs

@@ -74,16 +74,21 @@ pub type Map<K, V> = alloc::collections::BTreeMap<K, V>;
 /// Generated code delegates to these methods rather than calling inherent
 /// methods on a concrete type, so users can swap in their own map
 /// implementation via the `map_type` bindgen option.
-///
-/// The concrete map type must also implement `IntoIterator` (both owned
-/// and by-ref) yielding key/value pairs.
-pub trait WitMap<K, V> {
+pub trait WitMap<K, V>: Sized {
+    type Iter: Iterator;
+
     fn wit_map_new(capacity: usize) -> Self;
     fn wit_map_push(&mut self, key: K, value: V);
     fn wit_map_len(&self) -> usize;
+    fn wit_map_into_iter(self) -> Self::Iter;
 }
 
-impl<'a, K, V, T: WitMap<K, V>> WitMap<K, V> for &'a T {
+impl<'a, K, V, T: WitMap<K, V>> WitMap<K, V> for &'a T
+where
+    &'a T: IntoIterator,
+{
+    type Iter = <&'a T as IntoIterator>::IntoIter;
+
     fn wit_map_new(_capacity: usize) -> Self {
         unreachable!()
     }
@@ -93,9 +98,14 @@ impl<'a, K, V, T: WitMap<K, V>> WitMap<K, V> for &'a T {
     fn wit_map_len(&self) -> usize {
         T::wit_map_len(self)
     }
+    fn wit_map_into_iter(self) -> Self::Iter {
+        self.into_iter()
+    }
 }
 
 impl<K: Ord, V> WitMap<K, V> for alloc::collections::BTreeMap<K, V> {
+    type Iter = alloc::collections::btree_map::IntoIter<K, V>;
+
     fn wit_map_new(_capacity: usize) -> Self {
         alloc::collections::BTreeMap::new()
     }
@@ -105,10 +115,15 @@ impl<K: Ord, V> WitMap<K, V> for alloc::collections::BTreeMap<K, V> {
     fn wit_map_len(&self) -> usize {
         self.len()
     }
+    fn wit_map_into_iter(self) -> Self::Iter {
+        self.into_iter()
+    }
 }
 
 #[cfg(feature = "std")]
 impl<K: core::hash::Hash + Eq, V> WitMap<K, V> for std::collections::HashMap<K, V> {
+    type Iter = std::collections::hash_map::IntoIter<K, V>;
+
     fn wit_map_new(capacity: usize) -> Self {
         std::collections::HashMap::with_capacity(capacity)
     }
@@ -118,6 +133,9 @@ impl<K: core::hash::Hash + Eq, V> WitMap<K, V> for std::collections::HashMap<K,
     fn wit_map_len(&self) -> usize {
         self.len()
     }
+    fn wit_map_into_iter(self) -> Self::Iter {
+        self.into_iter()
+    }
 }
 
 /// For more information about this see `./ci/rebuild-libwit-bindgen-cabi.sh`.
@@ -283,3 +301,81 @@ impl Drop for Cleanup {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::collections::BTreeMap;
+    use alloc::string::ToString;
+
+    #[test]
+    fn btreemap_new_push_len() {
+        let mut m: BTreeMap<u32, alloc::string::String> = WitMap::wit_map_new(10);
+        assert_eq!(WitMap::<u32, alloc::string::String>::wit_map_len(&m), 0);
+
+        WitMap::wit_map_push(&mut m, 1, "one".to_string());
+        WitMap::wit_map_push(&mut m, 2, "two".to_string());
+        assert_eq!(WitMap::<u32, alloc::string::String>::wit_map_len(&m), 2);
+    }
+
+    #[test]
+    fn btreemap_into_iter() {
+        let mut m: BTreeMap<u32, u32> = WitMap::wit_map_new(0);
+        WitMap::wit_map_push(&mut m, 10, 100);
+        WitMap::wit_map_push(&mut m, 20, 200);
+
+        let entries: alloc::vec::Vec<_> = WitMap::wit_map_into_iter(m).collect();
+        assert_eq!(entries, alloc::vec![(10, 100), (20, 200)]);
+    }
+
+    #[test]
+    fn btreemap_duplicate_key_overwrites() {
+        let mut m: BTreeMap<u32, u32> = WitMap::wit_map_new(0);
+        WitMap::wit_map_push(&mut m, 1, 10);
+        WitMap::wit_map_push(&mut m, 1, 20);
+        assert_eq!(WitMap::<u32, u32>::wit_map_len(&m), 1);
+    }
+
+    #[test]
+    fn ref_blanket_impl_len() {
+        let mut m: BTreeMap<u32, u32> = WitMap::wit_map_new(0);
+        WitMap::wit_map_push(&mut m, 1, 10);
+
+        let r = &m;
+        assert_eq!(WitMap::<u32, u32>::wit_map_len(&r), 1);
+    }
+
+    #[test]
+    fn ref_blanket_impl_into_iter() {
+        let mut m: BTreeMap<u32, u32> = WitMap::wit_map_new(0);
+        WitMap::wit_map_push(&mut m, 5, 50);
+
+        let r = &m;
+        let entries: alloc::vec::Vec<_> = WitMap::wit_map_into_iter(r).collect();
+        assert_eq!(entries, alloc::vec![(&5, &50)]);
+    }
+
+    #[cfg(feature = "std")]
+    mod hashmap_tests {
+        use super::*;
+        use std::collections::HashMap;
+
+        #[test]
+        fn hashmap_new_push_len() {
+            let mut m: HashMap<u32, u32> = WitMap::wit_map_new(5);
+            WitMap::wit_map_push(&mut m, 1, 10);
+            WitMap::wit_map_push(&mut m, 2, 20);
+            assert_eq!(WitMap::<u32, u32>::wit_map_len(&m), 2);
+        }
+
+        #[test]
+        fn hashmap_into_iter() {
+            let mut m: HashMap<u32, u32> = WitMap::wit_map_new(0);
+            WitMap::wit_map_push(&mut m, 1, 10);
+
+            let entries: alloc::vec::Vec<_> = WitMap::wit_map_into_iter(m).collect();
+            assert_eq!(entries.len(), 1);
+            assert_eq!(entries[0], (1, 10));
+        }
+    }
+}

crates/rust/src/bindgen.rs

@@ -800,9 +800,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                         "if let Some(cleanup) = {cleanup} {{ cleanup.forget(); }}"
                     );
                 }
-                self.push_str(&format!(
-                    "for (i, (map_key, map_value)) in {map}.into_iter().enumerate() {{\n"
-                ));
+                uwriteln!(
+                    self.src,
+                    "for (i, (map_key, map_value)) in {wit_map}::wit_map_into_iter({map}).enumerate() {{"
+                );
                 self.push_str(&format!(
                     "let base = {result}.add(i * {});\n",
                     entry.size.format(POINTER_SIZE_EXPRESSION)

crates/rust/tests/codegen.rs

@@ -143,6 +143,49 @@ mod newtyped_list {
     }
 }
 
+#[allow(unused, reason = "testing codegen, not functionality")]
+mod map_type_hashmap {
+    wit_bindgen::generate!({
+        inline: r#"
+        package test:map-type;
+
+        interface maps {
+            type names-by-id = map<u32, string>;
+
+            roundtrip: func(a: names-by-id) -> names-by-id;
+            inline-roundtrip: func(a: map<string, u32>) -> map<string, u32>;
+        }
+
+        world test {
+            import maps;
+            export maps;
+        }
+        "#,
+        map_type: "std::collections::HashMap",
+        generate_all,
+    });
+}
+
+#[allow(unused, reason = "testing codegen, not functionality")]
+mod map_type_default {
+    wit_bindgen::generate!({
+        inline: r#"
+        package test:map-default;
+
+        interface maps {
+            type names-by-id = map<u32, string>;
+            nested: func(a: map<string, map<u32, string>>) -> map<string, map<u32, string>>;
+        }
+
+        world test {
+            import maps;
+            export maps;
+        }
+        "#,
+        generate_all,
+    });
+}
+
 #[allow(unused, reason = "testing codegen, not functionality")]
 mod retyped_list {
     use std::ops::Deref;

crates/test/src/rust.rs

@@ -94,6 +94,10 @@ impl LanguageMethods for Rust {
             ("async", &["--async=all"]),
             ("no-std", &["--std-feature"]),
             ("merge-equal", &["--merge-structurally-equal-types"]),
+            (
+                "hashmap",
+                &["--map-type=std::collections::HashMap"],
+            ),
         ]
     }