Add map tests for nested maps, multi-param, variant, and result types

Exercise additional ABI code paths: nested map<K, map<K2, V>> with
recursive lower/lift blocks, multiple map parameters with independent
ptr/len pairs, map as a variant arm payload, map inside result<ok, err>,
and tuple-with-map in codegen.

Author: yordis

tests/codegen/map.wit

@@ -16,6 +16,11 @@ interface map-types {
     y: string,
   }
 
+  variant map-or-string {
+    as-map(names-by-id),
+    as-string(string),
+  }
+
   named-roundtrip: func(a: names-by-id) -> ids-by-name;
   inline-roundtrip: func(a: map<u32, string>, b: map<string, list<u8>>) -> tuple<map<string, u32>, map<string, list<u8>>>;
   nested-roundtrip: func(a: bytes-by-name) -> bytes-by-name;
@@ -25,6 +30,9 @@ interface map-types {
   record-value-roundtrip: func(a: map<string, map-value-record>) -> map<string, map-value-record>;
   bool-key-roundtrip: func(a: map<bool, string>) -> map<bool, string>;
   char-key-roundtrip: func(a: map<char, u32>) -> map<char, u32>;
+  variant-roundtrip: func(a: map-or-string) -> map-or-string;
+  result-roundtrip: func(a: result<names-by-id, string>) -> result<names-by-id, string>;
+  tuple-with-map: func(a: tuple<names-by-id, u64>) -> tuple<names-by-id, u64>;
 }
 
 world map-world {

tests/runtime/map/runner.rs

@@ -17,6 +17,10 @@ impl Guest for Component {
         test_record_roundtrip();
         test_inline_roundtrip();
         test_large_map();
+        test_multi_param_roundtrip();
+        test_nested_roundtrip();
+        test_variant_roundtrip();
+        test_result_roundtrip();
     }
 }
 
@@ -95,6 +99,78 @@ fn test_large_map() {
     let result = large_roundtrip(&input);
     assert_eq!(result.len(), 100);
     for i in 0..100 {
-        assert_eq!(result.get(&i).map(String::as_str), Some(format!("value-{i}").as_str()));
+        assert_eq!(
+            result.get(&i).map(String::as_str),
+            Some(format!("value-{i}").as_str()),
+        );
+    }
+}
+
+fn test_multi_param_roundtrip() {
+    let mut names = NamesById::new();
+    names.insert(1, "one".to_string());
+    names.insert(2, "two".to_string());
+    let mut bytes = BytesByName::new();
+    bytes.insert("key".to_string(), vec![42u8]);
+    let (ids, bytes_out) = multi_param_roundtrip(&names, &bytes);
+    assert_eq!(ids.len(), 2);
+    assert_eq!(ids.get("one"), Some(&1));
+    assert_eq!(ids.get("two"), Some(&2));
+    assert_eq!(bytes_out.len(), 1);
+    assert_eq!(
+        bytes_out.get("key").map(Vec::as_slice),
+        Some([42u8].as_slice()),
+    );
+}
+
+fn test_nested_roundtrip() {
+    let mut inner_a = wit_bindgen::rt::Map::new();
+    inner_a.insert(1, "one".to_string());
+    inner_a.insert(2, "two".to_string());
+    let mut inner_b = wit_bindgen::rt::Map::new();
+    inner_b.insert(10, "ten".to_string());
+    let mut outer = wit_bindgen::rt::Map::new();
+    outer.insert("group-a".to_string(), inner_a);
+    outer.insert("group-b".to_string(), inner_b);
+    let result = nested_roundtrip(&outer);
+    assert_eq!(result.len(), 2);
+    let ra = result.get("group-a").unwrap();
+    assert_eq!(ra.get(&1).map(String::as_str), Some("one"));
+    assert_eq!(ra.get(&2).map(String::as_str), Some("two"));
+    let rb = result.get("group-b").unwrap();
+    assert_eq!(rb.get(&10).map(String::as_str), Some("ten"));
+}
+
+fn test_variant_roundtrip() {
+    let mut map = NamesById::new();
+    map.insert(1, "one".to_string());
+    let as_map = variant_roundtrip(&MapOrString::AsMap(map));
+    match &as_map {
+        MapOrString::AsMap(m) => {
+            assert_eq!(m.get(&1).map(String::as_str), Some("one"));
+        }
+        MapOrString::AsString(_) => panic!("expected AsMap"),
+    }
+
+    let as_str = variant_roundtrip(&MapOrString::AsString("hello".to_string()));
+    match &as_str {
+        MapOrString::AsString(s) => assert_eq!(s, "hello"),
+        MapOrString::AsMap(_) => panic!("expected AsString"),
+    }
+}
+
+fn test_result_roundtrip() {
+    let mut map = NamesById::new();
+    map.insert(5, "five".to_string());
+    let ok_result = result_roundtrip(Ok(&map));
+    match &ok_result {
+        Ok(m) => assert_eq!(m.get(&5).map(String::as_str), Some("five")),
+        Err(_) => panic!("expected Ok"),
+    }
+
+    let err_result = result_roundtrip(Err("bad input"));
+    match &err_result {
+        Err(e) => assert_eq!(e, "bad input"),
+        Ok(_) => panic!("expected Err"),
     }
 }

tests/runtime/map/test.rs

@@ -1,6 +1,8 @@
 include!(env!("BINDINGS"));
 
-use crate::exports::test::maps::to_test::{BytesByName, IdsByName, LabeledEntry, NamesById};
+use crate::exports::test::maps::to_test::{
+    BytesByName, IdsByName, LabeledEntry, MapOrString, NamesById,
+};
 
 struct Component;
 
@@ -64,4 +66,34 @@ impl exports::test::maps::to_test::Guest for Component {
     fn large_roundtrip(a: NamesById) -> NamesById {
         a
     }
+
+    fn multi_param_roundtrip(a: NamesById, b: BytesByName) -> (IdsByName, BytesByName) {
+        assert_eq!(a.len(), 2);
+        assert_eq!(b.len(), 1);
+        let mut ids = IdsByName::new();
+        for (id, name) in a {
+            ids.insert(name, id);
+        }
+        (ids, b)
+    }
+
+    fn nested_roundtrip(
+        a: wit_bindgen::rt::Map<String, wit_bindgen::rt::Map<u32, String>>,
+    ) -> wit_bindgen::rt::Map<String, wit_bindgen::rt::Map<u32, String>> {
+        assert_eq!(a.len(), 2);
+        let inner = a.get("group-a").unwrap();
+        assert_eq!(inner.get(&1).map(String::as_str), Some("one"));
+        assert_eq!(inner.get(&2).map(String::as_str), Some("two"));
+        let inner2 = a.get("group-b").unwrap();
+        assert_eq!(inner2.get(&10).map(String::as_str), Some("ten"));
+        a
+    }
+
+    fn variant_roundtrip(a: MapOrString) -> MapOrString {
+        a
+    }
+
+    fn result_roundtrip(a: Result<NamesById, String>) -> Result<NamesById, String> {
+        a
+    }
 }

tests/runtime/map/test.wit

@@ -10,13 +10,22 @@ interface to-test {
     values: names-by-id,
   }
 
+  variant map-or-string {
+    as-map(names-by-id),
+    as-string(string),
+  }
+
   named-roundtrip: func(a: names-by-id) -> ids-by-name;
   bytes-roundtrip: func(a: bytes-by-name) -> bytes-by-name;
   empty-roundtrip: func(a: names-by-id) -> names-by-id;
   option-roundtrip: func(a: map<string, option<u32>>) -> map<string, option<u32>>;
   record-roundtrip: func(a: labeled-entry) -> labeled-entry;
   inline-roundtrip: func(a: map<u32, string>) -> map<string, u32>;
   large-roundtrip: func(a: names-by-id) -> names-by-id;
+  multi-param-roundtrip: func(a: names-by-id, b: bytes-by-name) -> tuple<ids-by-name, bytes-by-name>;
+  nested-roundtrip: func(a: map<string, map<u32, string>>) -> map<string, map<u32, string>>;
+  variant-roundtrip: func(a: map-or-string) -> map-or-string;
+  result-roundtrip: func(a: result<names-by-id, string>) -> result<names-by-id, string>;
 }
 
 world test {