Fix AdjacentlyTaggedEnumVariant

serde/src/private/de.rs

@@ -1446,10 +1446,7 @@ mod content {
                 }
                 s @ Content::String(_) | s @ Content::Str(_) => (s, None),
                 other => {
-                    return Err(de::Error::invalid_type(
-                        other.unexpected(),
-                        &"string or map",
-                    ));
+                    return Err(de::Error::invalid_type(other.unexpected(), &visitor));
                 }
             };
 
@@ -2016,10 +2013,7 @@ mod content {
                 }
                 ref s @ Content::String(_) | ref s @ Content::Str(_) => (s, None),
                 ref other => {
-                    return Err(de::Error::invalid_type(
-                        other.unexpected(),
-                        &"string or map",
-                    ));
+                    return Err(de::Error::invalid_type(other.unexpected(), &visitor));
                 }
             };
 
@@ -2903,13 +2897,19 @@ where
     where
         D: Deserializer<'de>,
     {
-        deserializer.deserialize_enum(
-            self.enum_name,
-            self.variants,
-            AdjacentlyTaggedEnumVariantVisitor {
-                enum_name: self.enum_name,
-                fields_enum: PhantomData,
-            },
-        )
+        let content = Content::deserialize(deserializer)?;
+        let deserializer = ContentRefDeserializer::new(&content);
+
+        match F::deserialize(deserializer) {
+            Err(_) => deserializer.deserialize_enum(
+                self.enum_name,
+                self.variants,
+                AdjacentlyTaggedEnumVariantVisitor {
+                    enum_name: self.enum_name,
+                    fields_enum: PhantomData,
+                },
+            ),
+            v => v,
+        }
     }
 }

serde/src/private/ser.rs

@@ -1378,14 +1378,19 @@ impl Serialize for VariantName {
 pub struct AdjacentlyTaggedEnumVariant {
     pub enum_name: &'static str,
     pub variant_index: u32,
-    pub variant_name: &'static str,
+    pub variant_name: VariantName,
 }
 
 impl Serialize for AdjacentlyTaggedEnumVariant {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_unit_variant(self.enum_name, self.variant_index, self.variant_name)
+        match self.variant_name {
+            VariantName::String(name) => {
+                serializer.serialize_unit_variant(self.enum_name, self.variant_index, name)
+            }
+            ref s => s.serialize(serializer),
+        }
     }
 }

serde_derive/src/ser.rs

@@ -658,12 +658,15 @@ fn serialize_adjacently_tagged_variant(
 ) -> Fragment {
     let this_type = &params.this_type;
     let type_name = cattrs.name().serialize_name();
+
     let variant_name = variant.attrs.name().serialize_name();
+    let variant_name_lit = serialize_variant_name(&variant_name);
+
     let serialize_variant = quote! {
         &_serde::__private::ser::AdjacentlyTaggedEnumVariant {
             enum_name: #type_name,
             variant_index: #variant_index,
-            variant_name: #variant_name,
+            variant_name: #variant_name_lit,
         }
     };