Implement handling of #[serde(default)] on variant in internally tagged enums

If tag will not be found in the data, the default tag will be assumed

Author: Mingun

serde/src/private/de.rs

@@ -816,17 +816,18 @@ mod content {
     pub struct TaggedContentVisitor<T> {
         tag_name: &'static str,
         expecting: &'static str,
-        value: PhantomData<T>,
+        /// If set, this tag will be used if tag will not be found in data
+        default: Option<T>,
     }
 
     impl<T> TaggedContentVisitor<T> {
         /// Visitor for the content of an internally tagged enum with the given
         /// tag name.
-        pub fn new(name: &'static str, expecting: &'static str) -> Self {
+        pub fn new(name: &'static str, expecting: &'static str, default: Option<T>) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
                 expecting,
-                value: PhantomData,
+                default,
             }
         }
     }
@@ -846,6 +847,8 @@ mod content {
         where
             S: SeqAccess<'de>,
         {
+            // We do not support sequence representation without tags, because that may
+            // create ambiguity during deserialization
             let tag = match tri!(seq.next_element()) {
                 Some(tag) => tag,
                 None => {
@@ -879,7 +882,7 @@ mod content {
                     }
                 }
             }
-            match tag {
+            match tag.or(self.default) {
                 None => Err(de::Error::missing_field(self.tag_name)),
                 Some(tag) => Ok((tag, Content::Map(vec))),
             }

serde_derive/src/de/enum_internally.rs

@@ -27,33 +27,42 @@ pub(super) fn deserialize(
     let (variants_stmt, variant_visitor) = enum_::prepare_enum_variant_enum(variants);
 
     // Match arms to extract a variant from a string
-    let variant_arms = variants
+    let mut variants = variants
         .iter()
         .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_name = field_i(i);
+        .filter(|&(_, variant)| !variant.attrs.skip_deserializing());
+    let variant_arms = variants.clone().map(|(i, variant)| {
+        let variant_name = field_i(i);
 
-            let block = Match(deserialize_internally_tagged_variant(
-                params, variant, cattrs,
-            ));
+        let block = Match(deserialize_internally_tagged_variant(
+            params, variant, cattrs,
+        ));
 
-            quote! {
-                __Field::#variant_name => #block
-            }
-        });
+        quote! {
+            __Field::#variant_name => #block
+        }
+    });
 
     let expecting = format!("internally tagged enum {}", params.type_name());
     let expecting = cattrs.expecting().unwrap_or(&expecting);
 
+    // We checked that only one variant is marked with #[serde(default)]
+    let default = match variants.find(|(_, variant)| variant.attrs.default()) {
+        Some((i, _)) => {
+            let default = field_i(i);
+            quote! { _serde::#private::Some(__Field::#default) }
+        }
+        None => quote! { _serde::#private::None },
+    };
+
     quote_block! {
         #variant_visitor
 
         #variants_stmt
 
         let (__tag, __content) = _serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::#private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
+            _serde::#private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting, #default))?;
         let __deserializer = _serde::#private::de::ContentDeserializer::<__D::Error>::new(__content);
 
         match __tag {

test_suite/tests/test_enum_internally_tagged.rs

@@ -1037,6 +1037,126 @@ mod struct_enum {
     }
 }
 
+#[test]
+fn default_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag")]
+    enum InternallyTaggedWithDefault {
+        Unit,
+        NewtypeUnit(()),
+        NewtypeUnitStruct(Unit),
+        NewtypeNewtype(Newtype),
+        NewtypeMap(BTreeMap<String, String>),
+        NewtypeStruct(Struct),
+        NewtypeEnum(Enum),
+        #[serde(default)]
+        Struct {
+            a: u8,
+        },
+        StructEnum {
+            enum_: Enum,
+        },
+    }
+
+    let value = InternallyTaggedWithDefault::Struct { a: 1 };
+
+    // Special case: no tag field, use enum tokens
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    // Special case: no tag field, Map representation
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    // Special case: Map representation, unknown tag
+    assert_de_tokens_error::<InternallyTaggedWithDefault>(
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("Z"),
+            Token::MapEnd,
+        ],
+        "unknown variant `Z`, expected one of \
+        `Unit`, \
+        `NewtypeUnit`, \
+        `NewtypeUnitStruct`, \
+        `NewtypeNewtype`, \
+        `NewtypeMap`, \
+        `NewtypeStruct`, \
+        `NewtypeEnum`, \
+        `Struct`, \
+        `StructEnum`",
+    );
+
+    // Special case: Seq representation, unknown tag
+    assert_de_tokens_error::<InternallyTaggedWithDefault>(
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("Z"), // tag
+            Token::SeqEnd,
+        ],
+        "unknown variant `Z`, expected one of \
+        `Unit`, \
+        `NewtypeUnit`, \
+        `NewtypeUnitStruct`, \
+        `NewtypeNewtype`, \
+        `NewtypeMap`, \
+        `NewtypeStruct`, \
+        `NewtypeEnum`, \
+        `Struct`, \
+        `StructEnum`",
+    );
+
+    // Special case: Seq representation cannot be used without a tag due to ambiguity
+    assert_de_tokens_error::<InternallyTaggedWithDefault>(
+        &[
+            Token::Seq { len: Some(1) },
+            Token::U8(1), // tag (== NewtypeUnit)
+            Token::SeqEnd,
+        ],
+        // The error is not very clear, because actually we got end of sequence instead of a Unit
+        "invalid type: sequence, expected unit",
+    );
+}
+
 #[test]
 fn wrong_tag() {
     assert_de_tokens_error::<InternallyTagged>(