Implement serde support for our OOM-handling SecondaryMap

cranelift/entity/src/map.rs

@@ -212,6 +212,21 @@ where
     }
 }
 
+impl<K, V> From<Vec<V>> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Default,
+{
+    fn from(elems: Vec<V>) -> Self {
+        let default = Default::default();
+        Self {
+            elems,
+            default,
+            unused: PhantomData,
+        }
+    }
+}
+
 impl<K, V> FromIterator<(K, V)> for SecondaryMap<K, V>
 where
     K: EntityRef,

crates/core/src/alloc/vec.rs

@@ -264,18 +264,18 @@ impl<'a, T> IntoIterator for &'a mut Vec<T> {
     }
 }
 
-impl<T> From<StdVec<T>> for Vec<T> {
-    fn from(inner: StdVec<T>) -> Self {
-        Self { inner }
-    }
-}
-
 impl<T> From<Vec<T>> for StdVec<T> {
     fn from(v: Vec<T>) -> Self {
         v.inner
     }
 }
 
+impl<T> From<StdVec<T>> for Vec<T> {
+    fn from(inner: StdVec<T>) -> Self {
+        Self { inner }
+    }
+}
+
 impl<T> From<Box<[T]>> for Vec<T> {
     fn from(boxed_slice: Box<[T]>) -> Self {
         Self::from(StdVec::from(boxed_slice))

crates/environ/src/collections/secondary_map.rs

@@ -1,6 +1,7 @@
-use crate::error::OutOfMemory;
+use crate::{collections::Vec, error::OutOfMemory};
 use core::{fmt, ops::Index};
 use cranelift_entity::{EntityRef, SecondaryMap as Inner};
+use serde::ser::SerializeSeq;
 
 /// Like [`cranelift_entity::SecondaryMap`] but all allocation is fallible.
 pub struct SecondaryMap<K, V>
@@ -142,3 +143,46 @@ where
         &self.inner[k]
     }
 }
+
+impl<K, V> From<Vec<V>> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Default,
+{
+    fn from(values: Vec<V>) -> Self {
+        let values: alloc::vec::Vec<V> = values.into();
+        let inner = Inner::from(values);
+        Self { inner }
+    }
+}
+
+impl<K, V> serde::ser::Serialize for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + serde::ser::Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.capacity()))?;
+        for elem in self.values() {
+            seq.serialize_element(elem)?;
+        }
+        seq.end()
+    }
+}
+
+impl<'de, K, V> serde::de::Deserialize<'de> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Default + serde::de::Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let values: Vec<V> = serde::de::Deserialize::deserialize(deserializer)?;
+        Ok(Self::from(values))
+    }
+}