UPDATED: Integer/boolean tags for internally/adjacently tagged enums

serde/src/private/de.rs

@@ -2587,6 +2587,28 @@ where
     }
 }
 
+impl<'de, E> IdentifierDeserializer<'de, E> for i64
+where
+    E: Error,
+{
+    type Deserializer = <i64 as IntoDeserializer<'de, E>>::Deserializer;
+
+    fn from(self) -> Self::Deserializer {
+        self.into_deserializer()
+    }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for bool
+where
+    E: Error,
+{
+    type Deserializer = <bool as IntoDeserializer<'de, E>>::Deserializer;
+
+    fn from(self) -> Self::Deserializer {
+        self.into_deserializer()
+    }
+}
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
     pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,

serde/src/private/ser.rs

@@ -19,7 +19,7 @@ pub fn serialize_tagged_newtype<S, T>(
     type_ident: &'static str,
     variant_ident: &'static str,
     tag: &'static str,
-    variant_name: &'static str,
+    variant_name: VariantName,
     value: &T,
 ) -> Result<S::Ok, S::Error>
 where
@@ -39,7 +39,7 @@ struct TaggedSerializer<S> {
     type_ident: &'static str,
     variant_ident: &'static str,
     tag: &'static str,
-    variant_name: &'static str,
+    variant_name: VariantName,
     delegate: S,
 }
 
@@ -183,13 +183,13 @@ where
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(Some(1)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         map.end()
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(Some(1)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         map.end()
     }
 
@@ -200,7 +200,7 @@ where
         inner_variant: &'static str,
     ) -> Result<Self::Ok, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(Some(2)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         tri!(map.serialize_entry(inner_variant, &()));
         map.end()
     }
@@ -227,7 +227,7 @@ where
         T: Serialize,
     {
         let mut map = tri!(self.delegate.serialize_map(Some(2)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         tri!(map.serialize_entry(inner_variant, inner_value));
         map.end()
     }
@@ -270,7 +270,7 @@ where
         len: usize,
     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(Some(2)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         tri!(map.serialize_key(inner_variant));
         Ok(SerializeTupleVariantAsMapValue::new(
             map,
@@ -281,7 +281,7 @@ where
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(len.map(|len| len + 1)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         Ok(map)
     }
 
@@ -291,7 +291,7 @@ where
         len: usize,
     ) -> Result<Self::SerializeStruct, Self::Error> {
         let mut state = tri!(self.delegate.serialize_struct(name, len + 1));
-        tri!(state.serialize_field(self.tag, self.variant_name));
+        tri!(state.serialize_field(self.tag, &self.variant_name));
         Ok(state)
     }
 
@@ -317,7 +317,7 @@ where
         len: usize,
     ) -> Result<Self::SerializeStructVariant, Self::Error> {
         let mut map = tri!(self.delegate.serialize_map(Some(2)));
-        tri!(map.serialize_entry(self.tag, self.variant_name));
+        tri!(map.serialize_entry(self.tag, &self.variant_name));
         tri!(map.serialize_key(inner_variant));
         Ok(SerializeStructVariantAsMapValue::new(
             map,
@@ -1356,6 +1356,25 @@ where
     }
 }
 
+pub enum VariantName {
+    String(&'static str),
+    Integer(i64),
+    Boolean(bool),
+}
+
+impl Serialize for VariantName {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            VariantName::String(s) => serializer.serialize_str(s),
+            VariantName::Integer(i) => serializer.serialize_i64(*i),
+            VariantName::Boolean(b) => serializer.serialize_bool(*b),
+        }
+    }
+}
+
 pub struct AdjacentlyTaggedEnumVariant {
     pub enum_name: &'static str,
     pub variant_index: u32,

serde_derive/src/bound.rs

@@ -60,7 +60,7 @@ pub fn with_where_predicates_from_variants(
     from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
 ) -> syn::Generics {
     let variants = match &cont.data {
-        Data::Enum(variants) => variants,
+        Data::Enum(_, variants) => variants,
         Data::Struct(_, _) => {
             return generics.clone();
         }
@@ -255,7 +255,7 @@ pub fn with_bound(
         associated_type_usage: Vec::new(),
     };
     match &cont.data {
-        Data::Enum(variants) => {
+        Data::Enum(_, variants) => {
             for variant in variants {
                 let relevant_fields = variant
                     .fields