Add ability to use #[serde(default)] to deserialize internally tagged enums when no tag is provided

serde/src/private/de.rs

@@ -805,16 +805,22 @@ mod content {
     /// Not public API.
     pub struct TaggedContentVisitor<'de, T> {
         tag_name: &'static str,
+        default_variant: Option<T>,
         expecting: &'static str,
         value: PhantomData<TaggedContent<'de, T>>,
     }
 
     impl<'de, T> TaggedContentVisitor<'de, 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,
+            default_variant: Option<T>,
+            expecting: &'static str,
+        ) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
+                default_variant,
                 expecting,
                 value: PhantomData,
             }
@@ -851,11 +857,9 @@ mod content {
         where
             S: SeqAccess<'de>,
         {
-            let tag = match try!(seq.next_element()) {
+            let tag = match seq.next_element()?.or(self.default_variant) {
                 Some(tag) => tag,
-                None => {
-                    return Err(de::Error::missing_field(self.tag_name));
-                }
+                None => return Err(de::Error::missing_field(self.tag_name)),
             };
             let rest = de::value::SeqAccessDeserializer::new(seq);
             Ok(TaggedContent {
@@ -884,12 +888,12 @@ mod content {
                     }
                 }
             }
-            match tag {
-                None => Err(de::Error::missing_field(self.tag_name)),
-                Some(tag) => Ok(TaggedContent {
-                    tag,
+            match tag.or(self.default_variant) {
+                Some(default) => Ok(TaggedContent {
+                    tag: default,
                     content: Content::Map(vec),
                 }),
+                None => Err(de::Error::missing_field(self.tag_name)),
             }
         }
     }

serde_derive/src/de.rs

@@ -1366,6 +1366,10 @@ fn deserialize_internally_tagged_enum(
             }
         });
 
+    let default_variant = get_default_variant(variants).unwrap_or(quote! {
+        std::option::Option::None
+    });
+
     let expecting = format!("internally tagged enum {}", params.type_name());
     let expecting = cattrs.expecting().unwrap_or(&expecting);
 
@@ -1376,14 +1380,26 @@ fn deserialize_internally_tagged_enum(
 
         let __tagged = try!(_serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
+            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #default_variant, #expecting)));
 
         match __tagged.tag {
             #(#variant_arms)*
         }
     }
 }
 
+fn get_default_variant(variants: &[Variant]) -> Option<TokenStream> {
+    for (i, variant) in variants.iter().enumerate() {
+        if variant.attrs.default() {
+            let variant_name = field_i(i);
+            return Some(quote! {
+                std::option::Option::Some(__Field::#variant_name)
+            });
+        }
+    }
+    None
+}
+
 fn deserialize_adjacently_tagged_enum(
     params: &Parameters,
     variants: &[Variant],

serde_derive/src/internals/ast.rs

@@ -156,6 +156,17 @@ fn enum_from_ast<'a>(
         })
         .collect();
 
+    let mut has_default = false;
+    for variant in &variants {
+        if !variant.attrs.default() {
+            continue;
+        }
+        if has_default {
+            cx.error_spanned_by(&variant.ident, "only one variant can be marked as default");
+        }
+        has_default = true;
+    }
+
     let index_of_last_tagged_variant = variants
         .iter()
         .rposition(|variant| !variant.attrs.untagged());

serde_derive/src/internals/attr.rs

@@ -736,6 +736,7 @@ pub struct Variant {
     de_bound: Option<Vec<syn::WherePredicate>>,
     skip_deserializing: bool,
     skip_serializing: bool,
+    default: bool,
     other: bool,
     serialize_with: Option<syn::ExprPath>,
     deserialize_with: Option<syn::ExprPath>,
@@ -755,6 +756,7 @@ impl Variant {
         let mut de_aliases = VecAttr::none(cx, RENAME);
         let mut skip_deserializing = BoolAttr::none(cx, SKIP_DESERIALIZING);
         let mut skip_serializing = BoolAttr::none(cx, SKIP_SERIALIZING);
+        let mut default = BoolAttr::none(cx, DEFAULT);
         let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
         let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
         let mut ser_bound = Attr::none(cx, BOUND);
@@ -812,6 +814,8 @@ impl Variant {
                             }
                         }
                     }
+                } else if meta.path == DEFAULT {
+                    default.set_true(&meta.path);
                 } else if meta.path == SKIP {
                     // #[serde(skip)]
                     skip_serializing.set_true(&meta.path);
@@ -905,6 +909,7 @@ impl Variant {
             de_bound: de_bound.get(),
             skip_deserializing: skip_deserializing.get(),
             skip_serializing: skip_serializing.get(),
+            default: default.get(),
             other: other.get(),
             serialize_with: serialize_with.get(),
             deserialize_with: deserialize_with.get(),
@@ -950,6 +955,10 @@ impl Variant {
         self.skip_serializing
     }
 
+    pub fn default(&self) -> bool {
+        self.default
+    }
+
     pub fn other(&self) -> bool {
         self.other
     }

test_suite/tests/test_macros.rs

@@ -812,6 +812,117 @@ fn test_internally_tagged_enum() {
     );
 }
 
+#[test]
+fn test_internally_tagged_enum_with_default_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Newtype(BTreeMap<String, String>);
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Struct {
+        f: u8,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTaggedWithDefaultStructVariant {
+        #[serde(default)]
+        A {
+            a: u8,
+        },
+        E(Struct),
+        B,
+        C(BTreeMap<String, String>),
+        D(Newtype),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTaggedWithDefaultTupleVariant {
+        A {
+            a: u8,
+        },
+        #[serde(default)]
+        E(Struct),
+        B,
+        C(BTreeMap<String, String>),
+        D(Newtype),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTaggedWithDefaultUnitVariant {
+        A {
+            a: u8,
+        },
+        E(Struct),
+        #[serde(default)]
+        B,
+        C(BTreeMap<String, String>),
+        D(Newtype),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTaggedWithDefaultMapVariant {
+        A {
+            a: u8,
+        },
+        E(Struct),
+        B,
+        #[serde(default)]
+        C(BTreeMap<String, String>),
+        D(Newtype),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTaggedWithDefaultNewtypeVariant {
+        A {
+            a: u8,
+        },
+        E(Struct),
+        B,
+        C(BTreeMap<String, String>),
+        #[serde(default)]
+        D(Newtype),
+    }
+
+    assert_de_tokens(
+        &InternallyTaggedWithDefaultStructVariant::A { a: 1 },
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTaggedWithDefaultTupleVariant::E(Struct { f: 1 }),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("f"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTaggedWithDefaultUnitVariant::B,
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+    );
+
+    assert_de_tokens(
+        &InternallyTaggedWithDefaultMapVariant::C(BTreeMap::new()),
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+    );
+
+    assert_de_tokens(
+        &InternallyTaggedWithDefaultNewtypeVariant::D(Newtype(BTreeMap::new())),
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+    );
+}
+
 #[test]
 fn test_internally_tagged_bytes() {
     #[derive(Debug, PartialEq, Deserialize)]