1 files changed, 151 insertions, 0 deletions
diff --git a/third_party/rust/hashlink/src/serde.rs b/third_party/rust/hashlink/src/serde.rs
new file mode 100644
index 0000000000..b8e307c16b
--- /dev/null
+++ b/third_party/rust/hashlink/src/serde.rs
@@ -0,0 +1,151 @@
+use std::{
+    fmt::{self, Formatter},
+    hash::{BuildHasher, Hash},
+    marker::PhantomData,
+};
+
+use serde::{
+    de::{MapAccess, SeqAccess, Visitor},
+    ser::{SerializeMap, SerializeSeq},
+    Deserialize, Deserializer, Serialize, Serializer,
+};
+
+use crate::{LinkedHashMap, LinkedHashSet};
+
+// LinkedHashMap impls
+
+impl<K, V, S> Serialize for LinkedHashMap<K, V, S>
+where
+    K: Serialize + Eq + Hash,
+    V: Serialize,
+    S: BuildHasher,
+{
+    #[inline]
+    fn serialize<T: Serializer>(&self, serializer: T) -> Result<T::Ok, T::Error> {
+        let mut map_serializer = serializer.serialize_map(Some(self.len()))?;
+        for (k, v) in self {
+            map_serializer.serialize_key(k)?;
+            map_serializer.serialize_value(v)?;
+        }
+        map_serializer.end()
+    }
+}
+
+#[derive(Debug)]
+pub struct LinkedHashMapVisitor<K, V> {
+    marker: PhantomData<LinkedHashMap<K, V>>,
+}
+
+impl<K, V> LinkedHashMapVisitor<K, V> {
+    fn new() -> Self {
+        LinkedHashMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> Default for LinkedHashMapVisitor<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de, K, V> Visitor<'de> for LinkedHashMapVisitor<K, V>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+{
+    type Value = LinkedHashMap<K, V>;
+
+    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+        write!(formatter, "a map")
+    }
+
+    #[inline]
+    fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Self::Value, M::Error> {
+        let mut values = LinkedHashMap::with_capacity(map.size_hint().unwrap_or(0));
+
+        while let Some((k, v)) = map.next_entry()? {
+            values.insert(k, v);
+        }
+
+        Ok(values)
+    }
+}
+
+impl<'de, K, V> Deserialize<'de> for LinkedHashMap<K, V>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+{
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_map(LinkedHashMapVisitor::default())
+    }
+}
+
+// LinkedHashSet impls
+
+impl<T, S> Serialize for LinkedHashSet<T, S>
+where
+    T: Serialize + Eq + Hash,
+    S: BuildHasher,
+{
+    #[inline]
+    fn serialize<U: Serializer>(&self, serializer: U) -> Result<U::Ok, U::Error> {
+        let mut seq_serializer = serializer.serialize_seq(Some(self.len()))?;
+        for v in self {
+            seq_serializer.serialize_element(v)?;
+        }
+        seq_serializer.end()
+    }
+}
+
+#[derive(Debug)]
+pub struct LinkedHashSetVisitor<T> {
+    marker: PhantomData<LinkedHashSet<T>>,
+}
+
+impl<T> LinkedHashSetVisitor<T> {
+    fn new() -> Self {
+        LinkedHashSetVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Default for LinkedHashSetVisitor<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de, T> Visitor<'de> for LinkedHashSetVisitor<T>
+where
+    T: Deserialize<'de> + Eq + Hash,
+{
+    type Value = LinkedHashSet<T>;
+
+    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+        write!(formatter, "a sequence")
+    }
+
+    #[inline]
+    fn visit_seq<S: SeqAccess<'de>>(self, mut seq: S) -> Result<Self::Value, S::Error> {
+        let mut values = LinkedHashSet::with_capacity(seq.size_hint().unwrap_or(0));
+
+        while let Some(v) = seq.next_element()? {
+            values.insert(v);
+        }
+
+        Ok(values)
+    }
+}
+
+impl<'de, T> Deserialize<'de> for LinkedHashSet<T>
+where
+    T: Deserialize<'de> + Eq + Hash,
+{
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_seq(LinkedHashSetVisitor::default())
+    }
+}