refactor(cpp): use wit::map instead of std::map for map types

std::map requires per-entry rb-tree allocation during lift; wit::map
mirrors the canonical ABI layout (flat pair array) so lift is a single
allocation, matching the existing wit::vector / wit::string pattern.

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

crates/cpp/helper-types/wit.h

@@ -13,6 +13,7 @@
 #include <stdlib.h> // free
 #include <new>
 #include <span>
+#include <utility> // pair
 
 namespace wit {
 /// @brief Helper class to map between IDs and resources
@@ -107,12 +108,6 @@ class string {
   char const* end() const {
     return (char const*)data_ + length;
   }
-  friend bool operator<(string const &a, string const &b) {
-    return a.get_view() < b.get_view();
-  }
-  friend bool operator==(string const &a, string const &b) {
-    return a.get_view() == b.get_view();
-  }
 };
 
 /// A vector in linear memory, freed unconditionally using free
@@ -176,6 +171,70 @@ template <class T> class vector {
   } 
 };
 
+/// @brief A map stored as a contiguous array of key-value pairs in linear
+/// memory, freed unconditionally using free.
+///
+/// Mirrors the canonical ABI representation of `map<K, V>` (`list<tuple<K, V>>`)
+/// to enable lift without per-entry tree allocation. Unlike `std::map` this
+/// container provides flat iteration only — callers who need keyed lookup can
+/// build their own index from `get_view()`.
+template <class K, class V> class map {
+public:
+  using entry_type = std::pair<K, V>;
+
+private:
+  entry_type *data_;
+  size_t length;
+
+  static entry_type* empty_ptr() { return (entry_type*)alignof(entry_type); }
+
+public:
+  map(map const &) = delete;
+  map(map &&b) : data_(b.data_), length(b.length) { b.data_ = nullptr; }
+  map &operator=(map const &) = delete;
+  map &operator=(map &&b) {
+    if (data_ && length > 0) {
+      for (unsigned i = 0; i < length; ++i) { data_[i].~entry_type(); }
+      free(data_);
+    }
+    data_ = b.data_;
+    length = b.length;
+    b.data_ = nullptr;
+    return *this;
+  }
+  map(entry_type *d, size_t l) : data_(d), length(l) {}
+  map() : data_(empty_ptr()), length() {}
+  entry_type const *data() const { return data_; }
+  entry_type *data() { return data_; }
+  entry_type &operator[](size_t n) { return data_[n]; }
+  entry_type const &operator[](size_t n) const { return data_[n]; }
+  size_t size() const { return length; }
+  bool empty() const { return !length; }
+  ~map() {
+    if (data_ && length > 0) {
+      for (unsigned i = 0; i < length; ++i) { data_[i].~entry_type(); }
+      free((void*)data_);
+    }
+  }
+  // WARNING: map contains uninitialized entries; caller must construct them via
+  // `initialize` before the map is observed or destroyed.
+  static map<K, V> allocate(size_t len) {
+    if (!len) return map<K, V>(empty_ptr(), 0);
+    return map<K, V>((entry_type*)malloc(sizeof(entry_type) * len), len);
+  }
+  void initialize(size_t n, entry_type&& entry) {
+    new ((void*)(data_ + n)) entry_type(std::move(entry));
+  }
+  entry_type* leak() { entry_type* result = data_; data_ = nullptr; return result; }
+  static void drop_raw(void *ptr) { if (ptr != empty_ptr()) free(ptr); }
+  std::span<entry_type> get_view() const { return std::span<entry_type>(data_, length); }
+  std::span<entry_type const> get_const_view() const { return std::span<entry_type const>(data_, length); }
+  entry_type* begin() { return data_; }
+  entry_type* end() { return data_ + length; }
+  entry_type const* begin() const { return data_; }
+  entry_type const* end() const { return data_ + length; }
+};
+
 /// @brief  A Resource defined within the guest (guest side)
 ///
 /// It registers with the host and should remain in a static location.

crates/cpp/src/lib.rs

@@ -75,7 +75,6 @@ struct Includes {
     needs_wit: bool,
     needs_memory: bool,
     needs_array: bool,
-    needs_map: bool,
 }
 
 #[derive(Default)]
@@ -436,9 +435,6 @@ impl Cpp {
         if self.dependencies.needs_bit {
             self.include("<bit>");
         }
-        if self.dependencies.needs_map {
-            self.include("<map>");
-        }
     }
 
     fn start_new_file(&mut self, condition: Option<bool>) -> FileContext {
@@ -1746,10 +1742,31 @@ impl CppInterfaceGenerator<'_> {
                     )
                 }
                 TypeDefKind::Map(key, value) => {
-                    self.r#gen.dependencies.needs_map = true;
-                    let k = self.type_name(key, from_namespace, flavor);
-                    let v = self.type_name(value, from_namespace, flavor);
-                    format!("std::map<{k}, {v}>")
+                    let element_flavor = match flavor {
+                        Flavor::BorrowedArgument | Flavor::Argument(AbiVariant::GuestImport) => {
+                            Flavor::BorrowedArgument
+                        }
+                        _ => Flavor::InStruct,
+                    };
+                    let k = self.type_name(key, from_namespace, element_flavor);
+                    let v = self.type_name(value, from_namespace, element_flavor);
+                    match flavor {
+                        Flavor::BorrowedArgument => {
+                            self.r#gen.dependencies.needs_span = true;
+                            format!("std::span<std::pair<{k}, {v}> const>")
+                        }
+                        Flavor::Argument(var)
+                            if matches!(var, AbiVariant::GuestImport)
+                                || self.r#gen.opts.api_style == APIStyle::Symmetric =>
+                        {
+                            self.r#gen.dependencies.needs_span = true;
+                            format!("std::span<std::pair<{k}, {v}> const>")
+                        }
+                        _ => {
+                            self.r#gen.dependencies.needs_wit = true;
+                            format!("wit::map<{k}, {v}>")
+                        }
+                    }
                 }
                 TypeDefKind::Unknown => todo!(),
             },
@@ -3559,28 +3576,28 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 let val = format!("map{tmp}");
                 let ptr = format!("ptr{tmp}");
                 let len = format!("len{tmp}");
-                let idx = format!("idx{tmp}");
-                let entry_name = format!("entry{tmp}");
                 let entry = self.r#gen.sizes.record([*key, *value]);
                 let size = entry.size.format(POINTER_SIZE_EXPRESSION);
                 let align = entry.align.format(POINTER_SIZE_EXPRESSION);
+                // The canonical ABI entry layout can differ from the C++ entry
+                // layout (see wit-bindgen#1592), so always allocate a fresh ABI
+                // buffer rather than reusing the source map's storage.
                 self.push_str(&format!("auto&& {val} = {};\n", operands[0]));
                 self.push_str(&format!("auto {len} = (size_t)({val}.size());\n"));
                 uwriteln!(
                     self.src,
                     "auto {ptr} = ({ptr_type})({len} > 0 ? cabi_realloc(nullptr, 0, {align}, {len} * {size}) : nullptr);",
                     ptr_type = self.r#gen.r#gen.opts.ptr_type()
                 );
-                uwriteln!(self.src, "size_t {idx} = 0;");
-                uwriteln!(self.src, "for (auto& {entry_name} : {val}) {{");
-                uwriteln!(self.src, "auto iter_map_key = {entry_name}.first;");
-                uwriteln!(self.src, "auto& iter_map_value = {entry_name}.second;");
-                uwriteln!(self.src, "auto base = {ptr} + {idx} * {size};");
+                uwriteln!(self.src, "for (size_t i = 0; i < {len}; ++i) {{");
+                uwriteln!(self.src, "auto base = {ptr} + i * {size};");
+                uwriteln!(self.src, "auto&& iter_entry = {val}[i];");
+                uwriteln!(self.src, "auto&& iter_map_key = iter_entry.first;");
+                uwriteln!(self.src, "auto&& iter_map_value = iter_entry.second;");
                 uwrite!(self.src, "{}", body.0);
-                uwriteln!(self.src, "++{idx};");
                 uwriteln!(self.src, "}}");
                 if realloc.is_some() {
-                    // ownership transfers
+                    uwriteln!(self.src, "{}.leak();", operands[0]);
                 }
                 results.push(ptr);
                 results.push(len);
@@ -3590,16 +3607,24 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 let tmp = self.tmp();
                 let entry = self.r#gen.sizes.record([*key, *value]);
                 let size = entry.size.format(POINTER_SIZE_EXPRESSION);
-                let key_type = self.r#gen.type_name(key, &self.namespace, Flavor::InStruct);
-                let value_type = self
-                    .r#gen
-                    .type_name(value, &self.namespace, Flavor::InStruct);
+                let flavor = if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric
+                    && matches!(self.variant, AbiVariant::GuestExport)
+                {
+                    Flavor::BorrowedArgument
+                } else {
+                    Flavor::InStruct
+                };
+                let key_type = self.r#gen.type_name(key, &self.namespace, flavor);
+                let value_type = self.r#gen.type_name(value, &self.namespace, flavor);
                 let len = format!("len{tmp}");
                 let base = format!("base{tmp}");
                 let result = format!("result{tmp}");
                 uwriteln!(self.src, "auto {base} = {};", operands[0]);
                 uwriteln!(self.src, "auto {len} = {};", operands[1]);
-                uwriteln!(self.src, "std::map<{key_type}, {value_type}> {result};");
+                uwriteln!(
+                    self.src,
+                    "auto {result} = wit::map<{key_type}, {value_type}>::allocate({len});"
+                );
                 if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric
                     && matches!(self.variant, AbiVariant::GuestExport)
                 {
@@ -3613,12 +3638,22 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                 let body_value = &body.1[1];
                 uwriteln!(
                     self.src,
-                    "{result}.insert(std::make_pair({}, {}));",
+                    "{result}.initialize(i, std::make_pair({}, {}));",
                     move_if_necessary(body_key),
                     move_if_necessary(body_value)
                 );
                 uwriteln!(self.src, "}}");
-                results.push(move_if_necessary(&result));
+
+                if self.r#gen.r#gen.opts.api_style == APIStyle::Symmetric
+                    && matches!(self.variant, AbiVariant::GuestExport)
+                {
+                    results.push(format!("{result}.get_const_view()"));
+                    self.leak_on_insertion.replace(format!(
+                        "if ({len}>0) _deallocate.push_back((void*){result}.leak());\n"
+                    ));
+                } else {
+                    results.push(move_if_necessary(&result));
+                }
             }
             abi::Instruction::IterMapKey { .. } => {
                 results.push("iter_map_key".to_string());