Attempt to finish serialize, but.. macros :(

bearcove · Nov 4, 2024 · dabf786 · dabf786
1 parent 447dd72
commit dabf786
Show file tree

Hide file tree

Showing 6 changed files with 65 additions and 12 deletions.
diff --git a/merde/examples/enums.rs b/merde/examples/enums.rs
@@ -14,7 +14,7 @@ fn main() {
     ];
 
     for event in events {
-        let json = event.to_json_string();
+        let json = event.to_json_string().unwrap();
         println!("JSON: {}", json);
         let deserialized: ExampleEvent = merde::json::from_str(&json).unwrap();
         println!("Deserialized: {:?}", deserialized);

diff --git a/merde/examples/return-deserialize.rs b/merde/examples/return-deserialize.rs
@@ -29,7 +29,7 @@ fn main() {
     let person: Person = merde_json::from_str(input).unwrap();
     println!("{:?}", person);
 
-    let serialized = person.to_json_string();
+    let serialized = person.to_json_string().unwrap();
     let person2: Person = merde_json::from_str(&serialized).unwrap();
     println!("{:?}", person2);
 

diff --git a/merde/examples/simple.rs b/merde/examples/simple.rs
@@ -29,7 +29,7 @@ fn main() {
     // Round-trip! Again, every binding borrows from the previous one, and
     // everything can be converted from `F<'a>` to `F<'static>` via the
     // `IntoStatic` trait.
-    let serialized = person.to_json_string();
+    let serialized = person.to_json_string().unwrap();
     let person2: Person = merde_json::from_str(&serialized).unwrap();
     println!("{:#?}", person2);
 

diff --git a/merde/src/lib.rs b/merde/src/lib.rs
@@ -453,15 +453,15 @@ macro_rules! impl_with_lifetime {
 
 #[doc(hidden)]
 #[macro_export]
-#[cfg(all(feature = "core"))]
+#[cfg(feature = "core")]
 macro_rules! impl_serialize {
     // owned tuple struct (transparent)
     (struct $struct_name:ident transparent) => {
         #[automatically_derived]
         impl $crate::Serialize for $struct_name {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 self.0.serialize(serializer).await
             }
@@ -474,7 +474,7 @@ macro_rules! impl_serialize {
         impl<$lifetime> $crate::Serialize for $struct_name<$lifetime> {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 self.0.serialize(serializer).await
             }
@@ -487,13 +487,13 @@ macro_rules! impl_serialize {
         impl<$lifetime> $crate::Serialize for $struct_name<$lifetime> {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 #[allow(unused_imports)]
                 use $crate::Event;
 
                 serializer
-                    .write(Event::MapStart(MapStart {
+                    .write(Event::MapStart($crate::MapStart {
                         size_hint: Some($crate::count_ident_tokens!($($field)*)),
                     }))
                     .await?;
@@ -512,7 +512,7 @@ macro_rules! impl_serialize {
         impl $crate::Serialize for $struct_name {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 #[allow(unused_imports)]
                 use $crate::Event;
@@ -539,7 +539,7 @@ macro_rules! impl_serialize {
         impl $crate::Serialize for $enum_name {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 #[allow(unused_imports)]
                 use $crate::Event;
@@ -572,7 +572,7 @@ macro_rules! impl_serialize {
         impl<$lifetime> $crate::Serialize for $enum_name<$lifetime> {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 #[allow(unused_imports)]
                 use $crate::Event;
@@ -605,7 +605,7 @@ macro_rules! impl_serialize {
         impl $crate::Serialize for $enum_name {
             async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
             where
-                S: Serializer + ?Sized,
+                S: $crate::Serializer + ?Sized,
             {
                 #[allow(unused_imports)]
                 use $crate::Event;
@@ -745,6 +745,15 @@ pub fn none_of<I, T>(_f: impl FnOnce(I) -> T) -> Option<T> {
     None
 }
 
+#[doc(hidden)]
+#[macro_export]
+macro_rules! count_ident_tokens {
+    () => { 0 };
+    ($first:ident) => { 1 };
+    ($first:ident $($rest:ident)*) => {
+        1 + $crate::count_ident_tokens!($($rest)*)
+    };
+}
 #[cfg(test)]
 #[cfg(feature = "json")]
 mod json_tests {

diff --git a/merde_core/src/serialize.rs b/merde_core/src/serialize.rs
@@ -243,5 +243,47 @@ impl<'s> Serialize for Value<'s> {
     }
 }
 
+macro_rules! impl_serialize_for_tuple {
+    ($($type_arg:ident),*) => {
+        impl<$($type_arg: Serialize),*> Serialize for ($($type_arg),*,) {
+            async fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+            where
+                S: Serializer + ?Sized,
+            {
+                serializer.write(Event::ArrayStart(ArrayStart {
+                    size_hint: Some(count_tup!($($type_arg)*))
+                })).await?;
+
+                impl_serialize_for_tuple!(@inner self serializer () ($($type_arg)*));
+                serializer.write(Event::ArrayEnd).await
+            }
+        }
+    };
+
+    (@inner $self:ident $serializer:ident ($($ignores:pat)*) ($m:ident $($r:ident)*)) => {
+        let ($($ignores)*, _field, ..) = $self;
+        _field.serialize($serializer).await?;
+        impl_serialize_for_tuple!(@inner $self $serializer ($($ignores)* _) ($($r)*));
+    };
+    (@inner $self:ident $serializer:ident ($($ignores:pat)*) ($m:ident)) => {
+        let ($($ignores)*, _field) = $self;
+        _field.serialize($serializer).await?;
+    };
+
+    // turns (a b c) into (_, _, _,)
+    (@to_underscore $($x:ident)*) => ($(_,)*);
+}
+
+const fn increment(x: usize) -> usize {
+    x + 1
+}
+
+macro_rules! count_tup {
+    () => { 0 };
+    ($t:ident $($rest:ident)*) => { 1 + count_tup!($($rest)*) };
+}
+
+impl_serialize_for_tuple!(T0);
+
 #[cfg(test)]
 mod tests;
diff --git a/merde_json/src/lib.rs b/merde_json/src/lib.rs
@@ -217,6 +217,8 @@ pub trait JsonSerialize: Serialize + Sized {
     }
 }
 
+impl<T> JsonSerialize for T where T: Serialize {}
+
 /// Unifies [MerdeError] and [JiterError] into a single type
 pub enum MerdeJsonError<'s> {
     /// A [MerdeError]