Impl serde::{Serialize, Deserialize} for crate defined symbol types (#86)

* add pub(crate) new constructor for symbols

* add Serialize and Deserialize impls for symbols

Author: Robbepop

src/serde_impl.rs

@@ -85,3 +85,37 @@ where
         Ok(interner)
     }
 }
+
+macro_rules! impl_serde_for_symbol {
+    ($name:ident, $ty:ty) => {
+        impl ::serde::Serialize for $crate::symbol::$name {
+            fn serialize<T: ::serde::Serializer>(
+                &self,
+                serializer: T,
+            ) -> ::core::result::Result<T::Ok, T::Error> {
+                self.value.serialize(serializer)
+            }
+        }
+
+        impl<'de> ::serde::Deserialize<'de> for $crate::symbol::$name {
+            fn deserialize<D: ::serde::Deserializer<'de>>(
+                deserializer: D,
+            ) -> ::core::result::Result<Self, D::Error> {
+                let index = <$ty as ::serde::Deserialize<'de>>::deserialize(deserializer)?;
+                let ::core::option::Option::Some(symbol) = Self::new(index) else {
+                    return ::core::result::Result::Err(<D::Error as ::serde::de::Error>::custom(
+                        ::core::concat!(
+                            "invalid index value for `",
+                            ::core::stringify!($name),
+                            "`"
+                        ),
+                    ));
+                };
+                ::core::result::Result::Ok(symbol)
+            }
+        }
+    };
+}
+impl_serde_for_symbol!(SymbolU16, u16);
+impl_serde_for_symbol!(SymbolU32, u32);
+impl_serde_for_symbol!(SymbolUsize, usize);

src/symbol.rs

@@ -63,14 +63,20 @@ macro_rules! gen_symbol_for {
         $( #[$doc] )*
         #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
         pub struct $name {
-            value: $non_zero,
+            pub(crate) value: $non_zero,
+        }
+
+        impl $name {
+            pub(crate) fn new(index: $base_ty) -> Option<Self> {
+                <$non_zero>::new((index).wrapping_add(1))
+                    .map(|value| Self { value })
+            }
         }
 
         impl Symbol for $name {
             #[inline]
             fn try_from_usize(index: usize) -> Option<Self> {
-                <$non_zero>::new((index as $base_ty).wrapping_add(1))
-                    .map(|value| Self { value })
+                Self::new(index as $base_ty)
             }
 
             #[inline]