Release 1.0.96

Provide 32 bit atomic impls for emscripten
Merge pull request #1581 from Roguelazer/issue-1579
2026-04-23 03:38:00 +00:00 · 2019-07-17 12:04:19 -07:00 · 2019-07-17 11:44:24 -07:00 · 2019-07-17 11:01:21 -07:00 · 2019-07-17 09:57:53 -07:00 · 2019-07-17 09:19:03 -07:00
135 changed files with 870 additions and 595 deletions
@@ -26,10 +26,8 @@ matrix:
        - cargo build --no-default-features --features alloc
        - cargo build --no-default-features --features rc,alloc
        - cargo test --features derive,rc,unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/deps"
-        - cargo build
        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test --features compiletest,unstable
+        - cargo test --features unstable
        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
        - cargo build

@@ -50,11 +48,17 @@ matrix:
    - rust: 1.21.0
    - rust: 1.25.0
    - rust: 1.26.0
+    - rust: 1.34.0
+
+    - rust: 1.36.0
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build --no-default-features --features alloc

    - rust: nightly
      name: Clippy
      script:
-        - rustup component add clippy-preview || travis_terminate 0
+        - rustup component add clippy || travis_terminate 0
        - cargo clippy -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/serde"
        - cargo clippy --features rc,unstable -- -D clippy::all
@@ -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
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>

-at your option.
-
-### Contribution
+<br>

+<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>
@@ -35,7 +35,5 @@ for:
      - cargo build --no-default-features --features alloc
      - cargo build --no-default-features --features rc,alloc
      - cargo test --features derive,rc,unstable
-      - cd %APPVEYOR_BUILD_FOLDER%\test_suite\deps
-      - cargo build
      - cd %APPVEYOR_BUILD_FOLDER%\test_suite
-      - cargo test --features compiletest,unstable
+      - cargo test --features unstable
@@ -1,8 +1,8 @@
 [package]
 name = "serde"
-version = "1.0.86" # remember to update html_root_url
+version = "1.0.96" # 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"
@@ -48,11 +48,7 @@ unstable = []
 # Provide impls for types in the Rust core allocation and collections library
 # including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
 # be enabled without depending on all of std.
-#
-# Requires a dependency on the unstable core allocation library:
-#
-#    https://doc.rust-lang.org/alloc/
-alloc = ["unstable"]
+alloc = []

 # Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
 # does not preserve identity and may result in multiple copies of the same data.
@@ -23,6 +23,12 @@ fn main() {
        println!("cargo:rustc-cfg=collections_bound");
    }

+    // core::cmp::Reverse stabilized in Rust 1.19:
+    // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
+    if minor >= 19 {
+        println!("cargo:rustc-cfg=core_reverse");
+    }
+
    // CString::into_boxed_c_str stabilized in Rust 1.20:
    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
    if minor >= 20 {
@@ -62,6 +68,25 @@ fn main() {
    if minor >= 28 {
        println!("cargo:rustc-cfg=num_nonzero");
    }
+
+    if minor >= 34 {
+        // Whitelist of archs that support std::sync::atomic module. Ideally we
+        // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
+        // Instead this is based on rustc's src/librustc_target/spec/*.rs.
+        let has_atomic64 = target.starts_with("x86_64")
+            || target.starts_with("i686")
+            || target.starts_with("aarch64")
+            || target.starts_with("powerpc64")
+            || target.starts_with("sparc64")
+            || target.starts_with("mips64el");
+        let has_atomic32 = has_atomic64 || emscripten;
+        if has_atomic64 {
+            println!("cargo:rustc-cfg=std_atomic64");
+        }
+        if has_atomic32 {
+            println!("cargo:rustc-cfg=std_atomic");
+        }
+    }
 }

 fn rustc_minor_version() -> Option<u32> {
@@ -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 {
@@ -578,6 +578,9 @@ macro_rules! forwarded_impl {
 #[cfg(all(feature = "std", de_boxed_c_str))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);

+#[cfg(core_reverse)]
+forwarded_impl!((T), Reverse<T>, Reverse);
+
 ////////////////////////////////////////////////////////////////////////////////

 struct OptionVisitor<T> {
@@ -787,7 +790,8 @@ seq_impl!(
    BinaryHeap::clear,
    BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
    BinaryHeap::reserve,
-    BinaryHeap::push);
+    BinaryHeap::push
+);

 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
@@ -796,7 +800,8 @@ seq_impl!(
    BTreeSet::clear,
    BTreeSet::new(),
    nop_reserve,
-    BTreeSet::insert);
+    BTreeSet::insert
+);

 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
@@ -962,7 +967,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
@@ -979,14 +984,12 @@ macro_rules! array_impls {
                where
                    A: SeqAccess<'de>,
                {
-                    $(
-                        let $name = match try!(seq.next_element()) {
+                    Ok([$(
+                        match try!(seq.next_element()) {
                            Some(val) => val,
                            None => return Err(Error::invalid_length($n, &self)),
-                        };
-                    )+
-
-                    Ok([$($name),+])
+                        }
+                    ),+])
                }
            }

@@ -1042,38 +1045,38 @@ macro_rules! array_impls {
 }

 array_impls! {
-    1 => (0 a)
-    2 => (0 a 1 b)
-    3 => (0 a 1 b 2 c)
-    4 => (0 a 1 b 2 c 3 d)
-    5 => (0 a 1 b 2 c 3 d 4 e)
-    6 => (0 a 1 b 2 c 3 d 4 e 5 f)
-    7 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g)
-    8 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h)
-    9 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i)
-    10 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j)
-    11 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
-    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)
+    1 => (0)
+    2 => (0 1)
+    3 => (0 1 2)
+    4 => (0 1 2 3)
+    5 => (0 1 2 3 4)
+    6 => (0 1 2 3 4 5)
+    7 => (0 1 2 3 4 5 6)
+    8 => (0 1 2 3 4 5 6 7)
+    9 => (0 1 2 3 4 5 6 7 8)
+    10 => (0 1 2 3 4 5 6 7 8 9)
+    11 => (0 1 2 3 4 5 6 7 8 9 10)
+    12 => (0 1 2 3 4 5 6 7 8 9 10 11)
+    13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
+    14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
+    15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
+    16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+    17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+    18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
+    19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
+    20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
+    21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
+    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 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
+    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 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 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 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 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 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 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 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 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)
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -2542,3 +2545,31 @@ where
        Deserialize::deserialize(deserializer).map(Wrapping)
    }
 }
+
+#[cfg(all(feature = "std", std_atomic))]
+macro_rules! atomic_impl {
+    ($($ty:ident)*) => {
+        $(
+            impl<'de> Deserialize<'de> for $ty {
+                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                where
+                    D: Deserializer<'de>,
+                {
+                    Deserialize::deserialize(deserializer).map(Self::new)
+                }
+            }
+        )*
+    };
+}
+
+#[cfg(all(feature = "std", std_atomic))]
+atomic_impl! {
+    AtomicBool
+    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
+    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+}
+
+#[cfg(all(feature = "std", std_atomic64))]
+atomic_impl! {
+    AtomicI64 AtomicU64
+}
@@ -59,13 +59,13 @@
 //!    - Box\<T\>
 //!    - Box\<\[T\]\>
 //!    - Box\<str\>
-//!    - Rc\<T\>
-//!    - Arc\<T\>
 //!    - Cow\<'a, T\>
 //!    - Cell\<T\>
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
+//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -1287,10 +1287,40 @@ where
        visitor.visit_map(self.map)
    }

+    fn deserialize_enum<V>(
+        self,
+        _name: &str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::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
+        tuple_struct map struct identifier ignored_any
+    }
+}
+
+impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
+where
+    A: de::MapAccess<'de>,
+{
+    type Error = A::Error;
+    type Variant = private::MapAsEnum<A>;
+
+    fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.map.next_key_seed(seed)? {
+            Some(key) => Ok((key, private::map_as_enum(self.map))),
+            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
+        }
    }
 }

@@ -1299,7 +1329,7 @@ where
 mod private {
    use lib::*;

-    use de::{self, Unexpected};
+    use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};

    #[derive(Clone, Debug)]
    pub struct UnitOnly<E> {
@@ -1360,6 +1390,92 @@ mod private {
        }
    }

+    #[derive(Clone, Debug)]
+    pub struct MapAsEnum<A> {
+        map: A,
+    }
+
+    pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
+        MapAsEnum { map: map }
+    }
+
+    impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
+    where
+        A: MapAccess<'de>,
+    {
+        type Error = A::Error;
+
+        fn unit_variant(mut self) -> Result<(), Self::Error> {
+            self.map.next_value()
+        }
+
+        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
+        where
+            T: DeserializeSeed<'de>,
+        {
+            self.map.next_value_seed(seed)
+        }
+
+        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.map.next_value_seed(SeedTupleVariant {
+                len: len,
+                visitor: visitor,
+            })
+        }
+
+        fn struct_variant<V>(
+            mut self,
+            _fields: &'static [&'static str],
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.map
+                .next_value_seed(SeedStructVariant { visitor: visitor })
+        }
+    }
+
+    struct SeedTupleVariant<V> {
+        len: usize,
+        visitor: V,
+    }
+
+    impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
+    where
+        V: Visitor<'de>,
+    {
+        type Value = V::Value;
+
+        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_tuple(self.len, self.visitor)
+        }
+    }
+
+    struct SeedStructVariant<V> {
+        visitor: V,
+    }
+
+    impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
+    where
+        V: Visitor<'de>,
+    {
+        type Value = V::Value;
+
+        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_map(self.visitor)
+        }
+    }
+
    /// Avoid having to restate the generic types on `MapDeserializer`. The
    /// `Iterator::Item` contains enough information to figure out K and V.
    pub trait Pair {
@@ -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::*;
@@ -1,13 +1,13 @@
 /// Conditional compilation depending on whether Serde is built with support for
 /// 128-bit integers.
 ///
-/// Data formats that wish to support Rust compiler versions older than 1.26 may
-/// place the i128 / u128 methods of their Serializer and Deserializer behind
-/// this macro.
+/// Data formats that wish to support Rust compiler versions older than 1.26
+/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
+/// of their Serializer and Deserializer behind this macro.
 ///
-/// Data formats that require a minimum Rust compiler version of at least 1.26
-/// do not need to bother with this macro and may assume support for 128-bit
-/// integers.
+/// Data formats that require a minimum Rust compiler version of at least 1.26,
+/// or do not target platforms that lack 128-bit integers, do not need to
+/// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
 /// # use serde::private::ser::Error;
@@ -46,7 +46,6 @@
 //! - [BSON], the data storage and network transfer format used by MongoDB.
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
-//! - [Hjson], a variant of JSON designed to be readable and writable by humans.
 //! - [JSON5], A superset of JSON including some productions from ES5.
 //! - [URL], the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
@@ -64,7 +63,6 @@
 //! [RON]: https://github.com/ron-rs/ron
 //! [BSON]: https://github.com/zonyitoo/bson-rs
 //! [Avro]: https://github.com/flavray/avro-rs
-//! [Hjson]: https://github.com/laktak/hjson-rust
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
 //! [URL]: https://github.com/nox/serde_urlencoded
 //! [Envy]: https://github.com/softprops/envy
@@ -75,7 +73,7 @@
 ////////////////////////////////////////////////////////////////////////////////

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.86")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.96")]
 // 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
@@ -83,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
@@ -91,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,
@@ -155,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;
@@ -202,17 +200,28 @@ mod lib {
    #[cfg(feature = "std")]
    pub use std::time::{SystemTime, UNIX_EPOCH};

-    #[cfg(any(core_duration, feature = "std"))]
-    pub use self::core::time::Duration;
+    #[cfg(all(feature = "std", collections_bound))]
+    pub use std::collections::Bound;
+
+    #[cfg(core_reverse)]
+    pub use self::core::cmp::Reverse;
+
+    #[cfg(ops_bound)]
+    pub use self::core::ops::Bound;

    #[cfg(range_inclusive)]
    pub use self::core::ops::RangeInclusive;

-    #[cfg(all(feature = "std", collections_bound))]
-    pub use std::collections::Bound;
+    #[cfg(all(feature = "std", std_atomic))]
+    pub use std::sync::atomic::{
+        AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+        AtomicUsize, Ordering,
+    };
+    #[cfg(all(feature = "std", std_atomic64))]
+    pub use std::sync::atomic::{AtomicI64, AtomicU64};

-    #[cfg(ops_bound)]
-    pub use self::core::ops::Bound;
+    #[cfg(any(core_duration, feature = "std"))]
+    pub use self::core::time::Duration;
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -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)),
            }
        }
@@ -2709,7 +2711,7 @@ where
        }

        Err(Error::custom(format_args!(
-            "no variant of enum {} not found in flattened data",
+            "no variant of enum {} found in flattened data",
            name
        )))
    }
@@ -160,10 +160,12 @@ macro_rules! array_impls {
    }
 }

-array_impls!(01 02 03 04 05 06 07 08 09 10
-             11 12 13 14 15 16 17 18 19 20
-             21 22 23 24 25 26 27 28 29 30
-             31 32);
+array_impls! {
+    01 02 03 04 05 06 07 08 09 10
+    11 12 13 14 15 16 17 18 19 20
+    21 22 23 24 25 26 27 28 29 30
+    31 32
+}

 ////////////////////////////////////////////////////////////////////////////////

@@ -618,6 +620,7 @@ impl Serialize for SystemTime {
 #[cfg(feature = "std")]
 macro_rules! serialize_display_bounded_length {
    ($value:expr, $max:expr, $serializer:expr) => {{
+        #[allow(deprecated)]
        let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
        let remaining_len = {
            let mut remaining = &mut buffer[..];
@@ -822,3 +825,47 @@ where
        self.0.serialize(serializer)
    }
 }
+
+#[cfg(core_reverse)]
+impl<T> Serialize for Reverse<T>
+where
+    T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(all(feature = "std", std_atomic))]
+macro_rules! atomic_impl {
+    ($($ty:ident)*) => {
+        $(
+            impl Serialize for $ty {
+                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    self.load(Ordering::SeqCst).serialize(serializer)
+                }
+            }
+        )*
+    }
+}
+
+#[cfg(all(feature = "std", std_atomic))]
+atomic_impl! {
+    AtomicBool
+    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
+    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+}
+
+#[cfg(all(feature = "std", std_atomic64))]
+atomic_impl! {
+    AtomicI64 AtomicU64
+}
@@ -56,13 +56,13 @@
 //!    - PhantomData\<T\>
 //!  - **Wrapper types**:
 //!    - Box\<T\>
-//!    - Rc\<T\>
-//!    - Arc\<T\>
 //!    - Cow\<'a, T\>
 //!    - Cell\<T\>
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
+//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -1,8 +1,8 @@
 [package]
 name = "serde_derive"
-version = "1.0.86" # remember to update html_root_url
+version = "1.0.96" # 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"
@@ -27,15 +27,16 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
    let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
    let body = Stmts(deserialize_body(&cont, &params));
    let delife = params.borrowed.de_lifetime();
+    let serde = cont.attrs.serde_path();

    let impl_block = if let Some(remote) = cont.attrs.remote() {
        let vis = &input.vis;
        let used = pretend::pretend_used(&cont);
        quote! {
            impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<#remote #ty_generics, __D::Error>
+                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<#remote #ty_generics, __D::Error>
                where
-                    __D: _serde::Deserializer<#delife>,
+                    __D: #serde::Deserializer<#delife>,
                {
                    #used
                    #body
@@ -47,10 +48,10 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream

        quote! {
            #[automatically_derived]
-            impl #de_impl_generics _serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+            impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
+                fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<Self, __D::Error>
                where
-                    __D: _serde::Deserializer<#delife>,
+                    __D: #serde::Deserializer<#delife>,
                {
                    #body
                }
@@ -60,7 +61,12 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
        }
    };

-    Ok(dummy::wrap_in_const("DESERIALIZE", ident, impl_block))
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "DESERIALIZE",
+        ident,
+        impl_block,
+    ))
 }

 fn precondition(cx: &Ctxt, cont: &Container) {
@@ -2053,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);
@@ -2384,7 +2390,12 @@ fn deserialize_map(
                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                    quote!({
                        #wrapper
-                        try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
+                        match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
+                            _serde::export::Ok(__wrapper) => __wrapper.value,
+                            _serde::export::Err(__err) => {
+                                return _serde::export::Err(__err);
+                            }
+                        }
                    })
                }
            };
@@ -2451,7 +2462,7 @@ fn deserialize_map(

    let extract_collected = fields_names
        .iter()
-        .filter(|&&(field, _)| field.attrs.flatten())
+        .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
        .map(|&(field, ref name)| {
            let field_ty = field.ty;
            let func = match field.attrs.deserialize_with() {
@@ -2471,7 +2482,9 @@ fn deserialize_map(

    let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
        Some(quote! {
-            if let _serde::export::Some(_serde::export::Some((__key, _))) = __collect.into_iter().filter(|x| x.is_some()).next() {
+            if let _serde::export::Some(_serde::export::Some((__key, _))) =
+                __collect.into_iter().filter(_serde::export::Option::is_some).next()
+            {
                if let _serde::export::Some(__key) = __key.as_str() {
                    return _serde::export::Err(
                        _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
@@ -2615,7 +2628,12 @@ fn deserialize_map_in_place(
                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                    quote!({
                        #wrapper
-                        self.place.#member = try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
+                        self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
+                            _serde::export::Ok(__wrapper) => __wrapper.value,
+                            _serde::export::Err(__err) => {
+                                return _serde::export::Err(__err);
+                            }
+                        };
                    })
                }
            };
@@ -1,8 +1,14 @@
 use proc_macro2::{Ident, Span, TokenStream};

+use syn;
 use try;

-pub fn wrap_in_const(trait_: &str, ty: &Ident, code: TokenStream) -> TokenStream {
+pub fn wrap_in_const(
+    serde_path: Option<&syn::Path>,
+    trait_: &str,
+    ty: &Ident,
+    code: TokenStream,
+) -> TokenStream {
    let try_replacement = try::replacement();

    let dummy_const = Ident::new(
@@ -10,13 +16,22 @@ pub fn wrap_in_const(trait_: &str, ty: &Ident, code: TokenStream) -> TokenStream
        Span::call_site(),
    );

-    quote! {
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
+    let use_serde = match serde_path {
+        Some(path) => quote! {
+            use #path as _serde;
+        },
+        None => quote! {
            #[allow(unknown_lints)]
            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
            #[allow(rust_2018_idioms)]
            extern crate serde as _serde;
+        },
+    };
+
+    quote! {
+        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+        const #dummy_const: () = {
+            #use_serde
            #try_replacement
            #code
        };
@@ -1,6 +1,7 @@
 use internals::Ctxt;
 use proc_macro2::{Group, Span, TokenStream, TokenTree};
 use quote::ToTokens;
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use syn;
@@ -218,6 +219,7 @@ pub struct Container {
    remote: Option<syn::Path>,
    identifier: Identifier,
    has_flatten: bool,
+    serde_path: Option<syn::Path>,
 }

 /// Styles of representing an enum.
@@ -298,6 +300,7 @@ impl Container {
        let mut remote = Attr::none(cx, "remote");
        let mut field_identifier = BoolAttr::none(cx, "field_identifier");
        let mut variant_identifier = BoolAttr::none(cx, "variant_identifier");
+        let mut serde_path = Attr::none(cx, "crate");

        for meta_items in item.attrs.iter().filter_map(get_serde_meta_items) {
            for meta_item in meta_items {
@@ -582,6 +585,13 @@ impl Container {
                        variant_identifier.set_true(word);
                    }

+                    // Parse `#[serde(crate = "foo")]`
+                    Meta(NameValue(ref m)) if m.ident == "crate" => {
+                        if let Ok(path) = parse_lit_into_path(cx, &m.ident, &m.lit) {
+                            serde_path.set(&m.ident, path)
+                        }
+                    }
+
                    Meta(ref meta_item) => {
                        cx.error_spanned_by(
                            meta_item.name(),
@@ -613,6 +623,7 @@ impl Container {
            remote: remote.get(),
            identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
            has_flatten: false,
+            serde_path: serde_path.get(),
        }
    }

@@ -671,6 +682,15 @@ impl Container {
    pub fn mark_has_flatten(&mut self) {
        self.has_flatten = true;
    }
+
+    pub fn custom_serde_path(&self) -> Option<&syn::Path> {
+        self.serde_path.as_ref()
+    }
+
+    pub fn serde_path(&self) -> Cow<syn::Path> {
+        self.custom_serde_path()
+            .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
+    }
 }

 fn decide_tag(
@@ -76,25 +76,6 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
        }
        _ => {}
    }
-    if field.attrs.skip_serializing() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_serializing)]",
-        );
-    } else if field.attrs.skip_serializing_if().is_some() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_serializing_if = \"...\")]",
-        );
-    } else if field.attrs.skip_deserializing() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_deserializing)]",
-        );
-    }
 }

 /// The `other` attribute must be used at most once and it must be the last
@@ -13,14 +13,15 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.86")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.96")]
+#![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
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
-        cyclomatic_complexity,
+        cognitive_complexity,
        enum_variant_names,
        needless_pass_by_value,
        redundant_field_names,
@@ -34,6 +35,7 @@
    feature = "cargo-clippy",
    allow(
        cast_possible_truncation,
+        checked_conversions,
        doc_markdown,
        enum_glob_use,
        filter_map,
@@ -22,15 +22,16 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
    let params = Parameters::new(&cont);
    let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
    let body = Stmts(serialize_body(&cont, &params));
+    let serde = cont.attrs.serde_path();

    let impl_block = if let Some(remote) = cont.attrs.remote() {
        let vis = &input.vis;
        let used = pretend::pretend_used(&cont);
        quote! {
            impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
                where
-                    __S: _serde::Serializer,
+                    __S: #serde::Serializer,
                {
                    #used
                    #body
@@ -40,10 +41,10 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
    } else {
        quote! {
            #[automatically_derived]
-            impl #impl_generics _serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
                where
-                    __S: _serde::Serializer,
+                    __S: #serde::Serializer,
                {
                    #body
                }
@@ -51,7 +52,12 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
        }
    };

-    Ok(dummy::wrap_in_const("SERIALIZE", ident, impl_block))
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "SERIALIZE",
+        ident,
+        impl_block,
+    ))
 }

 fn precondition(cx: &Ctxt, cont: &Container) {
@@ -289,37 +295,38 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
    }
 }

+fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTrait) -> TokenStream {
+    match *cattrs.tag() {
+        attr::TagType::Internal { ref tag } => {
+            let type_name = cattrs.name().serialize_name();
+            let func = struct_trait.serialize_field(Span::call_site());
+            quote! {
+                try!(#func(&mut __serde_state, #tag, #type_name));
+            }
+        }
+        _ => quote! {},
+    }
+}
+
 fn serialize_struct_as_struct(
    params: &Parameters,
    fields: &[Field],
    cattrs: &attr::Container,
 ) -> Fragment {
-    let mut serialize_fields =
+    let serialize_fields =
        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeStruct);

    let type_name = cattrs.name().serialize_name();

-    let additional_field_count: usize = match *cattrs.tag() {
-        attr::TagType::Internal { ref tag } => {
-            let func = StructTrait::SerializeStruct.serialize_field(Span::call_site());
-            serialize_fields.insert(
-                0,
-                quote! {
-                    try!(#func(&mut __serde_state, #tag, #type_name));
-                },
-            );
-
-            1
-        }
-        _ => 0,
-    };
+    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeStruct);
+    let tag_field_exists = !tag_field.is_empty();

    let mut serialized_fields = fields
        .iter()
        .filter(|&field| !field.attrs.skip_serializing())
        .peekable();

-    let let_mut = mut_if(serialized_fields.peek().is_some() || additional_field_count > 0);
+    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);

    let len = serialized_fields
        .map(|field| match field.attrs.skip_serializing_if() {
@@ -330,12 +337,13 @@ fn serialize_struct_as_struct(
            }
        })
        .fold(
-            quote!(#additional_field_count),
+            quote!(#tag_field_exists as usize),
            |sum, expr| quote!(#sum + #expr),
        );

    quote_block! {
        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len));
+        #tag_field
        #(#serialize_fields)*
        _serde::ser::SerializeStruct::end(__serde_state)
    }
@@ -349,12 +357,15 @@ fn serialize_struct_as_map(
    let serialize_fields =
        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);

+    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeMap);
+    let tag_field_exists = !tag_field.is_empty();
+
    let mut serialized_fields = fields
        .iter()
        .filter(|&field| !field.attrs.skip_serializing())
        .peekable();

-    let let_mut = mut_if(serialized_fields.peek().is_some());
+    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);

    let len = if cattrs.has_flatten() {
        quote!(_serde::export::None)
@@ -367,12 +378,16 @@ fn serialize_struct_as_map(
                    quote!(if #path(#field_expr) { 0 } else { 1 })
                }
            })
-            .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+            .fold(
+                quote!(#tag_field_exists as usize),
+                |sum, expr| quote!(#sum + #expr),
+            );
        quote!(_serde::export::Some(#len))
    };

    quote_block! {
        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
+        #tag_field
        #(#serialize_fields)*
        _serde::ser::SerializeMap::end(__serde_state)
    }
@@ -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"
@@ -1,9 +1,10 @@
 #![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",
    allow(
-        cyclomatic_complexity,
+        cognitive_complexity,
        redundant_field_names,
        trivially_copy_pass_by_ref
    )
@@ -1,8 +1,8 @@
 [package]
 name = "serde_test"
-version = "1.0.86" # remember to update html_root_url
+version = "1.0.96" # 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"
@@ -144,7 +144,7 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.86")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.96")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
@@ -7,14 +7,15 @@ publish = false

 [features]
 unstable = ["serde/unstable"]
-compiletest = ["compiletest_rs"]
+
+[dependencies]
+serde = { path = "../serde" }

 [dev-dependencies]
 fnv = "1.0"
 rustc-serialize = "0.3.16"
+rustversion = "0.1"
 serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
-
-[dependencies]
-compiletest_rs = { version = "0.3", optional = true, features = ["stable"] }
+trybuild = "1.0"
@@ -1,11 +0,0 @@
-[package]
-name = "serde_test_suite_deps"
-version = "0.0.0"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-publish = false
-
-[workspace]
-
-[dependencies]
-serde = { path = "../../serde" }
-serde_derive = { path = "../../serde_derive" }
@@ -1,3 +0,0 @@
-#![feature(/*=============================================]
-#![===  Serde test suite requires a nightly compiler.  ===]
-#![====================================================*/)]
@@ -1,20 +1,7 @@
-#![cfg(feature = "compiletest")]
-
-use compiletest_rs as compiletest;
-
+#[cfg(not(target_os = "emscripten"))]
+#[rustversion::attr(not(nightly), ignore)]
 #[test]
 fn ui() {
-    compiletest::run_tests(&compiletest::Config {
-        mode: compiletest::common::Mode::Ui,
-        src_base: std::path::PathBuf::from("tests/ui"),
-        target_rustcflags: Some(String::from(
-            "\
-             --edition=2018 \
-             -L deps/target/debug/deps \
-             -Z unstable-options \
-             --extern serde_derive \
-             ",
-        )),
-        ..Default::default()
-    });
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
 }
@@ -1,18 +1,27 @@
-#![allow(clippy::decimal_literal_representation)]
+#![allow(clippy::decimal_literal_representation, clippy::unreadable_literal)]
 #![cfg_attr(feature = "unstable", feature(never_type))]

 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::default::Default;
 use std::ffi::{CStr, CString, OsString};
+use std::fmt::Debug;
 use std::net;
 use std::num::Wrapping;
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
+use std::sync::atomic::{
+    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+    AtomicUsize, Ordering,
+};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};

+#[cfg(target_arch = "x86_64")]
+use std::sync::atomic::{AtomicI64, AtomicU64};
+
 use fnv::FnvHasher;
+use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Configure, Token};

@@ -124,6 +133,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 +951,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! {
@@ -1112,6 +1149,45 @@ fn test_never_type() {
    );
 }

+#[test]
+fn test_atomics() {
+    fn test<L, A, T>(load: L, val: T, token: Token)
+    where
+        L: Fn(&A, Ordering) -> T,
+        A: DeserializeOwned,
+        T: PartialEq + Debug,
+    {
+        let tokens = &[token];
+        let mut de = serde_test::Deserializer::new(tokens);
+        match A::deserialize(&mut de) {
+            Ok(v) => {
+                let loaded = load(&v, Ordering::SeqCst);
+                assert_eq!(val, loaded);
+            }
+            Err(e) => panic!("tokens failed to deserialize: {}", e),
+        };
+        if de.remaining() > 0 {
+            panic!("{} remaining tokens", de.remaining());
+        }
+    }
+
+    test(AtomicBool::load, true, Token::Bool(true));
+    test(AtomicI8::load, -127, Token::I8(-127i8));
+    test(AtomicI16::load, -510, Token::I16(-510i16));
+    test(AtomicI32::load, -131072, Token::I32(-131072i32));
+    test(AtomicIsize::load, -131072isize, Token::I32(-131072));
+    test(AtomicU8::load, 127, Token::U8(127u8));
+    test(AtomicU16::load, 510u16, Token::U16(510u16));
+    test(AtomicU32::load, 131072u32, Token::U32(131072u32));
+    test(AtomicUsize::load, 131072usize, Token::U32(131072));
+
+    #[cfg(target_arch = "x86_64")]
+    {
+        test(AtomicI64::load, -8589934592, Token::I64(-8589934592));
+        test(AtomicU64::load, 8589934592u64, Token::U64(8589934592));
+    }
+}
+
 declare_error_tests! {
    test_unknown_field<StructDenyUnknown> {
        &[
@@ -265,7 +265,7 @@ fn test_gen() {
    #[cfg(feature = "unstable")]
    #[derive(Serialize, Deserialize)]
    struct NonAsciiIdents {
-        σ: f64,
+        σ:  f64,
    }

    #[derive(Serialize, Deserialize)]
@@ -522,6 +522,13 @@ fn test_gen() {
    }
    assert::<FlattenWith>();

+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct FlattenDenyUnknown<T> {
+        #[serde(flatten)]
+        t: T,
+    }
+
    #[derive(Serialize, Deserialize)]
    struct StaticStrStruct<'a> {
        a: &'a str,
@@ -665,6 +672,25 @@ fn test_gen() {
        ty: &'a str,
        id: String,
    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipSerializing<T> {
+        #[serde(flatten, skip_serializing)]
+        #[allow(dead_code)]
+        flat: T,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipSerializingIf<T> {
+        #[serde(flatten, skip_serializing_if = "StdOption::is_none")]
+        flat: StdOption<T>,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipDeserializing<T> {
+        #[serde(flatten, skip_deserializing)]
+        flat: T,
+    }
 }

 //////////////////////////////////////////////////////////////////////////
@@ -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();
+}
@@ -1424,6 +1424,76 @@ fn test_internally_tagged_braced_struct_with_zero_fields() {
    );
 }

+#[test]
+fn test_internally_tagged_struct_with_flattened_field() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag_struct")]
+    pub struct Struct {
+        #[serde(flatten)]
+        pub flat: Enum,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag_enum", content = "content")]
+    pub enum Enum {
+        A(u64),
+    }
+
+    assert_tokens(
+        &Struct { flat: Enum::A(0) },
+        &[
+            Token::Map { len: None },
+            Token::Str("tag_struct"),
+            Token::Str("Struct"),
+            Token::Str("tag_enum"),
+            Token::Str("A"),
+            Token::Str("content"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Struct { flat: Enum::A(0) },
+        &[
+            Token::Map { len: None },
+            Token::Str("tag_enum"),
+            Token::Str("A"),
+            Token::Str("content"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[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)]
@@ -1,3 +1,4 @@
+#![allow(clippy::unreadable_literal)]
 #![cfg_attr(feature = "unstable", feature(never_type))]

 use std::cell::RefCell;
@@ -9,11 +10,17 @@ use std::num::Wrapping;
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
+use std::sync::atomic::{
+    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+    AtomicUsize,
+};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};

 #[cfg(unix)]
 use std::str;
+#[cfg(target_arch = "x86_64")]
+use std::sync::atomic::{AtomicI64, AtomicU64};

 use fnv::FnvHasher;
 use serde::Serialize;
@@ -483,6 +490,26 @@ declare_tests! {
            Token::Str("1a"),
        ],
    }
+    test_atomic {
+        AtomicBool::new(false) => &[Token::Bool(false)],
+        AtomicBool::new(true) => &[Token::Bool(true)],
+        AtomicI8::new(63i8) => &[Token::I8(63i8)],
+        AtomicI16::new(-318i16) => &[Token::I16(-318i16)],
+        AtomicI32::new(65792i32) => &[Token::I32(65792i32)],
+        AtomicIsize::new(-65792isize) => &[Token::I64(-65792i64)],
+        AtomicU8::new(192u8) => &[Token::U8(192u8)],
+        AtomicU16::new(510u16) => &[Token::U16(510u16)],
+        AtomicU32::new(131072u32) => &[Token::U32(131072u32)],
+        AtomicUsize::new(655360usize) => &[Token::U64(655360u64)],
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+declare_tests! {
+    test_atomic64 {
+        AtomicI64::new(-4295032832i64) => &[Token::I64(-4295032832i64)],
+        AtomicU64::new(12884901888u64) => &[Token::U64(12884901888u64)],
+    }
 }

 declare_tests! {
@@ -0,0 +1,40 @@
+#[test]
+fn test_gen_custom_serde() {
+    #[derive(serde::Serialize, serde::Deserialize)]
+    #[serde(crate = "fake_serde")]
+    struct Foo;
+
+    // Would be overlapping if serde::Serialize were implemented
+    impl AssertNotSerdeSerialize for Foo {}
+    // Would be overlapping if serde::Deserialize were implemented
+    impl<'a> AssertNotSerdeDeserialize<'a> for Foo {}
+
+    fake_serde::assert::<Foo>();
+}
+
+mod fake_serde {
+    pub use serde::*;
+
+    pub fn assert<T>()
+    where
+        T: Serialize,
+        T: for<'a> Deserialize<'a>,
+    {
+    }
+
+    pub trait Serialize {
+        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
+    }
+
+    pub trait Deserialize<'a>: Sized {
+        fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>;
+    }
+}
+
+trait AssertNotSerdeSerialize {}
+
+impl<T: serde::Serialize> AssertNotSerdeSerialize for T {}
+
+trait AssertNotSerdeDeserialize<'a> {}
+
+impl<'a, T: serde::Deserialize<'a>> AssertNotSerdeDeserialize<'a> for T {}
@@ -1,5 +1,8 @@
-use serde::de::{value, IntoDeserializer};
-use serde::Deserialize;
+use serde::de::value::{self, MapAccessDeserializer};
+use serde::de::{IntoDeserializer, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer};
+use serde_test::{assert_de_tokens, Token};
+use std::fmt;

 #[test]
 fn test_u32_to_enum() {
@@ -32,3 +35,60 @@ fn test_integer128() {
    // i128 to i128
    assert_eq!(1i128, i128::deserialize(de_i128).unwrap());
 }
+
+#[test]
+fn test_map_access_to_enum() {
+    #[derive(PartialEq, Debug)]
+    struct Potential(PotentialKind);
+
+    #[derive(PartialEq, Debug, Deserialize)]
+    enum PotentialKind {
+        Airebo(Airebo),
+    }
+
+    #[derive(PartialEq, Debug, Deserialize)]
+    struct Airebo {
+        lj_sigma: f64,
+    }
+
+    impl<'de> Deserialize<'de> for Potential {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct PotentialVisitor;
+
+            impl<'de> Visitor<'de> for PotentialVisitor {
+                type Value = Potential;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    write!(formatter, "a map")
+                }
+
+                fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+                where
+                    A: MapAccess<'de>,
+                {
+                    Deserialize::deserialize(MapAccessDeserializer::new(map)).map(Potential)
+                }
+            }
+
+            deserializer.deserialize_any(PotentialVisitor)
+        }
+    }
+
+    let expected = Potential(PotentialKind::Airebo(Airebo { lj_sigma: 14.0 }));
+
+    assert_de_tokens(
+        &expected,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("Airebo"),
+            Token::Map { len: Some(1) },
+            Token::Str("lj_sigma"),
+            Token::F64(14.0),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+}
@@ -3,6 +3,3 @@ error: failed to parse borrowed lifetimes: "zzz"
  |
 5 |     #[serde(borrow = "zzz")]
  |                      ^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate borrowed lifetime `'a`
  |
 5 |     #[serde(borrow = "'a + 'a")]
  |                      ^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `borrow`
  |
 8 |     #[serde(borrow)]
  |             ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: at least one lifetime must be borrowed
  |
 5 |     #[serde(borrow = "")]
  |                      ^^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: field `s` has no lifetimes to borrow
 5 | /     #[serde(borrow)]
 6 | |     s: String,
  | |_____________^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: #[serde(borrow)] may only be used on newtype variants
 8 | /     #[serde(borrow)]
 9 | |     S { s: Str<'a> },
  | |____________________^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: field `s` does not have lifetime 'b
 5 | /     #[serde(borrow = "'b")]
 6 | |     s: &'a str,
  | |______________^
-
-error: aborting due to previous error
-
@@ -7,6 +7,3 @@ error: enum tags `conflict` for type and content conflict with each other
 7 | |     B,
 8 | | }
  | |_^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(flatten)] cannot be used on newtype structs
  |
 6 | struct Foo(#[serde(flatten)] HashMap<String, String>);
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -1,14 +0,0 @@
-use serde_derive::Deserialize;
-
-#[derive(Deserialize)]
-struct Foo {
-    #[serde(flatten, skip_deserializing)]
-    other: Other,
-}
-
-#[derive(Deserialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}
@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_deserializing)]
- --> $DIR/flatten-skip-deserializing.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_deserializing)]
-6 | |     other: Other,
-  | |________________^
-
-error: aborting due to previous error
-
@@ -1,14 +0,0 @@
-use serde_derive::Serialize;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing_if = "Option::is_none")]
-    other: Option<Other>,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}
@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_serializing_if = "...")]
- --> $DIR/flatten-skip-serializing-if.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_serializing_if = "Option::is_none")]
-6 | |     other: Option<Other>,
-  | |________________________^
-
-error: aborting due to previous error
-
@@ -1,14 +0,0 @@
-use serde_derive::Serialize;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing)]
-    other: Other,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}
@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_serializing)]
- --> $DIR/flatten-skip-serializing.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_serializing)]
-6 | |     other: Other,
-  | |________________^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(flatten)] cannot be used on tuple structs
  |
 6 | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
  |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -9,6 +9,3 @@ error: variant field name `conflict` conflicts with internal tag
 9  | |     },
 10 | | }
   | |_^
-
-error: aborting due to previous error
-
@@ -9,6 +9,3 @@ error: variant field name `conflict` conflicts with internal tag
 9  | |     },
 10 | | }
   | |_^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(default)] can only be used on structs with named fields
  |
 5 | enum E {
  | ^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(default = "...")] can only be used on structs with named fields
  |
 5 | enum E {
  | ^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(default)] can only be used on structs with named fields
  |
 5 | struct T(u8, u8);
  |         ^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(default = "...")] can only be used on structs with named fields
  |
 5 | struct T(u8, u8);
  |         ^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: unknown serde field attribute `serialize`
  |
 5 |     #[serde(rename = "x", serialize = "y")]
  |                           ^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
  |
 5 |     #[serde(rename(serialize = "x"), rename(serialize = "y"))]
  |                                      ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
  |
 6 |     #[serde(rename = "y")]
  |             ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
  |
 5 |     #[serde(rename(serialize = "x", serialize = "y"))]
  |                                     ^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
  |
 6 |     #[serde(rename(serialize = "y"))]
  |             ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: duplicate serde attribute `serialize_with`
  |
 5 |     #[serde(with = "w", serialize_with = "s")]
  |                         ^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(tag = "...", content = "...")] must be used together
  |
 4 | #[serde(content = "c")]
  |         ^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(tag = "...")] cannot be used with tuple variants
  |
 6 |     Tuple(u8, u8),
  |     ^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -15,6 +15,3 @@ error: untagged enum cannot have #[serde(tag = "...", content = "...")]
  |
 5 | #[serde(tag = "t", content = "c")]
  |                    ^^^^^^^
-
-error: aborting due to 3 previous errors
-
@@ -9,6 +9,3 @@ error: untagged enum cannot have #[serde(content = "...")]
  |
 5 | #[serde(content = "c")]
  |         ^^^^^^^
-
-error: aborting due to 2 previous errors
-
@@ -9,6 +9,3 @@ error: enum cannot be both untagged and internally tagged
  |
 5 | #[serde(tag = "type")]
  |         ^^^
-
-error: aborting due to 2 previous errors
-
@@ -3,6 +3,3 @@ error: #[serde(untagged)] can only be used on enums
  |
 5 | struct S;
  | ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = true)]
  |                      ^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = b'a')]
  |                      ^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = b"byte string")]
  |                      ^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = 'a')]
  |                      ^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = 3.14)]
  |                      ^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
  |
 5 |     #[serde(rename = 100)]
  |                      ^^^
-
-error: aborting due to previous error
-
@@ -9,6 +9,3 @@ error: #[serde(field_identifier)] and #[serde(variant_identifier)] cannot both b
  |
 4 | #[serde(field_identifier, variant_identifier)]
  |                           ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
@@ -3,6 +3,3 @@ error: #[serde(field_identifier)] can only be used on an enum
  |
 5 | struct S;
  | ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(field_identifier)] may only contain unit variants
  |
 7 |     B(u8, u8),
  |     ^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: `Other` must be the last variant
  |
 7 |     Other(String),
  |     ^^^^^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: #[serde(other)] must be on a unit variant
 7 | /     #[serde(other)]
 8 | |     Other(u8, u8),
  | |_________________^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: #[serde(other)] must be on the last variant
 7 | /     #[serde(other)]
 8 | |     Other,
  | |_________^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: #[serde(other)] cannot appear on untagged enum
 6 | /     #[serde(other)]
 7 | |     Other,
  | |_________^
-
-error: aborting due to previous error
-
@@ -4,6 +4,3 @@ error: #[serde(other)] may not be used on a variant identifier
 6 | /     #[serde(other)]
 7 | |     Other,
  | |_________^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(variant_identifier)] can only be used on an enum
  |
 5 | struct S;
  | ^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: #[serde(variant_identifier)] may only contain unit variants
  |
 7 |     B(u8, u8),
  |     ^^^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: malformed bound attribute, expected `bound(serialize = ..., deserialize =
  |
 5 |     #[serde(bound(unknown))]
  |                   ^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: malformed rename attribute, expected `rename(serialize = ..., deserialize
  |
 5 |     #[serde(rename(unknown))]
  |                    ^^^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: cannot deserialize when there is a lifetime parameter called 'de
  |
 4 | struct S<'de> {
  |          ^^^
-
-error: aborting due to previous error
-
@@ -6,6 +6,3 @@ error: cannot deserialize a dynamically sized struct
 6 | |     slice: [u8],
 7 | | }
  | |_^
-
-error: aborting due to previous error
-
@@ -7,6 +7,3 @@ error: field identifiers cannot be serialized
 7 | |     B,
 8 | | }
  | |_^
-
-error: aborting due to previous error
-
@@ -7,6 +7,3 @@ error: variant identifiers cannot be serialized
 7 | |     B,
 8 | | }
  | |_^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: failed to parse path: "~~~"
   |
 12 |     #[serde(getter = "~~~")]
   |                      ^^^^^
-
-error: aborting due to previous error
-
@@ -3,6 +3,3 @@ error: failed to parse path: "~~~"
   |
 10 | #[serde(remote = "~~~")]
   |                  ^^^^^
-
-error: aborting due to previous error
-
@@ -9,6 +9,3 @@ error: #[serde(getter = "...")] is not allowed in an enum
 15 | |     },
 16 | | }
   | |_^
-
-error: aborting due to previous error
-
@@ -4,6 +4,4 @@ error[E0063]: missing field `b` in initializer of `remote::S`
 11 | #[serde(remote = "remote::S")]
   |                  ^^^^^^^^^^^ missing `b`

-error: aborting due to previous error
-
 For more information about this error, try `rustc --explain E0063`.
@@ -6,6 +6,3 @@ error: #[serde(getter = "...")] can only be used in structs that have #[serde(re
 6 | |     a: u8,
 7 | | }
  | |_^
-
-error: aborting due to previous error
-
@@ -10,7 +10,5 @@ error[E0560]: struct `remote::S` has no field named `b`
 12 |     b: u8,
   |     ^ help: a field with a similar name exists: `a`

-error: aborting due to 2 previous errors
-
-Some errors occurred: E0560, E0609.
+Some errors have detailed explanations: E0560, E0609.
 For more information about an error, try `rustc --explain E0560`.
@@ -3,11 +3,5 @@ error[E0308]: mismatched types
  |
 7 | #[derive(Deserialize)]
  |          ^^^^^^^^^^^ expected u16, found u8
-help: you can cast an `u8` to `u16`, which will zero-extend the source value
-  |
-7 | #[derive(Deserialize.into())]
-  |          ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error

 For more information about this error, try `rustc --explain E0308`.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Tolnay	cf32a5b204	Release 1.0.96	2019-07-17 12:04:19 -07:00
David Tolnay	7b0e06c825	Provide 32 bit atomic impls for emscripten	2019-07-17 11:44:24 -07:00
David Tolnay	3158bf9093	Merge pull request #1581 from Roguelazer/issue-1579 conservatively limit atomic features	2019-07-17 11:01:21 -07:00
James Brown	01fade764c	replaced one too many _ with -	2019-07-17 09:57:53 -07:00
James Brown	210c2419be	conservatively limit atomic features	2019-07-17 09:19:03 -07:00
David Tolnay	da05163d51	Release 1.0.95	2019-07-16 10:08:53 -07:00
David Tolnay	f3e2bb5104	Disable 64 bit atomic tests on emscripten	2019-07-16 10:00:44 -07:00
David Tolnay	7a4c1086b5	Emscripten does not have 64 bit atomics	2019-07-16 09:57:00 -07:00
David Tolnay	e89feb9635	Test atomics without needing a macro As a secondary benefit, this avoids a congnitive_complexity lint from Clippy.	2019-07-16 09:17:36 -07:00
David Tolnay	5f72766c27	Ignore unreadable_literal lint in test code	2019-07-16 09:04:43 -07:00
David Tolnay	85ae57040d	One macro to deserialize all atomics	2019-07-16 07:46:44 -07:00
David Tolnay	d55a4a279f	Deserialize atomics without needing element type	2019-07-16 07:45:41 -07:00
David Tolnay	bee9299693	One macro to serialize all atomics	2019-07-16 07:42:42 -07:00
David Tolnay	9529fcec96	Serialize atomics using the primitive's Serialize impl	2019-07-16 07:40:37 -07:00
David Tolnay	bcec168e23	Centralize atomic imports	2019-07-16 07:36:16 -07:00
David Tolnay	102a332616	Format with rustfmt 2019-06-09	2019-07-16 07:32:13 -07:00
David Tolnay	a280942f02	Add a builder on 1.34 to cover atomic types	2019-07-16 07:29:10 -07:00
David Tolnay	637dba5c2a	Merge pull request #1572 from Roguelazer/issue-1496 Implement serialization and deserialization for std::sync::atomic types	2019-07-16 07:28:18 -07:00
David Tolnay	24f292d081	Build alloc feature on 1.36 in travis	2019-07-16 07:22:47 -07:00
David Tolnay	fa5c99e48a	Alloc crate is no longer unstable	2019-07-16 07:21:09 -07:00
David Tolnay	48f1a2c9b2	Merge pull request #1576 from c410-f3r/alloc-feature Make `alloc` feature work on stable	2019-07-16 07:19:49 -07:00
Caio	50ebbd63c6	Enable alloc on stable	2019-07-15 14:24:03 -03:00
James Brown	4e5f63ff45	gate atomic serde on rust 1.34 or higher	2019-07-12 13:44:42 -07:00
James Brown	de709e72a8	implement deserialization for atomic integer types	2019-07-11 18:18:54 -07:00
James Brown	56d3c8f071	implement serialization for atomic integer types	2019-07-11 17:34:53 -07:00
David Tolnay	ce89adecc1	Suppress deprecation warning on mem::uninitialized	2019-07-07 21:19:50 -07:00
David Tolnay	bc7a85063d	Switch to rustversion	2019-07-07 21:14:11 -07:00
David Tolnay	0574f1e020	Merge pull request #1561 from BurntSushi/ag/update-i128-docs Update docs for serde_if_integer128	2019-07-01 15:04:54 -07:00
Andrew Gallant	f9fdd60e2e	Update docs for serde_if_integer128 The docs imply that the only consideration for using the serde_if_integer128 macro is support for older versions of Rust, but Serde's build configuration for 128-bit integers is also gated on the target platform. For example, if Serde is being compiled for an emscripten target, then it will not provide 128-bit integer APIs. See also: https://github.com/BurntSushi/rust-csv/issues/158	2019-07-01 10:18:57 -04:00
David Tolnay	1c1eecabc0	Release 1.0.94	2019-06-27 10:55:12 -07:00
David Tolnay	abd3fd004e	Merge pull request #1559 from dtolnay/ignore-enum Accept enums in IgnoredAny	2019-06-27 10:54:22 -07:00
David Tolnay	15ee353488	IgnoredAny::visit_enum for old compilers	2019-06-27 10:45:18 -07:00
David Tolnay	e75efbfd31	Support ignoring enum with IgnoredAny	2019-06-27 10:29:55 -07:00
David Tolnay	1c97a7ecb3	Add comprehensive test for deserializing IgnoredAny from enum	2019-06-27 10:23:39 -07:00
David Tolnay	fccd3e9fba	Add deserialization tests for IgnoredAny	2019-06-27 10:07:06 -07:00
David Tolnay	4cb13b33e0	Release 1.0.93	2019-06-23 12:50:17 -07:00
David Tolnay	629802f2ab	Merge pull request #1555 from serde-rs/int Allow integer key in untagged flattened map	2019-06-23 12:49:21 -07:00
David Tolnay	afb1754528	Allow integer key in untagged flattened map	2019-06-23 12:09:15 -07:00
David Tolnay	dbd67c6c89	Clippy const_static_lifetime lint has been renamed	2019-06-19 01:34:13 -07:00
David Tolnay	ed01bdb9dd	Remove fixed cast_precision_loss lint	2019-06-15 10:13:05 -07:00
David Tolnay	b54821d8ab	Alloc feature has been stabilized warning: the feature `alloc` has been stable since 1.36.0 and no longer requires an attribute to enable --> serde/src/lib.rs:84:40 \| 84 \| #![cfg_attr(feature = "alloc", feature(alloc))] \| ^^^^^ \| = note: #[warn(stable_features)] on by default	2019-05-31 21:26:43 -07:00
David Tolnay	89c6a79b6e	Suppress a new pedantic lint	2019-05-31 21:25:36 -07:00
David Tolnay	cd0412bddc	Release 1.0.92	2019-05-31 13:44:01 -07:00
David Tolnay	e42262f0f5	Provide ToString for re-export by serde::export	2019-05-31 13:42:22 -07:00
David Tolnay	0a3eeab273	Merge pull request #1543 from jplatte/alloc-de-compile-fix Fix a compile error in derive(Deserialize) with no_std + alloc	2019-05-31 13:41:07 -07:00
Jonas Platte	e4e110e28f	Fix a compile error in derive(Deserialize) with no_std + alloc	2019-05-31 22:16:40 +02:00
David Tolnay	0726623389	Ignore bare_trait_objects lint to support old compilers	2019-05-31 11:34:18 -07:00
David Tolnay	fd9d334d01	Smaller format for license section	2019-05-18 17:35:47 -07:00
David Tolnay	840eb14121	Merge pull request #1528 from est31/no_variable_names Don't use variable names	2019-05-17 08:57:14 -07:00
est31	8fef196ee4	Don't use variable names They aren't needed. This makes the macro a bit simpler	2019-05-17 16:50:41 +02:00
David Tolnay	9c756f1ec0	Disable ui tests on emscripten These hit a strange error in our Emscripten builder in Travis as well as locally through cargo web: ERROR: failed to execute cargo: Resource temporarily unavailable (os error 11)	2019-05-12 00:28:22 -07:00
David Tolnay	6dd2b4607f	Switch to SPDX 2.1 license expression	2019-05-09 15:21:20 -07:00
David Tolnay	1e9ae88f53	Work around "failed to select a version for serde_test_suite" Without this: error: failed to select a version for `serde_test_suite`. ... required by package `serde_test_suite-tests v0.0.0` versions that meet the requirements `= 0.0.0` are: 0.0.0 the package `serde_test_suite-tests` depends on `serde_test_suite`, with features: `serde` but `serde_test_suite` does not have these features. failed to select a version for `serde_test_suite` which could resolve this conflict Seems like a Cargo bug -- I will minimize and report.	2019-05-06 22:53:38 -07:00
David Tolnay	5cc3902ab9	Release 1.0.91	2019-05-06 16:27:04 -07:00
David Tolnay	c8e09e2d6d	Merge pull request #1522 from dtolnay/enum Support deserializing enum out of MapAccessDeserializer	2019-05-06 16:26:43 -07:00
David Tolnay	e2a2ba116c	Remove old instructions intended for compiletest	2019-05-06 16:17:30 -07:00
David Tolnay	0a9d24a218	Support deserializing enum out of MapAccessDeserializer	2019-05-06 16:11:28 -07:00
David Tolnay	c222183669	Merge pull request #1521 from serde-rs/trybuild Switch ui tests to trybuild	2019-05-06 10:44:25 -07:00
David Tolnay	140f9beee7	Switch ui tests to trybuild	2019-05-06 10:25:47 -07:00
David Tolnay	28ce892617	Disable compiletest in appveyor error[E0464]: multiple matching crates for `serde` --> $DIR/wrong_getter.rs:15:10 \| 15 \| #[derive(Serialize)] \| ^^^^^^^^^ \| = note: candidates: crate `serde`: /?/C:/projects/serde/test_suite/deps/target/debug/deps/libserde-a1a28acc73b0edde.rlib crate `serde`: /?/C:/Users/appveyor/.	2019-04-22 23:18:21 -07:00
David Tolnay	1e6d3ff99b	Merge pull request #1512 from dtolnay/off Temporarily disable compiletest testing in CI	2019-04-22 23:05:54 -07:00
David Tolnay	fba1b92cbf	Temporarily disable compiletest testing in CI The nightly compiler just added a dependency on serde so libserde ends up in the sysroot, breaking crate resolution inside of compiletest. We will need to figure out how else to run these tests. error[E0464]: multiple matching crates for `serde` --> $DIR/wrong_ser.rs:9:10 \| 9 \| #[derive(Serialize)] \| ^^^^^^^^^ \| = note: candidates: crate `serde`: /rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libserde-2b75907288aa7c40.rlib crate `serde`: /serde/test_suite/deps/target/debug/deps/libserde-33e0a319242344ce.rlib	2019-04-22 22:42:36 -07:00
David Tolnay	ce1686379d	Update test suite to nightly-2019-04-20	2019-04-19 22:54:59 -07:00
David Tolnay	79a20e9e33	Resolve option_map_unwrap_or_else lint	2019-04-10 22:57:47 -07:00
David Tolnay	e9cd73f78e	Remove link to hjson This project has still not been updated to Serde 1.0.	2019-04-08 10:39:55 -07:00
David Tolnay	0be7f36d51	Release 1.0.90	2019-04-03 09:41:38 -07:00
David Tolnay	4c6cb6e359	Match on serde_path to handle Some(path) and None I find this a bit easier to follow than map + unwrap_or_else.	2019-04-03 09:40:25 -07:00
David Tolnay	82bde8d166	Format with rustfmt 2019-03-27	2019-04-03 09:40:12 -07:00
David Tolnay	465392b618	Merge pull request #1499 from sgrif/sg-custom-serde-path Allow `#[serde(crate = "...")]` to override `extern crate serde`	2019-04-03 09:32:07 -07:00
David Tolnay	f3c6b9f05a	Simplify signature of Container::serde_path	2019-04-03 09:18:45 -07:00
David Tolnay	2f1945eaf2	Refer directly to serde_path in Deserialize impl This makes it not a breaking change if we later want to eliminate the `use #serde_path as _serde;` line.	2019-04-03 09:16:21 -07:00
Sean Griffin	b4d8a55b2a	Change `serde_path` to `crate` Also changed the generated code to have at least one thing refer to the path directly, rather than via `use` -- This shows that the impl can work without `use`, but doesn't actually do all the work to remove the `use` lines unless we decide we need this feature to work on the 2015 edition	2019-03-28 11:42:50 -06:00
Sean Griffin	0e6ce8fa50	Fix for Rust 1.15	2019-03-20 14:31:49 -06:00
Sean Griffin	a295c38ba3	Allow `#[serde(serde_path = "...")]` to override `extern crate serde` This is intended to be used by other crates which provide their own proc macros and use serde internally. Today there's no consistent way to put `#[derive(Deserialize)]` on a struct that consistently works, since crates may be using either `features = ["derive"]` or relying on `serde_derive` separately. Even if we assume that everyone is using `features = ["derive"]`, without this commit, any crate which generates `#[derive(serde::Deserialize)]` forces its consumers to put `serde` in their `Cargo.toml`, even if they aren't otherwise using serde for anything. Examples of crates which suffer from this in the real world are tower-web and swirl. With this feature, it's expected that these crates would have `pub extern crate serde;` in some accessible path, and add `#[serde(serde_path = "that_crate::wherever::serde")]` anywhere they place serde's derives. Those crates would also have to derive `that_crate::whatever::serde::Deserialize`, or `use` the macros explicitly beforehand. The test for this is a little funky, as it's testing this in a way that is not the intended use case, or even one we want to support. It has its own module which re-exports all of serde, but defines its own `Serialize` and `Deserialize` traits. We then test that we generated impls for those traits, instead of serde's. The only other way to test this would be to create a new test crate which does not depend on serde, but instead depends on `serde_derive` and a third crate which publicly re-exports serde. This feels like way too much overhead for a single test case, hence the funky test given. I didn't see anywhere in this repo to document this attribute, so I assume the docs will have to be done as a separate PR to a separate repo. Fixes #1487	2019-03-18 15:20:19 -06:00
David Tolnay	295730ba1e	Clippy cyclomatic complexity lint has been renamed	2019-03-09 16:36:51 -08:00
David Tolnay	ac0d8f61c5	Use non-preview name of Clippy rustup component	2019-03-01 23:11:06 -08:00
David Tolnay	b811588fa0	Release 1.0.89	2019-02-28 17:09:10 -08:00
David Tolnay	5fcdf0ff2b	Sort version-conditional imports at the bottom	2019-02-28 16:53:13 -08:00
David Tolnay	650b723da3	Format with rustfmt 2019-02-14	2019-02-28 16:40:54 -08:00
David Tolnay	97920be33a	Merge pull request #1486 from vorot93/reverse impl Serialize and Deserialize for core::cmp::Reverse	2019-02-28 16:39:54 -08:00
David Tolnay	58bbaa9e80	Refer to Option through serde::export in generated code	2019-02-28 16:36:17 -08:00
David Tolnay	94f152730c	Merge pull request #1492 from thomaseizinger/1491-clippy-warning Don't generate code with redundant closures	2019-02-28 16:35:59 -08:00
David Tolnay	535e3d4372	Mention rc feature in list of trait impls in documentation	2019-02-28 01:13:36 -08:00
Thomas Eizinger	2ea43c8986	Don't generate code with redundant closures Fixes #1491.	2019-02-28 17:30:21 +11:00
Artem Vorotnikov	71fe2a5534	Reverse impls available for Rust >=1.19	2019-02-20 12:56:35 +03:00
Artem Vorotnikov	f3ffcfd61e	impl Serialize and Deserialize for core::cmp::Reverse	2019-02-20 04:32:55 +03:00
David Tolnay	bf27b28554	Simplify running update-references.sh	2019-02-17 10:58:46 -08:00
David Tolnay	344602d27e	Make array ser impls macro better fit rustfmt style	2019-02-16 15:22:53 -08:00
David Tolnay	64c483cf80	Release 1.0.88	2019-02-15 19:55:50 -08:00
David Tolnay	19091aacc7	Fix mistaken double negative in flatten error message	2019-02-15 18:56:31 -08:00
David Tolnay	ef9028d798	Remove conflict between flatten and skip	2019-02-15 18:39:15 -08:00
David Tolnay	1668cd19d3	Eliminate try!(..).value to improve rustfmt'd code Rustfmt bails out on the original code, leaving it all on one line.	2019-02-13 09:13:50 -08:00
David Tolnay	134f268cee	Release 1.0.87	2019-02-04 07:08:41 +01:00
David Tolnay	c473633676	Format with rustfmt 2018-12-10	2019-02-04 00:39:32 +01:00
David Tolnay	6a3a82007c	Merge pull request #1474 from jwillbold/master Fixed #1468, flattened struct fields made structs ignore their tag	2019-02-03 15:37:44 -08:00
Johannes Willbold	1d6ef76cfb	Fixed #1468 , flattened struct fields made structs ignore their tag	2019-02-03 02:09:37 +01:00