feat(preserve_order): integrate IndexMap support across Value types and deserializers

Author: lmmx

Cargo.toml

@@ -14,7 +14,7 @@ rust-version = "1.88"
 [dependencies]
 simdutf8 = { version = "0.1.4", features = ["public_imp", "aarch64_neon"] }
 
-value-trait = { version = "0.12" }
+value-trait = { version = "0.12.1" }
 beef = { version = "0.5", optional = true }
 halfbrown = "0.4"
 # ahash known key
@@ -25,6 +25,9 @@ ahash = { version = "0.8", optional = true }
 serde = { version = "1", features = ["derive"], optional = true }
 serde_json = { version = "1", optional = true }
 
+# preserve insertion order
+indexmap = { version = "2.0", optional = true }
+
 # perf testing
 alloc_counter = { version = "0.0.4", optional = true }
 colored = { version = "3.0", optional = true }
@@ -62,6 +65,9 @@ default = ["swar-number-parsing", "serde_impl", "runtime-detection"]
 
 arraybackend = ["halfbrown/arraybackend"]
 
+# preserve insertion order
+preserve_order = ["dep:indexmap", "value-trait/indexmap"]
+
 # Forces the `owned::Value` and `borrowed::Value` to deduplicate duplicated keys by letting consecutive keys overwrite previous ones. This comes at a
 # performance cost. By default duplicate keys will not be overwritten and feeding json objects with duplicated
 # keys to either of the `Value`s will result in undefined behavior.

src/serde/value/borrowed/de.rs

@@ -176,17 +176,32 @@ impl<'de> SeqAccess<'de> for ArrayRef<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectAccess<'de, const N: usize = 32> {
     i: halfbrown::IntoIter<Cow<'de, str>, Value<'de>, N>,
     v: Option<Value<'de>>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectAccess<'de> {
+    i: indexmap::map::IntoIter<Cow<'de, str>, Value<'de>>,
+    v: Option<Value<'de>>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de, const N: usize> ObjectAccess<'de, N> {
     fn new(i: halfbrown::IntoIter<Cow<'de, str>, Value<'de>, N>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectAccess<'de> {
+    fn new(i: indexmap::map::IntoIter<Cow<'de, str>, Value<'de>>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectAccess<'de> {
@@ -216,16 +231,32 @@ impl<'de> MapAccess<'de> for ObjectAccess<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectRefAccess<'de> {
     i: halfbrown::Iter<'de, Cow<'de, str>, Value<'de>>,
     v: Option<&'de Value<'de>>,
 }
+
+#[cfg(feature = "preserve_order")]
+struct ObjectRefAccess<'de> {
+    i: indexmap::map::Iter<'de, Cow<'de, str>, Value<'de>>,
+    v: Option<&'de Value<'de>>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de> ObjectRefAccess<'de> {
     fn new(i: halfbrown::Iter<'de, Cow<'de, str>, Value<'de>>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectRefAccess<'de> {
+    fn new(i: indexmap::map::Iter<'de, Cow<'de, str>, Value<'de>>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectRefAccess<'de> {

src/serde/value/borrowed/se.rs

@@ -194,7 +194,12 @@ impl<'se> serde::Serializer for Serializer<'se> {
     {
         let mut values = Object::with_capacity_and_hasher(1, ObjectHasher::default());
         let x = stry!(to_value(value));
-        unsafe { values.insert_nocheck(variant.into(), x) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            values.insert_nocheck(variant.into(), x);
+        };
+        #[cfg(feature = "preserve_order")]
+        values.insert(variant.into(), x);
         Ok(Value::from(values))
     }
 
@@ -349,7 +354,12 @@ impl<'se> serde::ser::SerializeTupleVariant for SerializeTupleVariant<'se> {
 
     fn end(self) -> Result<Value<'se>> {
         let mut object = Object::with_capacity_and_hasher(1, ObjectHasher::default());
-        unsafe { object.insert_nocheck(self.name.into(), Value::Array(Box::new(self.vec))) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            object.insert_nocheck(self.name.into(), Value::Array(Box::new(self.vec)))
+        };
+        #[cfg(feature = "preserve_order")]
+        object.insert(self.name.into(), Value::Array(Box::new(self.vec)));
 
         Ok(Value::Object(Box::new(object)))
     }
@@ -594,7 +604,12 @@ impl<'se> serde::ser::SerializeStructVariant for SerializeStructVariant<'se> {
 
     fn end(self) -> Result<Value<'se>> {
         let mut object = Object::with_capacity_and_hasher(1, ObjectHasher::default());
-        unsafe { object.insert_nocheck(self.name.into(), self.map.into()) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            object.insert_nocheck(self.name.into(), self.map.into())
+        };
+        #[cfg(feature = "preserve_order")]
+        object.insert(self.name.into(), self.map.into());
         Ok(Value::Object(Box::new(object)))
     }
 }

src/serde/value/owned/de.rs

@@ -164,16 +164,32 @@ impl<'de> SeqAccess<'de> for ArrayRef<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectAccess<const N: usize = 32> {
     i: halfbrown::IntoIter<String, Value, N>,
     v: Option<Value>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectAccess {
+    i: indexmap::map::IntoIter<String, Value>,
+    v: Option<Value>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<const N: usize> ObjectAccess<N> {
     fn new(i: halfbrown::IntoIter<String, Value, N>) -> Self {
         Self { i, v: None }
     }
 }
+
+#[cfg(feature = "preserve_order")]
+impl ObjectAccess {
+    fn new(i: indexmap::map::IntoIter<String, Value>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectAccess {
@@ -203,17 +219,32 @@ impl<'de> MapAccess<'de> for ObjectAccess {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectRefAccess<'de> {
     i: halfbrown::Iter<'de, String, Value>,
     v: Option<&'de Value>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectRefAccess<'de> {
+    i: indexmap::map::Iter<'de, String, Value>,
+    v: Option<&'de Value>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de> ObjectRefAccess<'de> {
     fn new(i: halfbrown::Iter<'de, String, Value>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectRefAccess<'de> {
+    fn new(i: indexmap::map::Iter<'de, String, Value>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectRefAccess<'de> {

src/serde/value/owned/se.rs

@@ -180,7 +180,12 @@ impl serde::Serializer for Serializer {
         T: ?Sized + Serialize,
     {
         let mut values = Object::with_capacity_and_hasher(1, ObjectHasher::default());
-        unsafe { values.insert_nocheck(variant.into(), stry!(to_value(value))) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            values.insert_nocheck(variant.into(), stry!(to_value(value)))
+        };
+        #[cfg(feature = "preserve_order")]
+        values.insert(variant.into(), stry!(to_value(value)));
         Ok(Value::from(values))
     }
 
@@ -335,7 +340,12 @@ impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
 
     fn end(self) -> Result<Value> {
         let mut object = Object::with_capacity_and_hasher(1, ObjectHasher::default());
-        unsafe { object.insert_nocheck(self.name, Value::Array(Box::new(self.vec))) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            object.insert_nocheck(self.name, Value::Array(Box::new(self.vec)))
+        };
+        #[cfg(feature = "preserve_order")]
+        object.insert(self.name, Value::Array(Box::new(self.vec)));
         Ok(Value::from(object))
     }
 }
@@ -574,7 +584,12 @@ impl serde::ser::SerializeStructVariant for SerializeStructVariant {
 
     fn end(self) -> Result<Value> {
         let mut object = Object::with_capacity_and_hasher(1, ObjectHasher::default());
-        unsafe { object.insert_nocheck(self.name, Value::from(self.map)) };
+        #[cfg(not(feature = "preserve_order"))]
+        unsafe {
+            object.insert_nocheck(self.name, Value::from(self.map))
+        };
+        #[cfg(feature = "preserve_order")]
+        object.insert(self.name, Value::from(self.map));
         Ok(Value::from(object))
     }
 }

src/value.rs

@@ -68,7 +68,10 @@ pub use self::owned::{
     to_value_with_buffers as to_owned_value_with_buffers,
 };
 use crate::{Buffers, Deserializer, Result};
+#[cfg(not(feature = "preserve_order"))]
 use halfbrown::HashMap;
+#[cfg(feature = "preserve_order")]
+use indexmap::IndexMap;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use tape::Node;
@@ -78,8 +81,18 @@ pub use value_trait::*;
 #[cfg(feature = "known-key")]
 pub type ObjectHasher = crate::known_key::NotSoRandomState;
 /// Hasher used for objects
-#[cfg(not(feature = "known-key"))]
+#[cfg(all(not(feature = "known-key"), not(feature = "preserve_order")))]
 pub type ObjectHasher = halfbrown::DefaultHashBuilder;
+/// Hasher used for objects
+#[cfg(all(not(feature = "known-key"), feature = "preserve_order"))]
+pub type ObjectHasher = std::hash::RandomState;
+
+/// Hashmap used for objects
+#[cfg(not(feature = "preserve_order"))]
+type ObjectMap<K, V> = HashMap<K, V, ObjectHasher>;
+/// Hashmap used for objects
+#[cfg(feature = "preserve_order")]
+type ObjectMap<K, V> = IndexMap<K, V, ObjectHasher>;
 
 /// Parses a slice of bytes into a Value dom.
 ///
@@ -92,7 +105,7 @@ pub type ObjectHasher = halfbrown::DefaultHashBuilder;
 /// Will return `Err` if `s` is invalid JSON.
 pub fn deserialize<'de, Value, Key>(s: &'de mut [u8]) -> Result<Value>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     match Deserializer::from_slice(s) {
@@ -117,7 +130,7 @@ pub fn deserialize_with_buffers<'de, Value, Key>(
     buffers: &mut Buffers,
 ) -> Result<Value>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     match Deserializer::from_slice_with_buffers(s, buffers) {
@@ -128,7 +141,7 @@ where
 
 struct ValueDeserializer<'de, Value, Key>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     de: Deserializer<'de>,
@@ -140,7 +153,7 @@ where
     Value: ValueBuilder<'de>
         + From<&'de str>
         + From<Vec<Value>>
-        + From<HashMap<Key, Value, ObjectHasher>>
+        + From<ObjectMap<Key, Value>>
         + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
@@ -179,18 +192,18 @@ where
 
     #[cfg_attr(not(feature = "no-inline"), inline)]
     fn parse_map(&mut self, len: usize) -> Value {
-        let mut res: HashMap<Key, Value, ObjectHasher> =
-            HashMap::with_capacity_and_hasher(len, ObjectHasher::default());
+        let mut res: ObjectMap<Key, Value> =
+            ObjectMap::with_capacity_and_hasher(len, ObjectHasher::default());
 
         // Since we checked if it's empty we know that we at least have one
         // element so we eat this
         for _ in 0..len {
             if let Node::String(key) = unsafe { self.de.next_() } {
-                #[cfg(not(feature = "value-no-dup-keys"))]
+                #[cfg(all(not(feature = "value-no-dup-keys"), not(feature = "preserve_order")))]
                 unsafe {
                     res.insert_nocheck(key.into(), self.parse());
                 };
-                #[cfg(feature = "value-no-dup-keys")]
+                #[cfg(any(feature = "value-no-dup-keys", feature = "preserve_order"))]
                 res.insert(key.into(), self.parse());
             } else {
                 unreachable!("parse_map: key needs to be a string");