Release 1.0.102

Improve Path deserialization

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.100" # remember to update html_root_url
+version = "1.0.102" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/build.rs

@@ -29,10 +29,12 @@ fn main() {
         println!("cargo:rustc-cfg=core_reverse");
     }
 
-    // CString::into_boxed_c_str stabilized in Rust 1.20:
+    // CString::into_boxed_c_str and PathBuf::into_boxed_path stabilized in Rust 1.20:
     // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
+    // https://doc.rust-lang.org/std/path/struct.PathBuf.html#method.into_boxed_path
     if minor >= 20 {
         println!("cargo:rustc-cfg=de_boxed_c_str");
+        println!("cargo:rustc-cfg=de_boxed_path");
     }
 
     // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:

serde/src/de/impls.rs

@@ -1580,6 +1580,24 @@ impl<'de> Visitor<'de> for PathBufVisitor {
     {
         Ok(From::from(v))
     }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        str::from_utf8(v)
+            .map(From::from)
+            .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        String::from_utf8(v)
+            .map(From::from)
+            .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self))
+    }
 }
 
 #[cfg(feature = "std")]
@@ -1592,6 +1610,9 @@ impl<'de> Deserialize<'de> for PathBuf {
     }
 }
 
+#[cfg(all(feature = "std", de_boxed_path))]
+forwarded_impl!((), Box<Path>, PathBuf::into_boxed_path);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // If this were outside of the serde crate, it would just use:

serde/src/lib.rs

@@ -47,12 +47,12 @@
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
 //! - [JSON5], A superset of JSON including some productions from ES5.
+//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
 //! - [URL], the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
 //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
 //!   Rust structs. *(deserialization only)*
-//! - [Postcard], a `no_std` and embedded-systems friendly compact binary format.
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Bincode]: https://github.com/TyOverby/bincode
@@ -65,17 +65,17 @@
 //! [BSON]: https://github.com/zonyitoo/bson-rs
 //! [Avro]: https://github.com/flavray/avro-rs
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
+//! [Postcard]: https://github.com/jamesmunns/postcard
 //! [URL]: https://github.com/nox/serde_urlencoded
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: http://doc.crates.io/manifest.html
 //! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
-//! [Postcard]: https://github.com/jamesmunns/postcard
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.100")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.102")]
 // 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
@@ -109,8 +109,13 @@
         // not practical
         needless_pass_by_value,
         similar_names,
+        too_many_lines,
         // preference
         doc_markdown,
+        // false positive
+        needless_doctest_main,
+        // noisy
+        must_use_candidate,
     )
 )]
 // Rustc lints.

serde/src/private/ser.rs

@@ -1032,7 +1032,7 @@ impl<'a, M> FlatMapSerializer<'a, M>
 where
     M: SerializeMap + 'a,
 {
-    fn bad_type(self, what: Unsupported) -> M::Error {
+    fn bad_type(what: Unsupported) -> M::Error {
         ser::Error::custom(format_args!(
             "can only flatten structs and maps (got {})",
             what
@@ -1057,59 +1057,59 @@ where
     type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
 
     fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Boolean))
+        Err(Self::bad_type(Unsupported::Boolean))
     }
 
     fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Integer))
+        Err(Self::bad_type(Unsupported::Integer))
     }
 
     fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
+        Err(Self::bad_type(Unsupported::Float))
     }
 
     fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Float))
+        Err(Self::bad_type(Unsupported::Float))
     }
 
     fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Char))
+        Err(Self::bad_type(Unsupported::Char))
     }
 
     fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::String))
+        Err(Self::bad_type(Unsupported::String))
     }
 
     fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::ByteArray))
+        Err(Self::bad_type(Unsupported::ByteArray))
     }
 
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
@@ -1124,11 +1124,11 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Unit))
+        Err(Self::bad_type(Unsupported::Unit))
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::UnitStruct))
+        Err(Self::bad_type(Unsupported::UnitStruct))
     }
 
     fn serialize_unit_variant(
@@ -1137,7 +1137,7 @@ where
         _: u32,
         _: &'static str,
     ) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Enum))
+        Err(Self::bad_type(Unsupported::Enum))
     }
 
     fn serialize_newtype_struct<T: ?Sized>(
@@ -1166,11 +1166,11 @@ where
     }
 
     fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(self.bad_type(Unsupported::Sequence))
+        Err(Self::bad_type(Unsupported::Sequence))
     }
 
     fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(self.bad_type(Unsupported::Tuple))
+        Err(Self::bad_type(Unsupported::Tuple))
     }
 
     fn serialize_tuple_struct(
@@ -1178,7 +1178,7 @@ where
         _: &'static str,
         _: usize,
     ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(self.bad_type(Unsupported::TupleStruct))
+        Err(Self::bad_type(Unsupported::TupleStruct))
     }
 
     fn serialize_tuple_variant(
@@ -1188,7 +1188,7 @@ where
         _: &'static str,
         _: usize,
     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(self.bad_type(Unsupported::Enum))
+        Err(Self::bad_type(Unsupported::Enum))
     }
 
     fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.100" # remember to update html_root_url
+version = "1.0.102" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"

serde_derive/src/bound.rs

@@ -17,8 +17,8 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
         params: generics
             .params
             .iter()
-            .map(|param| match *param {
-                syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
+            .map(|param| match param {
+                syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
                     eq_token: None,
                     default: None,
                     ..param.clone()
@@ -63,8 +63,8 @@ pub fn with_where_predicates_from_variants(
     generics: &syn::Generics,
     from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
 ) -> syn::Generics {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return generics.clone();
         }
@@ -114,8 +114,8 @@ pub fn with_bound(
     }
     impl<'ast> Visit<'ast> for FindTyParams<'ast> {
         fn visit_field(&mut self, field: &'ast syn::Field) {
-            if let syn::Type::Path(ref ty) = field.ty {
-                if let Some(Pair::Punctuated(ref t, _)) = ty.path.segments.pairs().next() {
+            if let syn::Type::Path(ty) = &field.ty {
+                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
                     if self.all_type_params.contains(&t.ident) {
                         self.associated_type_usage.push(ty);
                     }
@@ -160,8 +160,8 @@ pub fn with_bound(
         relevant_type_params: HashSet::new(),
         associated_type_usage: Vec::new(),
     };
-    match cont.data {
-        Data::Enum(ref variants) => {
+    match &cont.data {
+        Data::Enum(variants) => {
             for variant in variants.iter() {
                 let relevant_fields = variant
                     .fields
@@ -172,7 +172,7 @@ pub fn with_bound(
                 }
             }
         }
-        Data::Struct(_, ref fields) => {
+        Data::Struct(_, fields) => {
             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
                 visitor.visit_field(field.original);
             }
@@ -255,11 +255,11 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
     let params = Some(syn::GenericParam::Lifetime(def))
         .into_iter()
         .chain(generics.params.iter().cloned().map(|mut param| {
-            match param {
-                syn::GenericParam::Lifetime(ref mut param) => {
+            match &mut param {
+                syn::GenericParam::Lifetime(param) => {
                     param.bounds.push(bound.clone());
                 }
-                syn::GenericParam::Type(ref mut param) => {
+                syn::GenericParam::Type(param) => {
                     param
                         .bounds
                         .push(syn::TypeParamBound::Lifetime(bound.clone()));
@@ -291,14 +291,14 @@ fn type_of_item(cont: &Container) -> syn::Type {
                             .generics
                             .params
                             .iter()
-                            .map(|param| match *param {
-                                syn::GenericParam::Type(ref param) => {
+                            .map(|param| match param {
+                                syn::GenericParam::Type(param) => {
                                     syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
                                         qself: None,
                                         path: param.ident.clone().into(),
                                     }))
                                 }
-                                syn::GenericParam::Lifetime(ref param) => {
+                                syn::GenericParam::Lifetime(param) => {
                                     syn::GenericArgument::Lifetime(param.lifetime.clone())
                                 }
                                 syn::GenericParam::Const(_) => {

serde_derive/src/de.rs

@@ -75,7 +75,7 @@ fn precondition(cx: &Ctxt, cont: &Container) {
 }
 
 fn precondition_sized(cx: &Ctxt, cont: &Container) {
-    if let Data::Struct(_, ref fields) = cont.data {
+    if let Data::Struct(_, fields) = &cont.data {
         if let Some(last) = fields.last() {
             if let syn::Type::Slice(_) = *last.ty {
                 cx.error_spanned_by(
@@ -229,8 +229,8 @@ impl BorrowedLifetimes {
     }
 
     fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
-        match *self {
-            BorrowedLifetimes::Borrowed(ref bounds) => Some(syn::LifetimeDef {
+        match self {
+            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
                 attrs: Vec::new(),
                 lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
@@ -272,21 +272,19 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
     } else if let Some(type_try_from) = cont.attrs.type_try_from() {
         deserialize_try_from(type_try_from)
     } else if let attr::Identifier::No = cont.attrs.identifier() {
-        match cont.data {
-            Data::Enum(ref variants) => deserialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, ref fields) => {
+        match &cont.data {
+            Data::Enum(variants) => deserialize_enum(params, variants, &cont.attrs),
+            Data::Struct(Style::Struct, fields) => {
                 deserialize_struct(None, params, fields, &cont.attrs, None, &Untagged::No)
             }
-            Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => {
+            Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
                 deserialize_tuple(None, params, fields, &cont.attrs, None)
             }
             Data::Struct(Style::Unit, _) => deserialize_unit_struct(params, &cont.attrs),
         }
     } else {
-        match cont.data {
-            Data::Enum(ref variants) => {
-                deserialize_custom_identifier(params, variants, &cont.attrs)
-            }
+        match &cont.data {
+            Data::Enum(variants) => deserialize_custom_identifier(params, variants, &cont.attrs),
             Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
         }
     }
@@ -310,8 +308,8 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
         return None;
     }
 
-    let code = match cont.data {
-        Data::Struct(Style::Struct, ref fields) => {
+    let code = match &cont.data {
+        Data::Struct(Style::Struct, fields) => {
             if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
             {
                 code
@@ -319,7 +317,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
                 return None;
             }
         }
-        Data::Struct(Style::Tuple, ref fields) | Data::Struct(Style::Newtype, ref fields) => {
+        Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
             deserialize_tuple_in_place(None, params, fields, &cont.attrs, None)
         }
         Data::Enum(_) | Data::Struct(Style::Unit, _) => {
@@ -348,8 +346,8 @@ fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<
 }
 
 fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match cont.data {
-        Data::Struct(_, ref fields) => fields,
+    let fields = match &cont.data {
+        Data::Struct(_, fields) => fields,
         Data::Enum(_) => unreachable!(),
     };
 
@@ -369,9 +367,9 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
         if field as *const Field == transparent_field as *const Field {
             quote!(#member: __transparent)
         } else {
-            let value = match *field.attrs.default() {
+            let value = match field.attrs.default() {
                 attr::Default::Default => quote!(_serde::export::Default::default()),
-                attr::Default::Path(ref path) => quote!(#path()),
+                attr::Default::Path(path) => quote!(#path()),
                 attr::Default::None => quote!(_serde::export::PhantomData),
             };
             quote!(#member: #value)
@@ -456,7 +454,7 @@ fn deserialize_tuple(
 
     let is_enum = variant_ident.is_some();
     let type_path = match variant_ident {
-        Some(ref variant_ident) => quote!(#construct::#variant_ident),
+        Some(variant_ident) => quote!(#construct::#variant_ident),
         None => construct,
     };
     let expecting = match variant_ident {
@@ -664,9 +662,9 @@ fn deserialize_seq(
                     })
                 }
             };
-            let value_if_none = match *field.attrs.default() {
+            let value_if_none = match field.attrs.default() {
                 attr::Default::Default => quote!(_serde::export::Default::default()),
-                attr::Default::Path(ref path) => quote!(#path()),
+                attr::Default::Path(path) => quote!(#path()),
                 attr::Default::None => quote!(
                     return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
                 ),
@@ -702,11 +700,11 @@ fn deserialize_seq(
         };
     }
 
-    let let_default = match *cattrs.default() {
+    let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
             let __default: Self::Value = _serde::export::Default::default();
         )),
-        attr::Default::Path(ref path) => Some(quote!(
+        attr::Default::Path(path) => Some(quote!(
             let __default: Self::Value = #path();
         )),
         attr::Default::None => {
@@ -750,11 +748,11 @@ fn deserialize_seq_in_place(
                 self.place.#member = #default;
             }
         } else {
-            let value_if_none = match *field.attrs.default() {
+            let value_if_none = match field.attrs.default() {
                 attr::Default::Default => quote!(
                     self.place.#member = _serde::export::Default::default();
                 ),
-                attr::Default::Path(ref path) => quote!(
+                attr::Default::Path(path) => quote!(
                     self.place.#member = #path();
                 ),
                 attr::Default::None => quote!(
@@ -793,11 +791,11 @@ fn deserialize_seq_in_place(
 
     let this = &params.this;
     let (_, ty_generics, _) = params.generics.split_for_impl();
-    let let_default = match *cattrs.default() {
+    let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
             let __default: #this #ty_generics  = _serde::export::Default::default();
         )),
-        attr::Default::Path(ref path) => Some(quote!(
+        attr::Default::Path(path) => Some(quote!(
             let __default: #this #ty_generics  = #path();
         )),
         attr::Default::None => {
@@ -907,7 +905,7 @@ fn deserialize_struct(
     };
 
     let type_path = match variant_ident {
-        Some(ref variant_ident) => quote!(#construct::#variant_ident),
+        Some(variant_ident) => quote!(#construct::#variant_ident),
         None => construct,
     };
     let expecting = match variant_ident {
@@ -1144,15 +1142,14 @@ fn deserialize_enum(
     variants: &[Variant],
     cattrs: &attr::Container,
 ) -> Fragment {
-    match *cattrs.tag() {
+    match cattrs.tag() {
         attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
-        attr::TagType::Internal { ref tag } => {
+        attr::TagType::Internal { tag } => {
             deserialize_internally_tagged_enum(params, variants, cattrs, tag)
         }
-        attr::TagType::Adjacent {
-            ref tag,
-            ref content,
-        } => deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content),
+        attr::TagType::Adjacent { tag, content } => {
+            deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content)
+        }
         attr::TagType::None => deserialize_untagged_enum(params, variants, cattrs),
     }
 }
@@ -1174,12 +1171,10 @@ fn prepare_enum_variant_enum(
         })
         .collect();
 
-    let other_idx = variants
-        .iter()
-        .position(|ref variant| variant.attrs.other());
+    let other_idx = variants.iter().position(|variant| variant.attrs.other());
 
     let variants_stmt = {
-        let variant_names = variant_names_idents.iter().map(|&(ref name, _, _)| name);
+        let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
         quote! {
             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
         }
@@ -1688,9 +1683,12 @@ fn deserialize_externally_tagged_variant(
                 _serde::export::Ok(#this::#variant_ident)
             }
         }
-        Style::Newtype => {
-            deserialize_externally_tagged_newtype_variant(variant_ident, params, &variant.fields[0])
-        }
+        Style::Newtype => deserialize_externally_tagged_newtype_variant(
+            variant_ident,
+            params,
+            &variant.fields[0],
+            cattrs,
+        ),
         Style::Tuple => {
             deserialize_tuple(Some(variant_ident), params, &variant.fields, cattrs, None)
         }
@@ -1717,14 +1715,18 @@ fn deserialize_internally_tagged_variant(
 
     let variant_ident = &variant.ident;
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             let this = &params.this;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
+            let default = variant.fields.get(0).map(|field| {
+                let default = Expr(expr_is_missing(field, cattrs));
+                quote!((#default))
+            });
             quote_block! {
                 try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::export::Ok(#this::#variant_ident)
+                _serde::export::Ok(#this::#variant_ident #default)
             }
         }
         Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1762,17 +1764,21 @@ fn deserialize_untagged_variant(
 
     let variant_ident = &variant.ident;
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             let this = &params.this;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
+            let default = variant.fields.get(0).map(|field| {
+                let default = Expr(expr_is_missing(field, cattrs));
+                quote!((#default))
+            });
             quote_expr! {
                 match _serde::Deserializer::deserialize_any(
                     #deserializer,
                     _serde::private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
                 ) {
-                    _serde::export::Ok(()) => _serde::export::Ok(#this::#variant_ident),
+                    _serde::export::Ok(()) => _serde::export::Ok(#this::#variant_ident #default),
                     _serde::export::Err(__err) => _serde::export::Err(__err),
                 }
             }
@@ -1805,8 +1811,19 @@ fn deserialize_externally_tagged_newtype_variant(
     variant_ident: &syn::Ident,
     params: &Parameters,
     field: &Field,
+    cattrs: &attr::Container,
 ) -> Fragment {
     let this = &params.this;
+
+    if field.attrs.skip_deserializing() {
+        let this = &params.this;
+        let default = Expr(expr_is_missing(field, cattrs));
+        return quote_block! {
+            try!(_serde::de::VariantAccess::unit_variant(__variant));
+            _serde::export::Ok(#this::#variant_ident(#default))
+        };
+    }
+
     match field.attrs.deserialize_with() {
         None => {
             let field_ty = field.ty;
@@ -1861,7 +1878,7 @@ fn deserialize_generated_identifier(
     other_idx: Option<usize>,
 ) -> Fragment {
     let this = quote!(__Field);
-    let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident, _)| ident).collect();
+    let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
 
     let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
         let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
@@ -1967,7 +1984,7 @@ fn deserialize_custom_identifier(
         })
         .collect();
 
-    let names = names_idents.iter().map(|&(ref name, _, _)| name);
+    let names = names_idents.iter().map(|(name, _, _)| name);
 
     let names_const = if fallthrough.is_some() {
         None
@@ -2024,26 +2041,26 @@ fn deserialize_identifier(
     collect_other_fields: bool,
 ) -> Fragment {
     let mut flat_fields = Vec::new();
-    for &(_, ref ident, ref aliases) in fields {
+    for (_, ident, aliases) in fields {
         flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
     }
 
-    let field_strs = flat_fields.iter().map(|&(ref name, _)| name);
-    let field_borrowed_strs = flat_fields.iter().map(|&(ref name, _)| name);
+    let field_strs = flat_fields.iter().map(|(name, _)| name);
+    let field_borrowed_strs = flat_fields.iter().map(|(name, _)| name);
     let field_bytes = flat_fields
         .iter()
-        .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
+        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
     let field_borrowed_bytes = flat_fields
         .iter()
-        .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
+        .map(|(name, _)| Literal::byte_string(name.as_bytes()));
 
     let constructors: &Vec<_> = &flat_fields
         .iter()
-        .map(|&(_, ref ident)| quote!(#this::#ident))
+        .map(|(_, ident)| quote!(#this::#ident))
         .collect();
     let main_constructors: &Vec<_> = &fields
         .iter()
-        .map(|&(_, ref ident, _)| quote!(#this::#ident))
+        .map(|(_, ident, _)| quote!(#this::#ident))
         .collect();
 
     let expecting = if is_variant {
@@ -2305,7 +2322,7 @@ fn deserialize_struct_as_struct_visitor(
         .collect();
 
     let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
+        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
         quote_block! {
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
@@ -2361,7 +2378,7 @@ fn deserialize_map(
     let let_values = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let field_ty = field.ty;
             quote! {
                 let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
@@ -2384,7 +2401,7 @@ fn deserialize_map(
     let value_arms = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let deser_name = field.attrs.name().deserialize_name();
 
             let visit = match field.attrs.deserialize_with() {
@@ -2460,7 +2477,7 @@ fn deserialize_map(
     let extract_values = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let missing_expr = Match(expr_is_missing(field, cattrs));
 
             quote! {
@@ -2474,7 +2491,7 @@ fn deserialize_map(
     let extract_collected = fields_names
         .iter()
         .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let field_ty = field.ty;
             let func = match field.attrs.deserialize_with() {
                 None => {
@@ -2509,7 +2526,7 @@ fn deserialize_map(
         None
     };
 
-    let result = fields_names.iter().map(|&(field, ref name)| {
+    let result = fields_names.iter().map(|(field, name)| {
         let member = &field.member;
         if field.attrs.skip_deserializing() {
             let value = Expr(expr_is_missing(field, cattrs));
@@ -2519,11 +2536,11 @@ fn deserialize_map(
         }
     });
 
-    let let_default = match *cattrs.default() {
+    let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
             let __default: Self::Value = _serde::export::Default::default();
         )),
-        attr::Default::Path(ref path) => Some(quote!(
+        attr::Default::Path(path) => Some(quote!(
             let __default: Self::Value = #path();
         )),
         attr::Default::None => {
@@ -2582,7 +2599,7 @@ fn deserialize_struct_as_struct_in_place_visitor(
         .collect();
 
     let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
+        let field_names = field_names_idents.iter().map(|(name, _, _)| name);
         quote_block! {
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
@@ -2615,7 +2632,7 @@ fn deserialize_map_in_place(
     let let_flags = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|&(_, ref name)| {
+        .map(|(_, name)| {
             quote! {
                 let mut #name: bool = false;
             }
@@ -2625,7 +2642,7 @@ fn deserialize_map_in_place(
     let value_arms_from = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let deser_name = field.attrs.name().deserialize_name();
             let member = &field.member;
 
@@ -2692,7 +2709,7 @@ fn deserialize_map_in_place(
     let check_flags = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|&(field, ref name)| {
+        .map(|(field, name)| {
             let missing_expr = expr_is_missing(field, cattrs);
             // If missing_expr unconditionally returns an error, don't try
             // to assign its value to self.place.
@@ -2720,11 +2737,11 @@ fn deserialize_map_in_place(
     let this = &params.this;
     let (_, _, ty_generics, _) = split_with_de_lifetime(params);
 
-    let let_default = match *cattrs.default() {
+    let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
             let __default: #this #ty_generics = _serde::export::Default::default();
         )),
-        attr::Default::Path(ref path) => Some(quote!(
+        attr::Default::Path(path) => Some(quote!(
             let __default: #this #ty_generics = #path();
         )),
         attr::Default::None => {
@@ -2843,13 +2860,13 @@ fn wrap_deserialize_variant_with(
 }
 
 fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
-    match *field.attrs.default() {
+    match field.attrs.default() {
         attr::Default::Default => {
             let span = field.original.span();
             let func = quote_spanned!(span=> _serde::export::Default::default);
             return quote_expr!(#func());
         }
-        attr::Default::Path(ref path) => {
+        attr::Default::Path(path) => {
             return quote_expr!(#path());
         }
         attr::Default::None => { /* below */ }
@@ -2880,6 +2897,13 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
     }
 }
 
+fn effective_style(variant: &Variant) -> Style {
+    match variant.style {
+        Style::Newtype if variant.fields[0].attrs.skip_deserializing() => Style::Unit,
+        other => other,
+    }
+}
+
 struct DeImplGenerics<'a>(&'a Parameters);
 #[cfg(feature = "deserialize_in_place")]
 struct InPlaceImplGenerics<'a>(&'a Parameters);
@@ -2906,11 +2930,11 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
 
         // Add lifetime for `&'place mut Self, and `'a: 'place`
         for param in &mut generics.params {
-            match *param {
-                syn::GenericParam::Lifetime(ref mut param) => {
+            match param {
+                syn::GenericParam::Lifetime(param) => {
                     param.bounds.push(place_lifetime.lifetime.clone());
                 }
-                syn::GenericParam::Type(ref mut param) => {
+                syn::GenericParam::Type(param) => {
                     param.bounds.push(syn::TypeParamBound::Lifetime(
                         place_lifetime.lifetime.clone(),
                     ));

serde_derive/src/fragment.rs

@@ -27,9 +27,9 @@ macro_rules! quote_block {
 pub struct Expr(pub Fragment);
 impl ToTokens for Expr {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => expr.to_tokens(out),
-            Fragment::Block(ref block) => {
+        match &self.0 {
+            Fragment::Expr(expr) => expr.to_tokens(out),
+            Fragment::Block(block) => {
                 token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
@@ -40,9 +40,9 @@ impl ToTokens for Expr {
 pub struct Stmts(pub Fragment);
 impl ToTokens for Stmts {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => expr.to_tokens(out),
-            Fragment::Block(ref block) => block.to_tokens(out),
+        match &self.0 {
+            Fragment::Expr(expr) => expr.to_tokens(out),
+            Fragment::Block(block) => block.to_tokens(out),
         }
     }
 }
@@ -52,12 +52,12 @@ impl ToTokens for Stmts {
 pub struct Match(pub Fragment);
 impl ToTokens for Match {
     fn to_tokens(&self, out: &mut TokenStream) {
-        match self.0 {
-            Fragment::Expr(ref expr) => {
+        match &self.0 {
+            Fragment::Expr(expr) => {
                 expr.to_tokens(out);
                 <Token![,]>::default().to_tokens(out);
             }
-            Fragment::Block(ref block) => {
+            Fragment::Block(block) => {
                 token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
@@ -66,9 +66,9 @@ impl ToTokens for Match {
 
 impl AsRef<TokenStream> for Fragment {
     fn as_ref(&self) -> &TokenStream {
-        match *self {
-            Fragment::Expr(ref expr) => expr,
-            Fragment::Block(ref block) => block,
+        match self {
+            Fragment::Expr(expr) => expr,
+            Fragment::Block(block) => block,
         }
     }
 }

serde_derive/src/internals/ast.rs

@@ -67,11 +67,9 @@ impl<'a> Container<'a> {
     ) -> Option<Container<'a>> {
         let mut attrs = attr::Container::from_ast(cx, item);
 
-        let mut data = match item.data {
-            syn::Data::Enum(ref data) => {
-                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default()))
-            }
-            syn::Data::Struct(ref data) => {
+        let mut data = match &item.data {
+            syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
+            syn::Data::Struct(data) => {
                 let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
                 Data::Struct(style, fields)
             }
@@ -82,8 +80,8 @@ impl<'a> Container<'a> {
         };
 
         let mut has_flatten = false;
-        match data {
-            Data::Enum(ref mut variants) => {
+        match &mut data {
+            Data::Enum(variants) => {
                 for variant in variants {
                     variant.attrs.rename_by_rules(attrs.rename_all_rules());
                     for field in &mut variant.fields {
@@ -96,7 +94,7 @@ impl<'a> Container<'a> {
                     }
                 }
             }
-            Data::Struct(_, ref mut fields) => {
+            Data::Struct(_, fields) => {
                 for field in fields {
                     if field.attrs.flatten() {
                         has_flatten = true;
@@ -124,11 +122,11 @@ impl<'a> Container<'a> {
 
 impl<'a> Data<'a> {
     pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
-        match *self {
-            Data::Enum(ref variants) => {
+        match self {
+            Data::Enum(variants) => {
                 Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
             }
-            Data::Struct(_, ref fields) => Box::new(fields.iter()),
+            Data::Struct(_, fields) => Box::new(fields.iter()),
         }
     }
 
@@ -165,16 +163,16 @@ fn struct_from_ast<'a>(
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
 ) -> (Style, Vec<Field<'a>>) {
-    match *fields {
-        syn::Fields::Named(ref fields) => (
+    match fields {
+        syn::Fields::Named(fields) => (
             Style::Struct,
             fields_from_ast(cx, &fields.named, attrs, container_default),
         ),
-        syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => (
+        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
             Style::Newtype,
             fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
-        syn::Fields::Unnamed(ref fields) => (
+        syn::Fields::Unnamed(fields) => (
             Style::Tuple,
             fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
@@ -192,8 +190,8 @@ fn fields_from_ast<'a>(
         .iter()
         .enumerate()
         .map(|(i, field)| Field {
-            member: match field.ident {
-                Some(ref ident) => syn::Member::Named(ident.clone()),
+            member: match &field.ident {
+                Some(ident) => syn::Member::Named(ident.clone()),
                 None => syn::Member::Unnamed(i.into()),
             },
             attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),

serde_derive/src/internals/check.rs

@@ -32,8 +32,7 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
             if cont.data.has_getter() && cont.attrs.remote().is_none() {
                 cx.error_spanned_by(
                     cont.original,
-                    "#[serde(getter = \"...\")] can only be used in structs \
-                     that have #[serde(remote = \"...\")]",
+                    "#[serde(getter = \"...\")] can only be used in structs that have #[serde(remote = \"...\")]",
                 );
             }
         }
@@ -42,17 +41,17 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
 
 /// Flattening has some restrictions we can test.
 fn check_flatten(cx: &Ctxt, cont: &Container) {
-    match cont.data {
-        Data::Enum(ref variants) => {
+    match &cont.data {
+        Data::Enum(variants) => {
             for variant in variants {
                 for field in &variant.fields {
                     check_flatten_field(cx, variant.style, field);
                 }
             }
         }
-        Data::Struct(style, ref fields) => {
+        Data::Struct(style, fields) => {
             for field in fields {
-                check_flatten_field(cx, style, field);
+                check_flatten_field(cx, *style, field);
             }
         }
     }
@@ -86,8 +85,8 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
 /// `field_identifier` all but possibly one variant must be unit variants. The
 /// last variant may be a newtype variant which is an implicit "other" case.
 fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return;
         }
@@ -170,8 +169,8 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
 /// Skip-(de)serializing attributes are not allowed on variants marked
 /// (de)serialize_with.
 fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return;
         }
@@ -183,8 +182,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                 cx.error_spanned_by(
                     variant.original,
                     format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and \
-                         #[serde(skip_serializing)]",
+                        "variant `{}` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]",
                         variant.ident
                     ),
                 );
@@ -197,8 +195,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and \
-                             a field {} marked with #[serde(skip_serializing)]",
+                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing)]",
                             variant.ident, member
                         ),
                     );
@@ -208,8 +205,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and \
-                             a field {} marked with #[serde(skip_serializing_if)]",
+                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing_if)]",
                             variant.ident, member
                         ),
                     );
@@ -222,8 +218,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                 cx.error_spanned_by(
                     variant.original,
                     format!(
-                        "variant `{}` cannot have both #[serde(deserialize_with)] and \
-                         #[serde(skip_deserializing)]",
+                        "variant `{}` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]",
                         variant.ident
                     ),
                 );
@@ -236,8 +231,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
                     cx.error_spanned_by(
                         variant.original,
                         format!(
-                            "variant `{}` cannot have both #[serde(deserialize_with)] \
-                             and a field {} marked with #[serde(skip_deserializing)]",
+                            "variant `{}` cannot have both #[serde(deserialize_with)] and a field {} marked with #[serde(skip_deserializing)]",
                             variant.ident, member
                         ),
                     );
@@ -252,13 +246,13 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
 /// duplicate keys in the serialized output and/or ambiguity in
 /// the to-be-deserialized input.
 fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => return,
     };
 
-    let tag = match *cont.attrs.tag() {
-        TagType::Internal { ref tag } => tag.as_str(),
+    let tag = match cont.attrs.tag() {
+        TagType::Internal { tag } => tag.as_str(),
         TagType::External | TagType::Adjacent { .. } | TagType::None => return,
     };
 
@@ -299,11 +293,8 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
 /// In the case of adjacently-tagged enums, the type and the
 /// contents tag must differ, for the same reason.
 fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
-    let (type_tag, content_tag) = match *cont.attrs.tag() {
-        TagType::Adjacent {
-            ref tag,
-            ref content,
-        } => (tag, content),
+    let (type_tag, content_tag) = match cont.attrs.tag() {
+        TagType::Adjacent { tag, content } => (tag, content),
         TagType::Internal { .. } | TagType::External | TagType::None => return,
     };
 
@@ -345,7 +336,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
         );
     }
 
-    let fields = match cont.data {
+    let fields = match &mut cont.data {
         Data::Enum(_) => {
             cx.error_spanned_by(
                 cont.original,
@@ -360,7 +351,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
             );
             return;
         }
-        Data::Struct(_, ref mut fields) => fields,
+        Data::Struct(_, fields) => fields,
     };
 
     let mut transparent_field = None;
@@ -398,14 +389,14 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
 }
 
 fn member_message(member: &Member) -> String {
-    match *member {
-        Member::Named(ref ident) => format!("`{}`", ident),
-        Member::Unnamed(ref i) => format!("#{}", i.index),
+    match member {
+        Member::Named(ident) => format!("`{}`", ident),
+        Member::Unnamed(i) => format!("#{}", i.index),
     }
 }
 
 fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ref ty) = *field.ty {
+    if let Type::Path(ty) = field.ty {
         if let Some(seg) = ty.path.segments.last() {
             if seg.ident == "PhantomData" {
                 return false;

serde_derive/src/internals/ctxt.rs

@@ -38,6 +38,11 @@ impl Ctxt {
             .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
     }
 
+    /// Add one of Syn's parse errors.
+    pub fn syn_error(&self, err: syn::Error) {
+        self.errors.borrow_mut().as_mut().unwrap().push(err);
+    }
+
     /// Consume this object, producing a formatted error string if there are errors.
     pub fn check(self) -> Result<(), Vec<syn::Error>> {
         let errors = self.errors.borrow_mut().take().unwrap();

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.100")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.102")]
 #![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))]
@@ -43,8 +43,10 @@
         items_after_statements,
         match_same_arms,
         module_name_repetitions,
+        must_use_candidate,
         similar_names,
         single_match_else,
+        too_many_lines,
         unseparated_literal_suffix,
         use_self,
     )

serde_derive/src/pretend.rs

@@ -52,8 +52,8 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
     let type_ident = &cont.ident;
     let (_, ty_generics, _) = cont.generics.split_for_impl();
 
-    let patterns = match cont.data {
-        Data::Enum(ref variants) => variants
+    let patterns = match &cont.data {
+        Data::Enum(variants) => variants
             .iter()
             .filter_map(|variant| match variant.style {
                 Style::Struct => {
@@ -64,7 +64,7 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
                 _ => None,
             })
             .collect::<Vec<_>>(),
-        Data::Struct(Style::Struct, ref fields) => {
+        Data::Struct(Style::Struct, fields) => {
             let pat = struct_pattern(fields);
             vec![quote!(#type_ident #pat)]
         }
@@ -93,8 +93,8 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
 //     }
 //
 fn pretend_variants_used(cont: &Container) -> TokenStream {
-    let variants = match cont.data {
-        Data::Enum(ref variants) => variants,
+    let variants = match &cont.data {
+        Data::Enum(variants) => variants,
         Data::Struct(_, _) => {
             return quote!();
         }

serde_derive/src/ser.rs

@@ -164,15 +164,13 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
     } else if let Some(type_into) = cont.attrs.type_into() {
         serialize_into(params, type_into)
     } else {
-        match cont.data {
-            Data::Enum(ref variants) => serialize_enum(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, ref fields) => {
-                serialize_struct(params, fields, &cont.attrs)
-            }
-            Data::Struct(Style::Tuple, ref fields) => {
+        match &cont.data {
+            Data::Enum(variants) => serialize_enum(params, variants, &cont.attrs),
+            Data::Struct(Style::Struct, fields) => serialize_struct(params, fields, &cont.attrs),
+            Data::Struct(Style::Tuple, fields) => {
                 serialize_tuple_struct(params, fields, &cont.attrs)
             }
-            Data::Struct(Style::Newtype, ref fields) => {
+            Data::Struct(Style::Newtype, fields) => {
                 serialize_newtype_struct(params, &fields[0], &cont.attrs)
             }
             Data::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
@@ -181,8 +179,8 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
 }
 
 fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match cont.data {
-        Data::Struct(_, ref fields) => fields,
+    let fields = match &cont.data {
+        Data::Struct(_, fields) => fields,
         Data::Enum(_) => unreachable!(),
     };
 
@@ -259,7 +257,7 @@ fn serialize_tuple_struct(
     let mut serialized_fields = fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .peekable();
 
     let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -296,8 +294,8 @@ 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 } => {
+    match cattrs.tag() {
+        attr::TagType::Internal { tag } => {
             let type_name = cattrs.name().serialize_name();
             let func = struct_trait.serialize_field(Span::call_site());
             quote! {
@@ -467,17 +465,16 @@ fn serialize_variant(
             }
         };
 
-        let body = Match(match *cattrs.tag() {
+        let body = Match(match cattrs.tag() {
             attr::TagType::External => {
                 serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
             }
-            attr::TagType::Internal { ref tag } => {
+            attr::TagType::Internal { tag } => {
                 serialize_internally_tagged_variant(params, variant, cattrs, tag)
             }
-            attr::TagType::Adjacent {
-                ref tag,
-                ref content,
-            } => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content),
+            attr::TagType::Adjacent { tag, content } => {
+                serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content)
+            }
             attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
         });
 
@@ -509,7 +506,7 @@ fn serialize_externally_tagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_expr! {
                 _serde::Serializer::serialize_unit_variant(
@@ -586,7 +583,7 @@ fn serialize_internally_tagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_block! {
                 let mut __struct = try!(_serde::Serializer::serialize_struct(
@@ -646,7 +643,7 @@ fn serialize_adjacently_tagged_variant(
             _serde::Serialize::serialize(#ser, __serializer)
         }
     } else {
-        match variant.style {
+        match effective_style(variant) {
             Style::Unit => {
                 return quote_block! {
                     let mut __struct = try!(_serde::Serializer::serialize_struct(
@@ -723,6 +720,8 @@ fn serialize_adjacently_tagged_variant(
             where
                 __S: _serde::Serializer,
             {
+                // Elements that have skip_serializing will be unused.
+                #[allow(unused_variables)]
                 let (#(#fields_ident,)*) = self.data;
                 #inner
             }
@@ -753,7 +752,7 @@ fn serialize_untagged_variant(
         };
     }
 
-    match variant.style {
+    match effective_style(variant) {
         Style::Unit => {
             quote_expr! {
                 _serde::Serializer::serialize_unit(__serializer)
@@ -804,7 +803,7 @@ fn serialize_tuple_variant(
     let mut serialized_fields = fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .peekable();
 
     let let_mut = mut_if(serialized_fields.peek().is_some());
@@ -1039,7 +1038,7 @@ fn serialize_tuple_struct_visitor(
     fields
         .iter()
         .enumerate()
-        .filter(|&(_, ref field)| !field.attrs.skip_serializing())
+        .filter(|(_, field)| !field.attrs.skip_serializing())
         .map(|(i, field)| {
             let mut field_expr = if is_enum {
                 let id = Ident::new(&format!("__field{}", i), Span::call_site());
@@ -1163,9 +1162,9 @@ fn wrap_serialize_variant_with(
         .fields
         .iter()
         .map(|field| {
-            let id = match field.member {
-                Member::Named(ref ident) => ident.clone(),
-                Member::Unnamed(ref member) => {
+            let id = match &field.member {
+                Member::Named(ident) => ident.clone(),
+                Member::Unnamed(member) => {
                     Ident::new(&format!("__field{}", member.index), Span::call_site())
                 }
             };
@@ -1258,6 +1257,13 @@ fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStrea
     }
 }
 
+fn effective_style(variant: &Variant) -> Style {
+    match variant.style {
+        Style::Newtype if variant.fields[0].attrs.skip_serializing() => Style::Unit,
+        other => other,
+    }
+}
+
 enum StructTrait {
     SerializeMap,
     SerializeStruct,

serde_derive_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive_internals"
-version = "0.24.1" # remember to update html_root_url
+version = "0.25.0" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."

serde_derive_internals/lib.rs

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

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.100" # remember to update html_root_url
+version = "1.0.102" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"

serde_test/src/assert.rs

@@ -12,7 +12,6 @@ use std::fmt::Debug;
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -28,7 +27,6 @@ use std::fmt::Debug;
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
 pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
@@ -44,7 +42,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_ser_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -60,7 +57,6 @@ where
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
 pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
 where
@@ -135,7 +131,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// struct S {
 ///     a: u8,
@@ -151,7 +146,6 @@ where
 ///     Token::U8(0),
 ///     Token::StructEnd,
 /// ]);
-/// # }
 /// ```
 pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
@@ -190,7 +184,6 @@ where
 /// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens_error, Token};
 /// #
-/// # fn main() {
 /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
 /// #[serde(deny_unknown_fields)]
 /// struct S {
@@ -205,7 +198,6 @@ where
 ///     ],
 ///     "unknown field `x`, expected `a` or `b`",
 /// );
-/// # }
 /// ```
 pub fn assert_de_tokens_error<'de, T>(tokens: &'de [Token], error: &str)
 where

serde_test/src/lib.rs

@@ -144,11 +144,11 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.100")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.102")]
 #![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(float_cmp))]
+#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
 // Ignored clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
@@ -156,6 +156,7 @@
         empty_line_after_outer_attr,
         missing_docs_in_private_items,
         module_name_repetitions,
+        must_use_candidate,
         redundant_field_names,
         use_debug,
         use_self

test_suite/Cargo.toml

@@ -13,7 +13,6 @@ 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"] }

test_suite/tests/test_de.rs

@@ -104,6 +104,9 @@ struct StructSkipAllDenyUnknown {
     a: i32,
 }
 
+#[derive(Default, PartialEq, Debug)]
+struct NotDeserializable;
+
 #[derive(PartialEq, Debug, Deserialize)]
 enum Enum {
     #[allow(dead_code)]
@@ -117,6 +120,7 @@ enum Enum {
         b: i32,
         c: i32,
     },
+    SimpleWithSkipped(#[serde(skip_deserializing)] NotDeserializable),
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
@@ -728,6 +732,11 @@ declare_tests! {
             Token::I32(1),
         ],
     }
+    test_enum_simple_with_skipped {
+        Enum::SimpleWithSkipped(NotDeserializable) => &[
+            Token::UnitVariant { name: "Enum", variant: "SimpleWithSkipped" },
+        ],
+    }
     test_enum_seq {
         Enum::Seq(1, 2, 3) => &[
             Token::TupleVariant { name: "Enum", variant: "Seq", len: 3 },
@@ -880,11 +889,37 @@ declare_tests! {
         Path::new("/usr/local/lib") => &[
             Token::BorrowedStr("/usr/local/lib"),
         ],
+        Path::new("/usr/local/lib") => &[
+            Token::BorrowedBytes(b"/usr/local/lib"),
+        ],
     }
     test_path_buf {
+        PathBuf::from("/usr/local/lib") => &[
+            Token::Str("/usr/local/lib"),
+        ],
         PathBuf::from("/usr/local/lib") => &[
             Token::String("/usr/local/lib"),
         ],
+        PathBuf::from("/usr/local/lib") => &[
+            Token::Bytes(b"/usr/local/lib"),
+        ],
+        PathBuf::from("/usr/local/lib") => &[
+            Token::ByteBuf(b"/usr/local/lib"),
+        ],
+    }
+    test_boxed_path {
+        PathBuf::from("/usr/local/lib").into_boxed_path() => &[
+            Token::Str("/usr/local/lib"),
+        ],
+        PathBuf::from("/usr/local/lib").into_boxed_path() => &[
+            Token::String("/usr/local/lib"),
+        ],
+        PathBuf::from("/usr/local/lib").into_boxed_path() => &[
+            Token::Bytes(b"/usr/local/lib"),
+        ],
+        PathBuf::from("/usr/local/lib").into_boxed_path() => &[
+            Token::ByteBuf(b"/usr/local/lib"),
+        ],
     }
     test_cstring {
         CString::new("abc").unwrap() => &[
@@ -1217,13 +1252,13 @@ declare_error_tests! {
         &[
             Token::UnitVariant { name: "Enum", variant: "Foo" },
         ],
-        "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
+        "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`, `SimpleWithSkipped`",
     }
     test_enum_skipped_variant<Enum> {
         &[
             Token::UnitVariant { name: "Enum", variant: "Skipped" },
         ],
-        "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
+        "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`, `SimpleWithSkipped`",
     }
     test_enum_skip_all<EnumSkipAll> {
         &[
@@ -1254,10 +1289,10 @@ declare_error_tests! {
     test_enum_out_of_range<Enum> {
         &[
             Token::Enum { name: "Enum" },
-            Token::U32(4),
+            Token::U32(5),
             Token::Unit,
         ],
-        "invalid value: integer `4`, expected variant index 0 <= i < 4",
+        "invalid value: integer `5`, expected variant index 0 <= i < 5",
     }
     test_short_tuple<(u8, u8, u8)> {
         &[

test_suite/tests/test_ser.rs

@@ -44,6 +44,9 @@ struct Struct {
     c: i32,
 }
 
+#[derive(PartialEq, Debug)]
+struct NotSerializable;
+
 #[derive(Serialize, PartialEq, Debug)]
 enum Enum {
     Unit,
@@ -64,6 +67,7 @@ enum Enum {
         _a: i32,
         _b: i32,
     },
+    OneWithSkipped(#[serde(skip_serializing)] NotSerializable),
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -309,8 +313,13 @@ declare_tests! {
         ],
     }
     test_enum {
-        Enum::Unit => &[Token::UnitVariant { name: "Enum", variant: "Unit" }],
-        Enum::One(42) => &[Token::NewtypeVariant { name: "Enum", variant: "One" }, Token::I32(42)],
+        Enum::Unit => &[
+            Token::UnitVariant { name: "Enum", variant: "Unit" },
+        ],
+        Enum::One(42) => &[
+            Token::NewtypeVariant { name: "Enum", variant: "One" },
+            Token::I32(42),
+        ],
         Enum::Seq(1, 2) => &[
             Token::TupleVariant { name: "Enum", variant: "Seq", len: 2 },
                 Token::I32(1),
@@ -326,6 +335,9 @@ declare_tests! {
                 Token::I32(2),
             Token::StructVariantEnd,
         ],
+        Enum::OneWithSkipped(NotSerializable) => &[
+            Token::UnitVariant { name: "Enum", variant: "OneWithSkipped" },
+        ],
     }
     test_box {
         Box::new(0i32) => &[Token::I32(0)],

test_suite/tests/ui/malformed/cut_off.rs

@@ -0,0 +1,7 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+#[serde(rename =)]
+struct S;
+
+fn main() {}

test_suite/tests/ui/malformed/cut_off.stderr

@@ -0,0 +1,5 @@
+error: unexpected end of input, expected literal
+ --> $DIR/cut_off.rs:4:17
+  |
+4 | #[serde(rename =)]
+  |                 ^

test_suite/tests/ui/malformed/not_list.rs

@@ -0,0 +1,8 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+#[serde]
+#[serde = "?"]
+struct S;
+
+fn main() {}

test_suite/tests/ui/malformed/not_list.stderr

@@ -0,0 +1,11 @@
+error: expected #[serde(...)]
+ --> $DIR/not_list.rs:4:3
+  |
+4 | #[serde]
+  |   ^^^^^
+
+error: expected #[serde(...)]
+ --> $DIR/not_list.rs:5:3
+  |
+5 | #[serde = "?"]
+  |   ^^^^^^^^^^^

test_suite/tests/ui/remote/unknown_field.stderr

@@ -2,7 +2,7 @@ error[E0609]: no field `b` on type `&remote::S`
   --> $DIR/unknown_field.rs:12:5
    |
 12 |     b: u8,
-   |     ^
+   |     ^ help: a field with a similar name exists: `a`
 
 error[E0560]: struct `remote::S` has no field named `b`
   --> $DIR/unknown_field.rs:12:5

test_suite/tests/ui/remote/wrong_getter.stderr

@@ -6,5 +6,3 @@ error[E0308]: mismatched types
    |
    = note: expected type `&u8`
               found type `&u16`
-
-For more information about this error, try `rustc --explain E0308`.