Release 1.0.94

Accept enums in IgnoredAny

README.md

@@ -81,19 +81,19 @@ good response, we are happy to respond to [GitHub issues][issues] as well.
 [irc]: https://wiki.mozilla.org/IRC
 [issues]: https://github.com/serde-rs/serde/issues/new/choose
 
-## License
+<br>
 
-Serde is licensed under either of
+#### License
 
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+<sup>
-   http://www.apache.org/licenses/LICENSE-2.0)
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-   http://opensource.org/licenses/MIT)
+</sup>
 
-at your option.
+<br>
-
-### Contribution
 
+<sub>
 Unless you explicitly state otherwise, any contribution intentionally submitted
 for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
 dual licensed as above, without any additional terms or conditions.
+</sub>

serde/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde"
-version = "1.0.91" # remember to update html_root_url
+version = "1.0.94" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde/src/de/ignored_any.rs

@@ -1,6 +1,8 @@
 use lib::*;
 
-use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+use de::{
+    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
+};
 
 /// An efficient way of discarding data from a deserializer.
 ///
@@ -205,6 +207,13 @@ impl<'de> Visitor<'de> for IgnoredAny {
         let _ = bytes;
         Ok(IgnoredAny)
     }
+
+    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
+    where
+        A: EnumAccess<'de>,
+    {
+        data.variant::<IgnoredAny>()?.1.newtype_variant()
+    }
 }
 
 impl<'de> Deserialize<'de> for IgnoredAny {

serde/src/de/impls.rs

@@ -965,7 +965,7 @@ impl<'de, T> Deserialize<'de> for [T; 0] {
 }
 
 macro_rules! array_impls {
-    ($($len:expr => ($($n:tt $name:ident)+))+) => {
+    ($($len:expr => ($($n:tt)+))+) => {
         $(
             impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
             where
@@ -982,14 +982,12 @@ macro_rules! array_impls {
                 where
                     A: SeqAccess<'de>,
                 {
-                    $(
+                    Ok([$(
-                        let $name = match try!(seq.next_element()) {
+                        match try!(seq.next_element()) {
                             Some(val) => val,
                             None => return Err(Error::invalid_length($n, &self)),
-                        };
+                        }
-                    )+
+                    ),+])
-
-                    Ok([$($name),+])
                 }
             }
 
@@ -1045,38 +1043,38 @@ macro_rules! array_impls {
 }
 
 array_impls! {
-    1 => (0 a)
+    1 => (0)
-    2 => (0 a 1 b)
+    2 => (0 1)
-    3 => (0 a 1 b 2 c)
+    3 => (0 1 2)
-    4 => (0 a 1 b 2 c 3 d)
+    4 => (0 1 2 3)
-    5 => (0 a 1 b 2 c 3 d 4 e)
+    5 => (0 1 2 3 4)
-    6 => (0 a 1 b 2 c 3 d 4 e 5 f)
+    6 => (0 1 2 3 4 5)
-    7 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g)
+    7 => (0 1 2 3 4 5 6)
-    8 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h)
+    8 => (0 1 2 3 4 5 6 7)
-    9 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i)
+    9 => (0 1 2 3 4 5 6 7 8)
-    10 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j)
+    10 => (0 1 2 3 4 5 6 7 8 9)
-    11 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k)
+    11 => (0 1 2 3 4 5 6 7 8 9 10)
-    12 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l)
+    12 => (0 1 2 3 4 5 6 7 8 9 10 11)
-    13 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m)
+    13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
-    14 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n)
+    14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
-    15 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o)
+    15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
-    16 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p)
+    16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
-    17 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q)
+    17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
-    18 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r)
+    18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
-    19 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s)
+    19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
-    20 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t)
+    20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
-    21 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u)
+    21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
-    22 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v)
+    22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
-    23 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w)
+    23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
-    24 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x)
+    24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
-    25 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y)
+    25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
-    26 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z)
+    26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
-    27 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa)
+    27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
-    28 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab)
+    28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
-    29 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac)
+    29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
-    30 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad)
+    30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
-    31 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad 30 ae)
+    31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
-    32 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad 30 ae 31 af)
+    32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
 }
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/export.rs

@@ -9,7 +9,7 @@ pub use lib::result::Result::{self, Err, Ok};
 pub use self::string::from_utf8_lossy;
 
 #[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::Vec;
+pub use lib::{ToString, Vec};
 
 mod string {
     use lib::*;

serde/src/lib.rs

@@ -73,7 +73,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.91")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.94")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
@@ -81,7 +81,7 @@
 //
 //    https://github.com/serde-rs/serde/issues/812
 #![cfg_attr(feature = "unstable", feature(specialization, never_type))]
-#![cfg_attr(feature = "alloc", feature(alloc))]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy and clippy_pedantic lints
@@ -89,13 +89,13 @@
     feature = "cargo-clippy",
     allow(
         // not available in our oldest supported compiler
-        const_static_lifetime,
+        checked_conversions,
         empty_enum,
         redundant_field_names,
+        redundant_static_lifetimes,
         // integer and float ser/de requires these sorts of casts
         cast_possible_truncation,
         cast_possible_wrap,
-        cast_precision_loss,
         cast_sign_loss,
         // things are often more readable this way
         cast_lossless,
@@ -153,7 +153,7 @@ mod lib {
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::string::{String, ToString};
     #[cfg(feature = "std")]
-    pub use std::string::String;
+    pub use std::string::{String, ToString};
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::vec::Vec;

serde/src/private/de.rs

@@ -1420,6 +1420,7 @@ mod content {
                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
                 Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -2123,6 +2124,7 @@ mod content {
                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
                 Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }

serde_derive/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_derive"
-version = "1.0.91" # remember to update html_root_url
+version = "1.0.94" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_derive/src/de.rs

@@ -2059,7 +2059,7 @@ fn deserialize_identifier(
     ) = if collect_other_fields {
         (
             Some(quote! {
-                let __value = _serde::private::de::Content::String(__value.to_string());
+                let __value = _serde::private::de::Content::String(_serde::export::ToString::to_string(__value));
             }),
             Some(quote! {
                 let __value = _serde::private::de::Content::Str(__value);

serde_derive/src/lib.rs

@@ -13,7 +13,8 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.91")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.94")]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
@@ -34,6 +35,7 @@
     feature = "cargo-clippy",
     allow(
         cast_possible_truncation,
+        checked_conversions,
         doc_markdown,
         enum_glob_use,
         filter_map,

serde_derive_internals/Cargo.toml

@@ -2,7 +2,7 @@
 name = "serde_derive_internals"
 version = "0.24.1" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_derive_internals/lib.rs

@@ -1,4 +1,5 @@
 #![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.24.1")]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(
     feature = "cargo-clippy",

serde_test/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_test"
-version = "1.0.91" # remember to update html_root_url
+version = "1.0.94" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.91")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.94")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints

test_suite/Cargo.toml

@@ -8,6 +8,9 @@ publish = false
 [features]
 unstable = ["serde/unstable"]
 
+[dependencies]
+serde = { path = "../serde" }
+
 [dev-dependencies]
 fnv = "1.0"
 rustc-serialize = "0.3.16"

test_suite/tests/compiletest.rs

@@ -1,3 +1,4 @@
+#[cfg(not(target_os = "emscripten"))]
 #[rustc::attr(not(nightly), ignore)]
 #[test]
 fn ui() {

test_suite/tests/test_de.rs

@@ -124,6 +124,19 @@ enum EnumOther {
     Other,
 }
 
+#[derive(PartialEq, Debug)]
+struct IgnoredAny;
+
+impl<'de> Deserialize<'de> for IgnoredAny {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        serde::de::IgnoredAny::deserialize(deserializer)?;
+        Ok(IgnoredAny)
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 macro_rules! declare_tests {
@@ -929,6 +942,21 @@ declare_tests! {
             Token::SeqEnd,
         ],
     }
+    test_ignored_any {
+        IgnoredAny => &[
+            Token::Str("s"),
+        ],
+        IgnoredAny => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+        IgnoredAny => &[
+            Token::Enum { name: "E" },
+            Token::Str("Rust"),
+            Token::Unit,
+        ],
+    }
 }
 
 declare_tests! {

test_suite/tests/test_ignored_any.rs

@@ -0,0 +1,104 @@
+use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
+use serde::de::{
+    DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
+};
+use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
+
+#[derive(PartialEq, Debug, Deserialize)]
+enum Target {
+    Unit,
+    Newtype(i32),
+    Tuple(i32, i32),
+    Struct { a: i32 },
+}
+
+struct Enum(&'static str);
+
+impl<'de> Deserializer<'de> for Enum {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(self)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+impl<'de> EnumAccess<'de> for Enum {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        let v = seed.deserialize(self.0.into_deserializer())?;
+        Ok((v, self))
+    }
+}
+
+impl<'de> VariantAccess<'de> for Enum {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        seed.deserialize(10i32.into_deserializer())
+    }
+
+    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let seq = SeqDeserializer::new(vec![1i32, 2].into_iter());
+        visitor.visit_seq(seq)
+    }
+
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let map = MapDeserializer::new(vec![("a", 10i32)].into_iter());
+        visitor.visit_map(map)
+    }
+}
+
+#[test]
+fn test_deserialize_enum() {
+    // First just make sure the Deserializer impl works
+    assert_eq!(Target::Unit, Target::deserialize(Enum("Unit")).unwrap());
+    assert_eq!(
+        Target::Newtype(10),
+        Target::deserialize(Enum("Newtype")).unwrap()
+    );
+    assert_eq!(
+        Target::Tuple(1, 2),
+        Target::deserialize(Enum("Tuple")).unwrap()
+    );
+    assert_eq!(
+        Target::Struct { a: 10 },
+        Target::deserialize(Enum("Struct")).unwrap()
+    );
+
+    // Now try IgnoredAny
+    IgnoredAny::deserialize(Enum("Unit")).unwrap();
+    IgnoredAny::deserialize(Enum("Newtype")).unwrap();
+    IgnoredAny::deserialize(Enum("Tuple")).unwrap();
+    IgnoredAny::deserialize(Enum("Struct")).unwrap();
+}

test_suite/tests/test_macros.rs

@@ -1466,6 +1466,34 @@ fn test_internally_tagged_struct_with_flattened_field() {
     );
 }
 
+#[test]
+fn test_untagged_enum_with_flattened_integer_key() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(untagged)]
+    pub enum Untagged {
+        Variant {
+            #[serde(flatten)]
+            map: BTreeMap<u64, String>,
+        },
+    }
+
+    assert_tokens(
+        &Untagged::Variant {
+            map: {
+                let mut map = BTreeMap::new();
+                map.insert(100, "BTreeMap".to_owned());
+                map
+            },
+        },
+        &[
+            Token::Map { len: None },
+            Token::U64(100),
+            Token::Str("BTreeMap"),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_enum_in_untagged_enum() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]