Release 1.0.192

Allow internal tag field in untagged variant

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.191"
+version = "1.0.192"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -37,7 +37,7 @@ rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]
 # is compatible with exactly one serde release because the generated code
 # involves nonpublic APIs which are not bound by semver.
 [target.'cfg(any())'.dependencies]
-serde_derive = { version = "=1.0.191", path = "../serde_derive" }
+serde_derive = { version = "=1.0.192", path = "../serde_derive" }
 
 
 ### FEATURES #################################################################

serde/src/lib.rs

@@ -95,7 +95,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.191")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.192")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Show which crate feature enables conditionally compiled APIs in documentation.

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.191"
+version = "1.0.192"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std", "no-std::no-alloc"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"

serde_derive/src/internals/check.rs

@@ -318,6 +318,9 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     for variant in variants {
         match variant.style {
             Style::Struct => {
+                if variant.attrs.untagged() {
+                    continue;
+                }
                 for field in &variant.fields {
                     let check_ser =
                         !(field.attrs.skip_serializing() || variant.attrs.skip_serializing());

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.191")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.192")]
 // Ignored clippy lints
 #![allow(
     // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054

test_suite/tests/test_macros.rs

@@ -814,6 +814,100 @@ fn test_internally_tagged_enum() {
     );
 }
 
+#[test]
+fn test_internally_tagged_enum_with_untagged_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "kind")]
+    enum InternallyTagged {
+        Tagged {
+            a: u8,
+        },
+        #[serde(untagged)]
+        Untagged {
+            kind: String,
+            b: u8,
+        },
+    }
+
+    assert_de_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Tagged".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_internally_tagged_bytes() {
     #[derive(Debug, PartialEq, Deserialize)]