diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-30 18:31:44 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-30 18:31:44 +0000 |
commit | c23a457e72abe608715ac76f076f47dc42af07a5 (patch) | |
tree | 2772049aaf84b5c9d0ed12ec8d86812f7a7904b6 /vendor/serde_derive | |
parent | Releasing progress-linux version 1.73.0+dfsg1-1~progress7.99u1. (diff) | |
download | rustc-c23a457e72abe608715ac76f076f47dc42af07a5.tar.xz rustc-c23a457e72abe608715ac76f076f47dc42af07a5.zip |
Merging upstream version 1.74.1+dfsg1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vendor/serde_derive')
-rw-r--r-- | vendor/serde_derive/.cargo-checksum.json | 2 | ||||
-rw-r--r-- | vendor/serde_derive/Cargo.toml | 15 | ||||
-rw-r--r-- | vendor/serde_derive/README.md | 6 | ||||
-rw-r--r-- | vendor/serde_derive/src/bound.rs | 11 | ||||
-rw-r--r-- | vendor/serde_derive/src/de.rs | 512 | ||||
-rw-r--r-- | vendor/serde_derive/src/dummy.rs | 7 | ||||
-rw-r--r-- | vendor/serde_derive/src/fragment.rs | 2 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/ast.rs | 17 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/attr.rs | 204 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/case.rs | 23 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/check.rs | 46 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/ctxt.rs | 1 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/mod.rs | 11 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/receiver.rs | 4 | ||||
-rw-r--r-- | vendor/serde_derive/src/internals/symbol.rs | 2 | ||||
-rw-r--r-- | vendor/serde_derive/src/lib.rs | 9 | ||||
-rw-r--r-- | vendor/serde_derive/src/pretend.rs | 5 | ||||
-rw-r--r-- | vendor/serde_derive/src/ser.rs | 158 | ||||
-rw-r--r-- | vendor/serde_derive/src/this.rs | 2 | ||||
-rw-r--r-- | vendor/serde_derive/src/try.rs | 24 |
20 files changed, 545 insertions, 516 deletions
diff --git a/vendor/serde_derive/.cargo-checksum.json b/vendor/serde_derive/.cargo-checksum.json index a26efdce1..d9b8ba416 100644 --- a/vendor/serde_derive/.cargo-checksum.json +++ b/vendor/serde_derive/.cargo-checksum.json @@ -1 +1 @@ -{"files":{"Cargo.toml":"b6d33f5823dfd757e7d8f0be8cc237bbb2d8c4a6f4ff3c91aadbbc51e8fa4d81","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"00f425034a43042279478ba3a0826245e39cf7dc6a7497350db1adf2e97a8b34","crates-io.md":"56e988ac4944c45f5bf5051e3827892ed8fb817853d99d9df1fff6621108e270","src/bound.rs":"fee590a67ca956d7a2fca50a2dc069e71d27fa9adacde98670a88245a8841cf6","src/de.rs":"71bab0d455b977e98aad5a433ecfd511b42c94cea6d3961835b92d49e68a17da","src/dummy.rs":"1b7de5bfe1158ea7e70d668d4f76fdccf7f63144ac7869e82e8bf1e7ea0db13c","src/fragment.rs":"5548ba65a53d90a296f60c1328a7a7fb040db467f59c2f5210b2fb320457145d","src/internals/ast.rs":"07dfd9a789cd6268c2cff2889e738193d24e68c93873792a0548d5e6b3c94ca4","src/internals/attr.rs":"55b59fb42ac041ec44c34dfa58e2c11d37783fa4f5200fbd8520fe28d798eff7","src/internals/case.rs":"9492f0c5142d7b7e8cd39c86d13a855e5ce4489425adb2b96aed89e1b7851ac0","src/internals/check.rs":"41f4725b20919b8828850529d8d395dbb55f54ca4069a9cd0bf37109e9b93172","src/internals/ctxt.rs":"c403db8260a533e58af06e8d0a2bb962edb13a250424ab1f1fd2719902affc37","src/internals/mod.rs":"f32138ff19d57eb00f88ba11f6b015efab2102657804f71ebbf386a3698dad91","src/internals/receiver.rs":"6b016351b8294539039095863d8c99e81dd4530d7f769003d12d4ca73cca172c","src/internals/respan.rs":"899753859c58ce5f532a3ec4584796a52f13ed5a0533191e48c953ba5c1b52ff","src/internals/symbol.rs":"2bf0287da64d28da7e8673af60f66aaf6b29efe33131e56b24d6fa55edb533ad","src/lib.rs":"a008b6a91eb5b7bb410283e25b5276a0805c7902954e469c12ee14ed11c44be4","src/pretend.rs":"0e570faf787015535ea6b6683ebc271633c1ca945d3ee1d072c497a1a920c380","src/ser.rs":"e435dc7ef8ee9dca02913f43b4162d22c664061510089745b6278a63df7d30fe","src/this.rs":"a2c128955324c2994ed7cdc3fe4eeceb7ad8a0f9d071665a8378c85c8df64ce2","src/try.rs":"b171b0088c23ebf4bfa07ba457881b41ac5e547d55dd16f737ea988d34badf61"},"package":"389894603bd18c46fa56231694f8d827779c0951a667087194cf9de94ed24682"}
\ No newline at end of file +{"files":{"Cargo.toml":"61f217b58eb183aee7151c47faf2fb2677dd663f0bb0243338c343066d9c5d32","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"c3ece10a36d19b4e857a770eaf74a2164d220f55fa11947065a3898c1697ecef","crates-io.md":"56e988ac4944c45f5bf5051e3827892ed8fb817853d99d9df1fff6621108e270","src/bound.rs":"1b4504ae82ec3dc287eeb4262a57380af484f483c1d6b6c8ebb121370fda135a","src/de.rs":"d82c3bc1c7aec8aa7d513ceae65646421910781a3c277c817cf2e15e8e116dcf","src/dummy.rs":"9533dfee23f20d92ea75734c739022820c2787ded0d54f459feacdeb770ec912","src/fragment.rs":"6757cb4c3131d4300f093572efc273c4ab5a20e3e1efb54a311dcfa52d0bd6eb","src/internals/ast.rs":"7dc997e4090033bbd1d0bdd870e8bb87b096b7f66cfd02047f6b85ebdd569b12","src/internals/attr.rs":"7ec05ffad5b049ba2c91cfb9eedc5d472030682d9c8bcd81040f646525dcc7cd","src/internals/case.rs":"10c8dda2b32d8c6c6b63cf09cdc63d02375af7e95ecefe8fecb34f93b65191bb","src/internals/check.rs":"11275a0889c41323306f5de737f7aacb341adf1dcec298ce40860615be898b3f","src/internals/ctxt.rs":"83a4e6fbe0e439d578478883594407e03f2f340541be479bdf0b04a202633a37","src/internals/mod.rs":"ed021ca635c18132a0e5c3d90f21b7f65def0a61e946421a30200b5b9ab6ad43","src/internals/receiver.rs":"105d72145d1e6a45cdccee3694fcba599ece59194d2e070e8c5669c6f18c81da","src/internals/respan.rs":"899753859c58ce5f532a3ec4584796a52f13ed5a0533191e48c953ba5c1b52ff","src/internals/symbol.rs":"d619e88caa3c7a09b03014257f2b349ee922290062d9b97b4dd19d0e64532690","src/lib.rs":"29f5b1c463429105c3529a8c02354d5f4117174928055f5efc98886aa8a0e94c","src/pretend.rs":"2c79785bc42e975534d7d88c04b46377cefd3db948b63a32234707531c55b099","src/ser.rs":"e3341471cea9d7e2fb4043e5d1746862beb9a4e25196170879eeac529d460920","src/this.rs":"87818dc80cbb521b51938a653d09daf10aafc220bb10425948de82ad670fcb85"},"package":"4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"}
\ No newline at end of file diff --git a/vendor/serde_derive/Cargo.toml b/vendor/serde_derive/Cargo.toml index f233cd751..c0e181032 100644 --- a/vendor/serde_derive/Cargo.toml +++ b/vendor/serde_derive/Cargo.toml @@ -12,19 +12,11 @@ [package] rust-version = "1.56" name = "serde_derive" -version = "1.0.171" +version = "1.0.188" authors = [ "Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>", ] -include = [ - "build.rs", - "src/**/*.rs", - "crates-io.md", - "README.md", - "LICENSE-APACHE", - "LICENSE-MIT", -] description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]" homepage = "https://serde.rs" documentation = "https://serde.rs/derive.html" @@ -43,6 +35,7 @@ license = "MIT OR Apache-2.0" repository = "https://github.com/serde-rs/serde" [package.metadata.docs.rs] +rustdoc-args = ["--generate-link-to-definition"] targets = ["x86_64-unknown-linux-gnu"] [lib] @@ -56,10 +49,10 @@ version = "1.0" version = "1.0" [dependencies.syn] -version = "2.0.25" +version = "2.0.28" [dev-dependencies.serde] -version = "1.0" +version = "1" [features] default = [] diff --git a/vendor/serde_derive/README.md b/vendor/serde_derive/README.md index a049250b6..477fd3647 100644 --- a/vendor/serde_derive/README.md +++ b/vendor/serde_derive/README.md @@ -1,12 +1,12 @@ -# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.56+]][Rust 1.56] +# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.31+]][Rust 1.31] [![serde_derive: rustc 1.56+]][Rust 1.56] [Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master [actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster [Latest Version]: https://img.shields.io/crates/v/serde.svg [crates.io]: https://crates.io/crates/serde -[serde: rustc 1.19+]: https://img.shields.io/badge/serde-rustc_1.19+-lightgray.svg +[serde: rustc 1.31+]: https://img.shields.io/badge/serde-rustc_1.31+-lightgray.svg [serde_derive: rustc 1.56+]: https://img.shields.io/badge/serde_derive-rustc_1.56+-lightgray.svg -[Rust 1.19]: https://blog.rust-lang.org/2017/07/20/Rust-1.19.html +[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html [Rust 1.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.** diff --git a/vendor/serde_derive/src/bound.rs b/vendor/serde_derive/src/bound.rs index a38e7c2b5..dd51e6898 100644 --- a/vendor/serde_derive/src/bound.rs +++ b/vendor/serde_derive/src/bound.rs @@ -1,12 +1,9 @@ +use crate::internals::ast::{Container, Data}; +use crate::internals::{attr, ungroup}; +use proc_macro2::Span; use std::collections::HashSet; - -use syn; use syn::punctuated::{Pair, Punctuated}; - -use internals::ast::{Container, Data}; -use internals::{attr, ungroup}; - -use proc_macro2::Span; +use syn::Token; // Remove the default from every type parameter because in the generated impls // they look like associated types: "error: associated type bindings are not diff --git a/vendor/serde_derive/src/de.rs b/vendor/serde_derive/src/de.rs index cb98b8ea2..ee8a23766 100644 --- a/vendor/serde_derive/src/de.rs +++ b/vendor/serde_derive/src/de.rs @@ -1,19 +1,14 @@ +use crate::fragment::{Expr, Fragment, Match, Stmts}; +use crate::internals::ast::{Container, Data, Field, Style, Variant}; +use crate::internals::{attr, replace_receiver, ungroup, Ctxt, Derive}; +use crate::{bound, dummy, pretend, this}; use proc_macro2::{Literal, Span, TokenStream}; -use quote::ToTokens; -use syn::punctuated::Punctuated; -use syn::spanned::Spanned; -use syn::{self, Ident, Index, Member}; - -use bound; -use dummy; -use fragment::{Expr, Fragment, Match, Stmts}; -use internals::ast::{Container, Data, Field, Style, Variant}; -use internals::{attr, replace_receiver, ungroup, Ctxt, Derive}; -use pretend; -use this; - +use quote::{quote, quote_spanned, ToTokens}; use std::collections::BTreeSet; use std::ptr; +use syn::punctuated::Punctuated; +use syn::spanned::Spanned; +use syn::{parse_quote, Ident, Index, Member}; pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> { replace_receiver(input); @@ -322,10 +317,10 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St let code = match &cont.data { Data::Struct(Style::Struct, fields) => { - deserialize_struct_in_place(None, params, fields, &cont.attrs, None)? + deserialize_struct_in_place(params, fields, &cont.attrs)? } Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => { - deserialize_tuple_in_place(None, params, fields, &cont.attrs, None) + deserialize_tuple_in_place(params, fields, &cont.attrs) } Data::Enum(_) | Data::Struct(Style::Unit, _) => { return None; @@ -580,11 +575,9 @@ fn deserialize_tuple( #[cfg(feature = "deserialize_in_place")] fn deserialize_tuple_in_place( - variant_ident: Option<syn::Ident>, params: &Parameters, fields: &[Field], cattrs: &attr::Container, - deserializer: Option<TokenStream>, ) -> Fragment { assert!(!cattrs.has_flatten()); @@ -598,17 +591,25 @@ fn deserialize_tuple_in_place( split_with_de_lifetime(params); let delife = params.borrowed.de_lifetime(); - let is_enum = variant_ident.is_some(); - let expecting = match variant_ident { - Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident), - None => format!("tuple struct {}", params.type_name()), - }; + let expecting = format!("tuple struct {}", params.type_name()); let expecting = cattrs.expecting().unwrap_or(&expecting); let nfields = fields.len(); - let visit_newtype_struct = if !is_enum && nfields == 1 { - Some(deserialize_newtype_struct_in_place(params, &fields[0])) + let visit_newtype_struct = if nfields == 1 { + // We do not generate deserialize_in_place if every field has a + // deserialize_with. + assert!(fields[0].attrs.deserialize_with().is_none()); + + Some(quote! { + #[inline] + fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error> + where + __E: _serde::Deserializer<#delife>, + { + _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0) + } + }) } else { None }; @@ -622,15 +623,10 @@ fn deserialize_tuple_in_place( } }; - let dispatch = if let Some(deserializer) = deserializer { - quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #field_count, #visitor_expr)) - } else if is_enum { - quote!(_serde::de::VariantAccess::tuple_variant(__variant, #field_count, #visitor_expr)) - } else if nfields == 1 { - let type_name = cattrs.name().deserialize_name(); + let type_name = cattrs.name().deserialize_name(); + let dispatch = if nfields == 1 { quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr)) } else { - let type_name = cattrs.name().deserialize_name(); quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #field_count, #visitor_expr)) }; @@ -708,31 +704,23 @@ fn deserialize_seq( let span = field.original.span(); let func = quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>); - quote!(try!(#func(&mut __seq))) + quote!(#func(&mut __seq)?) } Some(path) => { let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path); quote!({ #wrapper _serde::__private::Option::map( - try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)), + _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)?, |__wrap| __wrap.value) }) } }; - let value_if_none = match field.attrs.default() { - attr::Default::Default => quote!(_serde::__private::Default::default()), - attr::Default::Path(path) => quote!(#path()), - attr::Default::None => quote!( - return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting)); - ), - }; + let value_if_none = expr_is_missing_seq(None, index_in_seq, field, cattrs, expecting); let assign = quote! { let #var = match #visit { _serde::__private::Some(__value) => __value, - _serde::__private::None => { - #value_if_none - } + _serde::__private::None => #value_if_none, }; }; index_in_seq += 1; @@ -808,24 +796,14 @@ fn deserialize_seq_in_place( self.place.#member = #default; } } else { - let value_if_none = match field.attrs.default() { - attr::Default::Default => quote!( - self.place.#member = _serde::__private::Default::default(); - ), - attr::Default::Path(path) => quote!( - self.place.#member = #path(); - ), - attr::Default::None => quote!( - return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting)); - ), - }; + let value_if_none = expr_is_missing_seq(Some(quote!(self.place.#member = )), index_in_seq, field, cattrs, expecting); let write = match field.attrs.deserialize_with() { None => { quote! { - if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq, - _serde::__private::de::InPlaceSeed(&mut self.place.#member))) + if let _serde::__private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq, + _serde::__private::de::InPlaceSeed(&mut self.place.#member))? { - #value_if_none + #value_if_none; } } } @@ -833,12 +811,12 @@ fn deserialize_seq_in_place( let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path); quote!({ #wrapper - match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) { + match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)? { _serde::__private::Some(__wrap) => { self.place.#member = __wrap.value; } _serde::__private::None => { - #value_if_none + #value_if_none; } } }) @@ -885,12 +863,12 @@ fn deserialize_newtype_struct( let span = field.original.span(); let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize); quote! { - try!(#func(__e)) + #func(__e)? } } Some(path) => { quote! { - try!(#path(__e)) + #path(__e)? } } }; @@ -916,25 +894,6 @@ fn deserialize_newtype_struct( } } -#[cfg(feature = "deserialize_in_place")] -fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> TokenStream { - // We do not generate deserialize_in_place if every field has a - // deserialize_with. - assert!(field.attrs.deserialize_with().is_none()); - - let delife = params.borrowed.de_lifetime(); - - quote! { - #[inline] - fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error> - where - __E: _serde::Deserializer<#delife>, - { - _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0) - } - } -} - enum StructForm<'a> { Struct, /// Contains a variant name @@ -999,12 +958,7 @@ fn deserialize_struct( ) }) .collect(); - let field_visitor = Stmts(deserialize_generated_identifier( - &field_names_idents, - cattrs, - false, - None, - )); + let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs); // untagged struct variants do not get a visit_seq method. The same applies to // structs that only have a map representation. @@ -1056,7 +1010,7 @@ fn deserialize_struct( } else { let field_names = field_names_idents .iter() - .flat_map(|(_, _, aliases)| aliases); + .flat_map(|&(_, _, aliases)| aliases); Some(quote! { #[doc(hidden)] @@ -1131,14 +1085,10 @@ fn deserialize_struct( #[cfg(feature = "deserialize_in_place")] fn deserialize_struct_in_place( - variant_ident: Option<syn::Ident>, params: &Parameters, fields: &[Field], cattrs: &attr::Container, - deserializer: Option<TokenStream>, ) -> Option<Fragment> { - let is_enum = variant_ident.is_some(); - // for now we do not support in_place deserialization for structs that // are represented as map. if cattrs.has_flatten() { @@ -1150,58 +1100,35 @@ fn deserialize_struct_in_place( split_with_de_lifetime(params); let delife = params.borrowed.de_lifetime(); - let expecting = match variant_ident { - Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident), - None => format!("struct {}", params.type_name()), - }; + let expecting = format!("struct {}", params.type_name()); let expecting = cattrs.expecting().unwrap_or(&expecting); - let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting)); - - let (field_visitor, fields_stmt, visit_map) = - deserialize_struct_as_struct_in_place_visitor(params, fields, cattrs); - - let field_visitor = Stmts(field_visitor); - let fields_stmt = Stmts(fields_stmt); - let visit_map = Stmts(visit_map); + let field_names_idents: Vec<_> = fields + .iter() + .enumerate() + .filter(|&(_, field)| !field.attrs.skip_deserializing()) + .map(|(i, field)| { + ( + field.attrs.name().deserialize_name(), + field_i(i), + field.attrs.aliases(), + ) + }) + .collect(); - let visitor_expr = quote! { - __Visitor { - place: __place, - lifetime: _serde::__private::PhantomData, - } - }; - let dispatch = if let Some(deserializer) = deserializer { - quote! { - _serde::Deserializer::deserialize_any(#deserializer, #visitor_expr) - } - } else if is_enum { - quote! { - _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr) - } - } else { - let type_name = cattrs.name().deserialize_name(); - quote! { - _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr) - } - }; + let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs); - let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing()); - let visitor_var = if all_skipped { + let mut_seq = if field_names_idents.is_empty() { quote!(_) } else { quote!(mut __seq) }; - - let visit_seq = quote! { - #[inline] - fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error> - where - __A: _serde::de::SeqAccess<#delife>, - { - #visit_seq - } - }; + let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting)); + let visit_map = Stmts(deserialize_map_in_place(params, fields, cattrs)); + let field_names = field_names_idents + .iter() + .flat_map(|&(_, _, aliases)| aliases); + let type_name = cattrs.name().deserialize_name(); let in_place_impl_generics = de_impl_generics.in_place(); let in_place_ty_generics = de_ty_generics.in_place(); @@ -1223,7 +1150,13 @@ fn deserialize_struct_in_place( _serde::__private::Formatter::write_str(__formatter, #expecting) } - #visit_seq + #[inline] + fn visit_seq<__A>(self, #mut_seq: __A) -> _serde::__private::Result<Self::Value, __A::Error> + where + __A: _serde::de::SeqAccess<#delife>, + { + #visit_seq + } #[inline] fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error> @@ -1234,9 +1167,13 @@ fn deserialize_struct_in_place( } } - #fields_stmt + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ #(#field_names),* ]; - #dispatch + _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, __Visitor { + place: __place, + lifetime: _serde::__private::PhantomData, + }) }) } @@ -1293,7 +1230,12 @@ fn prepare_enum_variant_enum( }) .collect(); - let other_idx = deserialized_variants.position(|(_, variant)| variant.attrs.other()); + let fallthrough = deserialized_variants + .position(|(_, variant)| variant.attrs.other()) + .map(|other_idx| { + let ignore_variant = variant_names_idents[other_idx].1.clone(); + quote!(_serde::__private::Ok(__Field::#ignore_variant)) + }); let variants_stmt = { let variant_names = variant_names_idents.iter().map(|(name, _, _)| name); @@ -1307,7 +1249,8 @@ fn prepare_enum_variant_enum( &variant_names_idents, cattrs, true, - other_idx, + None, + fallthrough, )); (variants_stmt, variant_visitor) @@ -1362,7 +1305,7 @@ fn deserialize_externally_tagged_enum( } } else { quote! { - match try!(_serde::de::EnumAccess::variant(__data)) { + match _serde::de::EnumAccess::variant(__data)? { #(#variant_arms)* } } @@ -1442,9 +1385,9 @@ fn deserialize_internally_tagged_enum( #variants_stmt - let (__tag, __content) = try!(_serde::Deserializer::deserialize_any( + let (__tag, __content) = _serde::Deserializer::deserialize_any( __deserializer, - _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))); + _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?; let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content); match __tag { @@ -1488,7 +1431,8 @@ fn deserialize_adjacently_tagged_enum( }) .collect(); - let expecting = format!("adjacently tagged enum {}", params.type_name()); + let rust_name = params.type_name(); + let expecting = format!("adjacently tagged enum {}", rust_name); let expecting = cattrs.expecting().unwrap_or(&expecting); let type_name = cattrs.name().deserialize_name(); let deny_unknown_fields = cattrs.deny_unknown_fields(); @@ -1508,6 +1452,14 @@ fn deserialize_adjacently_tagged_enum( } }; + let variant_seed = quote! { + _serde::__private::de::AdjacentlyTaggedEnumVariantSeed::<__Field> { + enum_name: #rust_name, + variants: VARIANTS, + fields_enum: _serde::__private::PhantomData + } + }; + let mut missing_content = quote! { _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#content)) }; @@ -1552,7 +1504,11 @@ fn deserialize_adjacently_tagged_enum( // Advance the map by one key, returning early in case of error. let next_key = quote! { - try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content)) + _serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content)? + }; + + let variant_from_map = quote! { + _serde::de::MapAccess::next_value_seed(&mut __map, #variant_seed)? }; // When allowing unknown fields, we want to transparently step through keys @@ -1565,7 +1521,7 @@ fn deserialize_adjacently_tagged_enum( while let _serde::__private::Some(__k) = #next_key { match __k { _serde::__private::de::TagContentOtherField::Other => { - let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); + let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; continue; }, _serde::__private::de::TagContentOtherField::Tag => { @@ -1600,14 +1556,14 @@ fn deserialize_adjacently_tagged_enum( let finish_content_then_tag = if variant_arms.is_empty() { quote! { - match try!(_serde::de::MapAccess::next_value::<__Field>(&mut __map)) {} + match #variant_from_map {} } } else { quote! { - let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) { + let __ret = match #variant_from_map { // Deserialize the buffered content now that we know the variant. #(#variant_arms)* - }); + }?; // Visit remaining keys, looking for duplicates. #visit_remaining_keys } @@ -1660,7 +1616,7 @@ fn deserialize_adjacently_tagged_enum( // First key is the tag. _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => { // Parse the tag. - let __field = try!(_serde::de::MapAccess::next_value(&mut __map)); + let __field = #variant_from_map; // Visit the second key. match #next_relevant_key { // Second key is a duplicate of the tag. @@ -1669,12 +1625,12 @@ fn deserialize_adjacently_tagged_enum( } // Second key is the content. _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => { - let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map, + let __ret = _serde::de::MapAccess::next_value_seed(&mut __map, __Seed { field: __field, marker: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData, - })); + })?; // Visit remaining keys, looking for duplicates. #visit_remaining_keys } @@ -1685,7 +1641,7 @@ fn deserialize_adjacently_tagged_enum( // First key is the content. _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => { // Buffer up the content. - let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map)); + let __content = _serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map)?; // Visit the second key. match #next_relevant_key { // Second key is the tag. @@ -1715,17 +1671,17 @@ fn deserialize_adjacently_tagged_enum( __A: _serde::de::SeqAccess<#delife>, { // Visit the first element - the tag. - match try!(_serde::de::SeqAccess::next_element(&mut __seq)) { + match _serde::de::SeqAccess::next_element(&mut __seq)? { _serde::__private::Some(__field) => { // Visit the second element - the content. - match try!(_serde::de::SeqAccess::next_element_seed( + match _serde::de::SeqAccess::next_element_seed( &mut __seq, __Seed { field: __field, marker: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData, }, - )) { + )? { _serde::__private::Some(__ret) => _serde::__private::Ok(__ret), // There is no second element. _serde::__private::None => { @@ -1795,7 +1751,7 @@ fn deserialize_untagged_enum_after( let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg); quote_block! { - let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)); + let __content = <_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)?; let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content); #( @@ -1828,7 +1784,7 @@ fn deserialize_externally_tagged_variant( Style::Unit => { let this_value = ¶ms.this_value; quote_block! { - try!(_serde::de::VariantAccess::unit_variant(__variant)); + _serde::de::VariantAccess::unit_variant(__variant)?; _serde::__private::Ok(#this_value::#variant_ident) } } @@ -1877,7 +1833,7 @@ fn deserialize_internally_tagged_variant( quote!((#default)) }); quote_block! { - try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))); + _serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?; _serde::__private::Ok(#this_value::#variant_ident #default) } } @@ -1963,7 +1919,7 @@ fn deserialize_externally_tagged_newtype_variant( if field.attrs.skip_deserializing() { let default = Expr(expr_is_missing(field, cattrs)); return quote_block! { - try!(_serde::de::VariantAccess::unit_variant(__variant)); + _serde::de::VariantAccess::unit_variant(__variant)?; _serde::__private::Ok(#this_value::#variant_ident(#default)) }; } @@ -2016,30 +1972,15 @@ fn deserialize_untagged_newtype_variant( } fn deserialize_generated_identifier( - fields: &[(String, Ident, Vec<String>)], + fields: &[(&str, Ident, &BTreeSet<String>)], cattrs: &attr::Container, is_variant: bool, - other_idx: Option<usize>, + ignore_variant: Option<TokenStream>, + fallthrough: Option<TokenStream>, ) -> Fragment { let this_value = quote!(__Field); 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>),); - let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value))); - (Some(ignore_variant), Some(fallthrough)) - } else if let Some(other_idx) = other_idx { - let ignore_variant = fields[other_idx].1.clone(); - let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant)); - (None, Some(fallthrough)) - } else if is_variant || cattrs.deny_unknown_fields() { - (None, None) - } else { - let ignore_variant = quote!(__ignore,); - let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore)); - (Some(ignore_variant), Some(fallthrough)) - }; - let visitor_impl = Stmts(deserialize_identifier( &this_value, fields, @@ -2085,6 +2026,33 @@ fn deserialize_generated_identifier( } } +/// Generates enum and its `Deserialize` implementation that represents each +/// non-skipped field of the struct +fn deserialize_field_identifier( + fields: &[(&str, Ident, &BTreeSet<String>)], + cattrs: &attr::Container, +) -> Stmts { + let (ignore_variant, fallthrough) = if cattrs.has_flatten() { + let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),); + let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value))); + (Some(ignore_variant), Some(fallthrough)) + } else if cattrs.deny_unknown_fields() { + (None, None) + } else { + let ignore_variant = quote!(__ignore,); + let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore)); + (Some(ignore_variant), Some(fallthrough)) + }; + + Stmts(deserialize_generated_identifier( + fields, + cattrs, + false, + ignore_variant, + fallthrough, + )) +} + // Generates `Deserialize::deserialize` body for an enum with // `serde(field_identifier)` or `serde(variant_identifier)` attribute. fn deserialize_custom_identifier( @@ -2146,7 +2114,7 @@ fn deserialize_custom_identifier( }) .collect(); - let names = names_idents.iter().map(|(name, _, _)| name); + let names = names_idents.iter().flat_map(|&(_, _, aliases)| aliases); let names_const = if fallthrough.is_some() { None @@ -2202,32 +2170,24 @@ fn deserialize_custom_identifier( fn deserialize_identifier( this_value: &TokenStream, - fields: &[(String, Ident, Vec<String>)], + fields: &[(&str, Ident, &BTreeSet<String>)], is_variant: bool, fallthrough: Option<TokenStream>, fallthrough_borrowed: Option<TokenStream>, collect_other_fields: bool, expecting: Option<&str>, ) -> Fragment { - let mut flat_fields = Vec::new(); - for (_, ident, aliases) in fields { - flat_fields.extend(aliases.iter().map(|alias| (alias, ident))); - } - - let field_strs: &Vec<_> = &flat_fields.iter().map(|(name, _)| name).collect(); - let field_bytes: &Vec<_> = &flat_fields - .iter() - .map(|(name, _)| Literal::byte_string(name.as_bytes())) - .collect(); - - let constructors: &Vec<_> = &flat_fields - .iter() - .map(|(_, ident)| quote!(#this_value::#ident)) - .collect(); - let main_constructors: &Vec<_> = &fields - .iter() - .map(|(_, ident, _)| quote!(#this_value::#ident)) - .collect(); + let str_mapping = fields.iter().map(|(_, ident, aliases)| { + // `aliases` also contains a main name + quote!(#(#aliases)|* => _serde::__private::Ok(#this_value::#ident)) + }); + let bytes_mapping = fields.iter().map(|(_, ident, aliases)| { + // `aliases` also contains a main name + let aliases = aliases + .iter() + .map(|alias| Literal::byte_string(alias.as_bytes())); + quote!(#(#aliases)|* => _serde::__private::Ok(#this_value::#ident)) + }); let expecting = expecting.unwrap_or(if is_variant { "variant identifier" @@ -2235,8 +2195,6 @@ fn deserialize_identifier( "field identifier" }); - let index_expecting = if is_variant { "variant" } else { "field" }; - let bytes_to_str = if fallthrough.is_some() || collect_other_fields { None } else { @@ -2284,21 +2242,6 @@ fn deserialize_identifier( &fallthrough_arm_tokens }; - let u64_fallthrough_arm_tokens; - let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough { - fallthrough - } else { - let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len()); - u64_fallthrough_arm_tokens = quote! { - _serde::__private::Err(_serde::de::Error::invalid_value( - _serde::de::Unexpected::Unsigned(__value), - &#fallthrough_msg, - )) - }; - &u64_fallthrough_arm_tokens - }; - - let variant_indices = 0_u64..; let visit_other = if collect_other_fields { quote! { fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E> @@ -2393,15 +2336,33 @@ fn deserialize_identifier( } } } else { + let u64_mapping = fields.iter().enumerate().map(|(i, (_, ident, _))| { + let i = i as u64; + quote!(#i => _serde::__private::Ok(#this_value::#ident)) + }); + + let u64_fallthrough_arm_tokens; + let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough { + fallthrough + } else { + let index_expecting = if is_variant { "variant" } else { "field" }; + let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len()); + u64_fallthrough_arm_tokens = quote! { + _serde::__private::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &#fallthrough_msg, + )) + }; + &u64_fallthrough_arm_tokens + }; + quote! { fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E> where __E: _serde::de::Error, { match __value { - #( - #variant_indices => _serde::__private::Ok(#main_constructors), - )* + #(#u64_mapping,)* _ => #u64_fallthrough_arm, } } @@ -2409,6 +2370,8 @@ fn deserialize_identifier( }; let visit_borrowed = if fallthrough_borrowed.is_some() || collect_other_fields { + let str_mapping = str_mapping.clone(); + let bytes_mapping = bytes_mapping.clone(); let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(fallthrough_arm); Some(quote! { fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E> @@ -2416,9 +2379,7 @@ fn deserialize_identifier( __E: _serde::de::Error, { match __value { - #( - #field_strs => _serde::__private::Ok(#constructors), - )* + #(#str_mapping,)* _ => { #value_as_borrowed_str_content #fallthrough_borrowed_arm @@ -2431,9 +2392,7 @@ fn deserialize_identifier( __E: _serde::de::Error, { match __value { - #( - #field_bytes => _serde::__private::Ok(#constructors), - )* + #(#bytes_mapping,)* _ => { #bytes_to_str #value_as_borrowed_bytes_content @@ -2458,9 +2417,7 @@ fn deserialize_identifier( __E: _serde::de::Error, { match __value { - #( - #field_strs => _serde::__private::Ok(#constructors), - )* + #(#str_mapping,)* _ => { #value_as_str_content #fallthrough_arm @@ -2473,9 +2430,7 @@ fn deserialize_identifier( __E: _serde::de::Error, { match __value { - #( - #field_bytes => _serde::__private::Ok(#constructors), - )* + #(#bytes_mapping,)* _ => { #bytes_to_str #value_as_bytes_content @@ -2538,7 +2493,7 @@ fn deserialize_map( let func = quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>); quote! { - try!(#func(&mut __map)) + #func(&mut __map)? } } Some(path) => { @@ -2570,14 +2525,14 @@ fn deserialize_map( __Field::__other(__name) => { __collect.push(_serde::__private::Some(( __name, - try!(_serde::de::MapAccess::next_value(&mut __map))))); + _serde::de::MapAccess::next_value(&mut __map)?))); } }) } else if cattrs.deny_unknown_fields() { None } else { Some(quote! { - _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); } + _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; } }) }; @@ -2585,14 +2540,14 @@ fn deserialize_map( let match_keys = if cattrs.deny_unknown_fields() && all_skipped { quote! { // FIXME: Once feature(exhaustive_patterns) is stable: - // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map)); + // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?; _serde::__private::Option::map( - try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)), + _serde::de::MapAccess::next_key::<__Field>(&mut __map)?, |__impossible| match __impossible {}); } } else { quote! { - while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? { match __key { #(#value_arms)* #ignored_arm @@ -2628,10 +2583,10 @@ fn deserialize_map( Some(path) => quote!(#path), }; quote! { - let #name: #field_ty = try!(#func( + let #name: #field_ty = #func( _serde::__private::de::FlatMapDeserializer( &mut __collect, - _serde::__private::PhantomData))); + _serde::__private::PhantomData))?; } }); @@ -2706,42 +2661,6 @@ fn deserialize_map( } #[cfg(feature = "deserialize_in_place")] -fn deserialize_struct_as_struct_in_place_visitor( - params: &Parameters, - fields: &[Field], - cattrs: &attr::Container, -) -> (Fragment, Fragment, Fragment) { - assert!(!cattrs.has_flatten()); - - let field_names_idents: Vec<_> = fields - .iter() - .enumerate() - .filter(|&(_, field)| !field.attrs.skip_deserializing()) - .map(|(i, field)| { - ( - field.attrs.name().deserialize_name(), - field_i(i), - field.attrs.aliases(), - ) - }) - .collect(); - - let fields_stmt = { - let field_names = field_names_idents.iter().map(|(name, _, _)| name); - quote_block! { - #[doc(hidden)] - const FIELDS: &'static [&'static str] = &[ #(#field_names),* ]; - } - }; - - let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None); - - let visit_map = deserialize_map_in_place(params, fields, cattrs); - - (field_visitor, fields_stmt, visit_map) -} - -#[cfg(feature = "deserialize_in_place")] fn deserialize_map_in_place( params: &Parameters, fields: &[Field], @@ -2778,7 +2697,7 @@ fn deserialize_map_in_place( let visit = match field.attrs.deserialize_with() { None => { quote! { - try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))) + _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))? } } Some(path) => { @@ -2810,7 +2729,7 @@ fn deserialize_map_in_place( None } else { Some(quote! { - _ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); } + _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; } }) }; @@ -2819,14 +2738,14 @@ fn deserialize_map_in_place( let match_keys = if cattrs.deny_unknown_fields() && all_skipped { quote! { // FIXME: Once feature(exhaustive_patterns) is stable: - // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map)); + // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?; _serde::__private::Option::map( - try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)), + _serde::de::MapAccess::next_key::<__Field>(&mut __map)?, |__impossible| match __impossible {}); } } else { quote! { - while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? { match __key { #(#value_arms_from)* #ignored_arm @@ -2923,7 +2842,7 @@ fn wrap_deserialize_with( __D: _serde::Deserializer<#delife>, { _serde::__private::Ok(__DeserializeWith { - value: try!(#deserialize_with(__deserializer)), + value: #deserialize_with(__deserializer)?, phantom: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData, }) @@ -3033,7 +2952,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment { let span = field.original.span(); let func = quote_spanned!(span=> _serde::__private::de::missing_field); quote_expr! { - try!(#func(#name)) + #func(#name)? } } Some(_) => { @@ -3044,6 +2963,35 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment { } } +fn expr_is_missing_seq( + assign_to: Option<TokenStream>, + index: usize, + field: &Field, + cattrs: &attr::Container, + expecting: &str, +) -> TokenStream { + match field.attrs.default() { + attr::Default::Default => { + let span = field.original.span(); + return quote_spanned!(span=> #assign_to _serde::__private::Default::default()); + } + attr::Default::Path(path) => { + return quote_spanned!(path.span()=> #assign_to #path()); + } + attr::Default::None => { /* below */ } + } + + match *cattrs.default() { + attr::Default::Default | attr::Default::Path(_) => { + let member = &field.member; + quote!(#assign_to __default.#member) + } + attr::Default::None => quote!( + return _serde::__private::Err(_serde::de::Error::invalid_length(#index, &#expecting)) + ), + } +} + fn effective_style(variant: &Variant) -> Style { match variant.style { Style::Newtype if variant.fields[0].attrs.skip_deserializing() => Style::Unit, diff --git a/vendor/serde_derive/src/dummy.rs b/vendor/serde_derive/src/dummy.rs index 57e8eabf2..095f950f3 100644 --- a/vendor/serde_derive/src/dummy.rs +++ b/vendor/serde_derive/src/dummy.rs @@ -1,11 +1,7 @@ use proc_macro2::TokenStream; - -use syn; -use try; +use quote::quote; pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream { - let try_replacement = try::replacement(); - let use_serde = match serde_path { Some(path) => quote! { use #path as _serde; @@ -21,7 +17,6 @@ pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> Token #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] const _: () = { #use_serde - #try_replacement #code }; } diff --git a/vendor/serde_derive/src/fragment.rs b/vendor/serde_derive/src/fragment.rs index 324504aa4..6627c2669 100644 --- a/vendor/serde_derive/src/fragment.rs +++ b/vendor/serde_derive/src/fragment.rs @@ -1,6 +1,6 @@ use proc_macro2::TokenStream; use quote::ToTokens; -use syn::token; +use syn::{token, Token}; pub enum Fragment { /// Tokens that can be used as an expression. diff --git a/vendor/serde_derive/src/internals/ast.rs b/vendor/serde_derive/src/internals/ast.rs index 8bcb0ecd1..a28d3ae7e 100644 --- a/vendor/serde_derive/src/internals/ast.rs +++ b/vendor/serde_derive/src/internals/ast.rs @@ -1,10 +1,8 @@ //! A Serde ast, parsed from the Syn ast and ready to generate Rust code. -use internals::attr; -use internals::check; -use internals::{Ctxt, Derive}; -use syn; +use crate::internals::{attr, check, Ctxt, Derive}; use syn::punctuated::Punctuated; +use syn::Token; /// A source data structure annotated with `#[derive(Serialize)]` and/or `#[derive(Deserialize)]`, /// parsed into an internal representation. @@ -88,9 +86,12 @@ impl<'a> Container<'a> { if field.attrs.flatten() { has_flatten = true; } - field - .attrs - .rename_by_rules(variant.attrs.rename_all_rules()); + field.attrs.rename_by_rules( + variant + .attrs + .rename_all_rules() + .or(attrs.rename_all_fields_rules()), + ); } } } @@ -121,7 +122,7 @@ impl<'a> Container<'a> { } impl<'a> Data<'a> { - pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> { + pub fn all_fields(&'a self) -> Box<dyn Iterator<Item = &'a Field<'a>> + 'a> { match self { Data::Enum(variants) => { Box::new(variants.iter().flat_map(|variant| variant.fields.iter())) diff --git a/vendor/serde_derive/src/internals/attr.rs b/vendor/serde_derive/src/internals/attr.rs index 42212a64d..0b25c7c0d 100644 --- a/vendor/serde_derive/src/internals/attr.rs +++ b/vendor/serde_derive/src/internals/attr.rs @@ -1,15 +1,14 @@ -use internals::symbol::*; -use internals::{ungroup, Ctxt}; +use crate::internals::symbol::*; +use crate::internals::{ungroup, Ctxt}; use proc_macro2::{Spacing, Span, TokenStream, TokenTree}; use quote::ToTokens; use std::borrow::Cow; use std::collections::BTreeSet; use std::iter::FromIterator; -use syn; use syn::meta::ParseNestedMeta; use syn::parse::ParseStream; use syn::punctuated::Punctuated; -use syn::{token, Ident, Lifetime}; +use syn::{parse_quote, token, Ident, Lifetime, Token}; // This module handles parsing of `#[serde(...)]` attributes. The entrypoints // are `attr::Container::from_ast`, `attr::Variant::from_ast`, and @@ -19,7 +18,7 @@ use syn::{token, Ident, Lifetime}; // user will see errors simultaneously for all bad attributes in the crate // rather than just the first. -pub use internals::case::RenameRule; +pub use crate::internals::case::RenameRule; struct Attr<'c, T> { cx: &'c Ctxt, @@ -135,7 +134,7 @@ pub struct Name { serialize_renamed: bool, deserialize: String, deserialize_renamed: bool, - deserialize_aliases: Vec<String>, + deserialize_aliases: BTreeSet<String>, } fn unraw(ident: &Ident) -> String { @@ -149,16 +148,12 @@ impl Name { de_name: Attr<String>, de_aliases: Option<VecAttr<String>>, ) -> Name { - let deserialize_aliases = match de_aliases { - Some(de_aliases) => { - let mut alias_list = BTreeSet::new(); - for alias_name in de_aliases.get() { - alias_list.insert(alias_name); - } - alias_list.into_iter().collect() + let mut alias_set = BTreeSet::new(); + if let Some(de_aliases) = de_aliases { + for alias_name in de_aliases.get() { + alias_set.insert(alias_name); } - None => Vec::new(), - }; + } let ser_name = ser_name.get(); let ser_renamed = ser_name.is_some(); @@ -169,35 +164,42 @@ impl Name { serialize_renamed: ser_renamed, deserialize: de_name.unwrap_or(source_name), deserialize_renamed: de_renamed, - deserialize_aliases, + deserialize_aliases: alias_set, } } /// Return the container name for the container when serializing. - pub fn serialize_name(&self) -> String { - self.serialize.clone() + pub fn serialize_name(&self) -> &str { + &self.serialize } /// Return the container name for the container when deserializing. - pub fn deserialize_name(&self) -> String { - self.deserialize.clone() + pub fn deserialize_name(&self) -> &str { + &self.deserialize } - fn deserialize_aliases(&self) -> Vec<String> { - let mut aliases = self.deserialize_aliases.clone(); - let main_name = self.deserialize_name(); - if !aliases.contains(&main_name) { - aliases.push(main_name); - } - aliases + fn deserialize_aliases(&self) -> &BTreeSet<String> { + &self.deserialize_aliases } } +#[derive(Copy, Clone)] pub struct RenameAllRules { serialize: RenameRule, deserialize: RenameRule, } +impl RenameAllRules { + /// Returns a new `RenameAllRules` with the individual rules of `self` and + /// `other_rules` joined by `RenameRules::or`. + pub fn or(self, other_rules: Self) -> Self { + Self { + serialize: self.serialize.or(other_rules.serialize), + deserialize: self.deserialize.or(other_rules.deserialize), + } + } +} + /// Represents struct or enum attribute information. pub struct Container { name: Name, @@ -205,6 +207,7 @@ pub struct Container { deny_unknown_fields: bool, default: Default, rename_all_rules: RenameAllRules, + rename_all_fields_rules: RenameAllRules, ser_bound: Option<Vec<syn::WherePredicate>>, de_bound: Option<Vec<syn::WherePredicate>>, tag: TagType, @@ -218,6 +221,7 @@ pub struct Container { is_packed: bool, /// Error message generated when type can't be deserialized expecting: Option<String>, + non_exhaustive: bool, } /// Styles of representing an enum. @@ -288,6 +292,8 @@ impl Container { let mut default = Attr::none(cx, DEFAULT); let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL); let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL); + let mut rename_all_fields_ser_rule = Attr::none(cx, RENAME_ALL_FIELDS); + let mut rename_all_fields_de_rule = Attr::none(cx, RENAME_ALL_FIELDS); let mut ser_bound = Attr::none(cx, BOUND); let mut de_bound = Attr::none(cx, BOUND); let mut untagged = BoolAttr::none(cx, UNTAGGED); @@ -301,9 +307,12 @@ impl Container { let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER); let mut serde_path = Attr::none(cx, CRATE); let mut expecting = Attr::none(cx, EXPECTING); + let mut non_exhaustive = false; for attr in &item.attrs { if attr.path() != SERDE { + non_exhaustive |= + matches!(&attr.meta, syn::Meta::Path(path) if path == NON_EXHAUSTIVE); continue; } @@ -341,6 +350,44 @@ impl Container { } } } + } else if meta.path == RENAME_ALL_FIELDS { + // #[serde(rename_all_fields = "foo")] + // #[serde(rename_all_fields(serialize = "foo", deserialize = "bar"))] + let one_name = meta.input.peek(Token![=]); + let (ser, de) = get_renames(cx, RENAME_ALL_FIELDS, &meta)?; + + match item.data { + syn::Data::Enum(_) => { + if let Some(ser) = ser { + match RenameRule::from_str(&ser.value()) { + Ok(rename_rule) => { + rename_all_fields_ser_rule.set(&meta.path, rename_rule); + } + Err(err) => cx.error_spanned_by(ser, err), + } + } + if let Some(de) = de { + match RenameRule::from_str(&de.value()) { + Ok(rename_rule) => { + rename_all_fields_de_rule.set(&meta.path, rename_rule); + } + Err(err) => { + if !one_name { + cx.error_spanned_by(de, err); + } + } + } + } + } + syn::Data::Struct(_) => { + let msg = "#[serde(rename_all_fields)] can only be used on enums"; + cx.syn_error(meta.error(msg)); + } + syn::Data::Union(_) => { + let msg = "#[serde(rename_all_fields)] can only be used on enums"; + cx.syn_error(meta.error(msg)); + } + } } else if meta.path == TRANSPARENT { // #[serde(transparent)] transparent.set_true(meta.path); @@ -353,21 +400,21 @@ impl Container { if let Some(path) = parse_lit_into_expr_path(cx, DEFAULT, &meta)? { match &item.data { syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields { - syn::Fields::Named(_) => { + syn::Fields::Named(_) | syn::Fields::Unnamed(_) => { default.set(&meta.path, Default::Path(path)); } - syn::Fields::Unnamed(_) | syn::Fields::Unit => { - let msg = "#[serde(default = \"...\")] can only be used on structs with named fields"; - cx.error_spanned_by(fields, msg); + syn::Fields::Unit => { + let msg = "#[serde(default = \"...\")] can only be used on structs that have fields"; + cx.syn_error(meta.error(msg)); } }, - syn::Data::Enum(syn::DataEnum { enum_token, .. }) => { - let msg = "#[serde(default = \"...\")] can only be used on structs with named fields"; - cx.error_spanned_by(enum_token, msg); + syn::Data::Enum(_) => { + let msg = "#[serde(default = \"...\")] can only be used on structs"; + cx.syn_error(meta.error(msg)); } - syn::Data::Union(syn::DataUnion { union_token, .. }) => { - let msg = "#[serde(default = \"...\")] can only be used on structs with named fields"; - cx.error_spanned_by(union_token, msg); + syn::Data::Union(_) => { + let msg = "#[serde(default = \"...\")] can only be used on structs"; + cx.syn_error(meta.error(msg)); } } } @@ -375,21 +422,21 @@ impl Container { // #[serde(default)] match &item.data { syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields { - syn::Fields::Named(_) => { + syn::Fields::Named(_) | syn::Fields::Unnamed(_) => { default.set(meta.path, Default::Default); } - syn::Fields::Unnamed(_) | syn::Fields::Unit => { - let msg = "#[serde(default)] can only be used on structs with named fields"; + syn::Fields::Unit => { + let msg = "#[serde(default)] can only be used on structs that have fields"; cx.error_spanned_by(fields, msg); } }, - syn::Data::Enum(syn::DataEnum { enum_token, .. }) => { - let msg = "#[serde(default)] can only be used on structs with named fields"; - cx.error_spanned_by(enum_token, msg); + syn::Data::Enum(_) => { + let msg = "#[serde(default)] can only be used on structs"; + cx.syn_error(meta.error(msg)); } - syn::Data::Union(syn::DataUnion { union_token, .. }) => { - let msg = "#[serde(default)] can only be used on structs with named fields"; - cx.error_spanned_by(union_token, msg); + syn::Data::Union(_) => { + let msg = "#[serde(default)] can only be used on structs"; + cx.syn_error(meta.error(msg)); } } } @@ -405,13 +452,13 @@ impl Container { syn::Data::Enum(_) => { untagged.set_true(&meta.path); } - syn::Data::Struct(syn::DataStruct { struct_token, .. }) => { + syn::Data::Struct(_) => { let msg = "#[serde(untagged)] can only be used on enums"; - cx.error_spanned_by(struct_token, msg); + cx.syn_error(meta.error(msg)); } - syn::Data::Union(syn::DataUnion { union_token, .. }) => { + syn::Data::Union(_) => { let msg = "#[serde(untagged)] can only be used on enums"; - cx.error_spanned_by(union_token, msg); + cx.syn_error(meta.error(msg)); } } } else if meta.path == TAG { @@ -427,12 +474,12 @@ impl Container { } syn::Fields::Unnamed(_) | syn::Fields::Unit => { let msg = "#[serde(tag = \"...\")] can only be used on enums and structs with named fields"; - cx.error_spanned_by(fields, msg); + cx.syn_error(meta.error(msg)); } }, - syn::Data::Union(syn::DataUnion { union_token, .. }) => { + syn::Data::Union(_) => { let msg = "#[serde(tag = \"...\")] can only be used on enums and structs with named fields"; - cx.error_spanned_by(union_token, msg); + cx.syn_error(meta.error(msg)); } } } @@ -443,13 +490,13 @@ impl Container { syn::Data::Enum(_) => { content.set(&meta.path, s.value()); } - syn::Data::Struct(syn::DataStruct { struct_token, .. }) => { + syn::Data::Struct(_) => { let msg = "#[serde(content = \"...\")] can only be used on enums"; - cx.error_spanned_by(struct_token, msg); + cx.syn_error(meta.error(msg)); } - syn::Data::Union(syn::DataUnion { union_token, .. }) => { + syn::Data::Union(_) => { let msg = "#[serde(content = \"...\")] can only be used on enums"; - cx.error_spanned_by(union_token, msg); + cx.syn_error(meta.error(msg)); } } } @@ -528,6 +575,10 @@ impl Container { serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None), deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None), }, + rename_all_fields_rules: RenameAllRules { + serialize: rename_all_fields_ser_rule.get().unwrap_or(RenameRule::None), + deserialize: rename_all_fields_de_rule.get().unwrap_or(RenameRule::None), + }, ser_bound: ser_bound.get(), de_bound: de_bound.get(), tag: decide_tag(cx, item, untagged, internal_tag, content), @@ -540,6 +591,7 @@ impl Container { serde_path: serde_path.get(), is_packed, expecting: expecting.get(), + non_exhaustive, } } @@ -547,8 +599,12 @@ impl Container { &self.name } - pub fn rename_all_rules(&self) -> &RenameAllRules { - &self.rename_all_rules + pub fn rename_all_rules(&self) -> RenameAllRules { + self.rename_all_rules + } + + pub fn rename_all_fields_rules(&self) -> RenameAllRules { + self.rename_all_fields_rules } pub fn transparent(&self) -> bool { @@ -621,6 +677,10 @@ impl Container { pub fn expecting(&self) -> Option<&str> { self.expecting.as_ref().map(String::as_ref) } + + pub fn non_exhaustive(&self) -> bool { + self.non_exhaustive + } } fn decide_tag( @@ -656,7 +716,7 @@ fn decide_tag( } TagType::Internal { tag } } - (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => { + (Some((untagged_tokens, ())), Some((tag_tokens, _)), None) => { let msg = "enum cannot be both untagged and internally tagged"; cx.error_spanned_by(untagged_tokens, msg); cx.error_spanned_by(tag_tokens, msg); @@ -667,14 +727,14 @@ fn decide_tag( cx.error_spanned_by(content_tokens, msg); TagType::External } - (Some((untagged_tokens, _)), None, Some((content_tokens, _))) => { + (Some((untagged_tokens, ())), None, Some((content_tokens, _))) => { let msg = "untagged enum cannot have #[serde(content = \"...\")]"; cx.error_spanned_by(untagged_tokens, msg); cx.error_spanned_by(content_tokens, msg); TagType::External } (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content }, - (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => { + (Some((untagged_tokens, ())), Some((tag_tokens, _)), Some((content_tokens, _))) => { let msg = "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]"; cx.error_spanned_by(untagged_tokens, msg); cx.error_spanned_by(tag_tokens, msg); @@ -696,7 +756,7 @@ fn decide_identifier( variant_identifier.0.get_with_tokens(), ) { (_, None, None) => Identifier::No, - (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => { + (_, Some((field_identifier_tokens, ())), Some((variant_identifier_tokens, ()))) => { let msg = "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set"; cx.error_spanned_by(field_identifier_tokens, msg); @@ -917,21 +977,24 @@ impl Variant { &self.name } - pub fn aliases(&self) -> Vec<String> { + pub fn aliases(&self) -> &BTreeSet<String> { self.name.deserialize_aliases() } - pub fn rename_by_rules(&mut self, rules: &RenameAllRules) { + pub fn rename_by_rules(&mut self, rules: RenameAllRules) { if !self.name.serialize_renamed { self.name.serialize = rules.serialize.apply_to_variant(&self.name.serialize); } if !self.name.deserialize_renamed { self.name.deserialize = rules.deserialize.apply_to_variant(&self.name.deserialize); } + self.name + .deserialize_aliases + .insert(self.name.deserialize.clone()); } - pub fn rename_all_rules(&self) -> &RenameAllRules { - &self.rename_all_rules + pub fn rename_all_rules(&self) -> RenameAllRules { + self.rename_all_rules } pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> { @@ -1256,17 +1319,20 @@ impl Field { &self.name } - pub fn aliases(&self) -> Vec<String> { + pub fn aliases(&self) -> &BTreeSet<String> { self.name.deserialize_aliases() } - pub fn rename_by_rules(&mut self, rules: &RenameAllRules) { + pub fn rename_by_rules(&mut self, rules: RenameAllRules) { if !self.name.serialize_renamed { self.name.serialize = rules.serialize.apply_to_field(&self.name.serialize); } if !self.name.deserialize_renamed { self.name.deserialize = rules.deserialize.apply_to_field(&self.name.deserialize); } + self.name + .deserialize_aliases + .insert(self.name.deserialize.clone()); } pub fn skip_serializing(&self) -> bool { diff --git a/vendor/serde_derive/src/internals/case.rs b/vendor/serde_derive/src/internals/case.rs index 554505160..8c8c02e75 100644 --- a/vendor/serde_derive/src/internals/case.rs +++ b/vendor/serde_derive/src/internals/case.rs @@ -1,13 +1,8 @@ //! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the //! case of the source (e.g. `my-field`, `MY_FIELD`). -// See https://users.rust-lang.org/t/psa-dealing-with-warning-unused-import-std-ascii-asciiext-in-today-s-nightly/13726 -#[allow(deprecated, unused_imports)] -use std::ascii::AsciiExt; - -use std::fmt::{self, Debug, Display}; - use self::RenameRule::*; +use std::fmt::{self, Debug, Display}; /// The different possible ways to change case of fields in a struct, or variants in an enum. #[derive(Copy, Clone, PartialEq)] @@ -59,8 +54,8 @@ impl RenameRule { } /// Apply a renaming rule to an enum variant, returning the version expected in the source. - pub fn apply_to_variant(&self, variant: &str) -> String { - match *self { + pub fn apply_to_variant(self, variant: &str) -> String { + match self { None | PascalCase => variant.to_owned(), LowerCase => variant.to_ascii_lowercase(), UpperCase => variant.to_ascii_uppercase(), @@ -84,8 +79,8 @@ impl RenameRule { } /// Apply a renaming rule to a struct field, returning the version expected in the source. - pub fn apply_to_field(&self, field: &str) -> String { - match *self { + pub fn apply_to_field(self, field: &str) -> String { + match self { None | LowerCase | SnakeCase => field.to_owned(), UpperCase => field.to_ascii_uppercase(), PascalCase => { @@ -112,6 +107,14 @@ impl RenameRule { ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"), } } + + /// Returns the `RenameRule` if it is not `None`, `rule_b` otherwise. + pub fn or(self, rule_b: Self) -> Self { + match self { + None => rule_b, + _ => self, + } + } } pub struct ParseError<'a> { diff --git a/vendor/serde_derive/src/internals/check.rs b/vendor/serde_derive/src/internals/check.rs index 4a7f52c6c..b01a8ca4d 100644 --- a/vendor/serde_derive/src/internals/check.rs +++ b/vendor/serde_derive/src/internals/check.rs @@ -1,11 +1,12 @@ -use internals::ast::{Container, Data, Field, Style}; -use internals::attr::{Identifier, TagType}; -use internals::{ungroup, Ctxt, Derive}; +use crate::internals::ast::{Container, Data, Field, Style}; +use crate::internals::attr::{Default, Identifier, TagType}; +use crate::internals::{ungroup, Ctxt, Derive}; use syn::{Member, Type}; // Cross-cutting checks that require looking at more than a single attrs object. // Simpler checks should happen when parsing and building the attrs. pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) { + check_default_on_tuple(cx, cont); check_remote_generic(cx, cont); check_getter(cx, cont); check_flatten(cx, cont); @@ -17,6 +18,39 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) { check_from_and_try_from(cx, cont); } +// If some field of a tuple struct is marked #[serde(default)] then all fields +// after it must also be marked with that attribute, or the struct must have a +// container-level serde(default) attribute. A field's default value is only +// used for tuple fields if the sequence is exhausted at that point; that means +// all subsequent fields will fail to deserialize if they don't have their own +// default. +fn check_default_on_tuple(cx: &Ctxt, cont: &Container) { + if let Default::None = cont.attrs.default() { + if let Data::Struct(Style::Tuple, fields) = &cont.data { + let mut first_default_index = None; + for (i, field) in fields.iter().enumerate() { + // Skipped fields automatically get the #[serde(default)] + // attribute. We are interested only on non-skipped fields here. + if field.attrs.skip_deserializing() { + continue; + } + if let Default::None = field.attrs.default() { + if let Some(first) = first_default_index { + cx.error_spanned_by( + field.ty, + format!("field must have #[serde(default)] because previous field {} has #[serde(default)]", first), + ); + } + continue; + } + if first_default_index.is_none() { + first_default_index = Some(i); + } + } + } + } +} + // Remote derive definition type must have either all of the generics of the // remote type: // @@ -285,8 +319,10 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) { match variant.style { Style::Struct => { for field in &variant.fields { - let check_ser = !field.attrs.skip_serializing(); - let check_de = !field.attrs.skip_deserializing(); + let check_ser = + !(field.attrs.skip_serializing() || variant.attrs.skip_serializing()); + let check_de = + !(field.attrs.skip_deserializing() || variant.attrs.skip_deserializing()); let name = field.attrs.name(); let ser_name = name.serialize_name(); diff --git a/vendor/serde_derive/src/internals/ctxt.rs b/vendor/serde_derive/src/internals/ctxt.rs index 707bed90e..a47bfa410 100644 --- a/vendor/serde_derive/src/internals/ctxt.rs +++ b/vendor/serde_derive/src/internals/ctxt.rs @@ -2,7 +2,6 @@ use quote::ToTokens; use std::cell::RefCell; use std::fmt::Display; use std::thread; -use syn; /// A type to collect errors together and format them. /// diff --git a/vendor/serde_derive/src/internals/mod.rs b/vendor/serde_derive/src/internals/mod.rs index 5e9f416c4..f98ef08e8 100644 --- a/vendor/serde_derive/src/internals/mod.rs +++ b/vendor/serde_derive/src/internals/mod.rs @@ -1,19 +1,18 @@ pub mod ast; pub mod attr; -mod ctxt; -pub use self::ctxt::Ctxt; - -mod receiver; -pub use self::receiver::replace_receiver; - mod case; mod check; +mod ctxt; +mod receiver; mod respan; mod symbol; use syn::Type; +pub use self::ctxt::Ctxt; +pub use self::receiver::replace_receiver; + #[derive(Copy, Clone)] pub enum Derive { Serialize, diff --git a/vendor/serde_derive/src/internals/receiver.rs b/vendor/serde_derive/src/internals/receiver.rs index 5dc01db26..6273dfece 100644 --- a/vendor/serde_derive/src/internals/receiver.rs +++ b/vendor/serde_derive/src/internals/receiver.rs @@ -1,11 +1,11 @@ -use internals::respan::respan; +use crate::internals::respan::respan; use proc_macro2::Span; use quote::ToTokens; use std::mem; use syn::punctuated::Punctuated; use syn::{ parse_quote, Data, DeriveInput, Expr, ExprPath, GenericArgument, GenericParam, Generics, Macro, - Path, PathArguments, QSelf, ReturnType, Type, TypeParamBound, TypePath, WherePredicate, + Path, PathArguments, QSelf, ReturnType, Token, Type, TypeParamBound, TypePath, WherePredicate, }; pub fn replace_receiver(input: &mut DeriveInput) { diff --git a/vendor/serde_derive/src/internals/symbol.rs b/vendor/serde_derive/src/internals/symbol.rs index 9606edb5f..572391a80 100644 --- a/vendor/serde_derive/src/internals/symbol.rs +++ b/vendor/serde_derive/src/internals/symbol.rs @@ -19,10 +19,12 @@ pub const FLATTEN: Symbol = Symbol("flatten"); pub const FROM: Symbol = Symbol("from"); pub const GETTER: Symbol = Symbol("getter"); pub const INTO: Symbol = Symbol("into"); +pub const NON_EXHAUSTIVE: Symbol = Symbol("non_exhaustive"); pub const OTHER: Symbol = Symbol("other"); pub const REMOTE: Symbol = Symbol("remote"); pub const RENAME: Symbol = Symbol("rename"); pub const RENAME_ALL: Symbol = Symbol("rename_all"); +pub const RENAME_ALL_FIELDS: Symbol = Symbol("rename_all_fields"); pub const REPR: Symbol = Symbol("repr"); pub const SERDE: Symbol = Symbol("serde"); pub const SERIALIZE: Symbol = Symbol("serialize"); diff --git a/vendor/serde_derive/src/lib.rs b/vendor/serde_derive/src/lib.rs index 176628ad5..d094242f3 100644 --- a/vendor/serde_derive/src/lib.rs +++ b/vendor/serde_derive/src/lib.rs @@ -13,8 +13,7 @@ //! //! [https://serde.rs/derive.html]: https://serde.rs/derive.html -#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.171")] -#![allow(unknown_lints, bare_trait_objects)] +#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.188")] // Ignored clippy lints #![allow( // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054 @@ -63,17 +62,16 @@ )] #![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))] -#[macro_use] +extern crate proc_macro2; extern crate quote; -#[macro_use] extern crate syn; extern crate proc_macro; -extern crate proc_macro2; mod internals; use proc_macro::TokenStream; +use syn::parse_macro_input; use syn::DeriveInput; #[macro_use] @@ -86,7 +84,6 @@ mod dummy; mod pretend; mod ser; mod this; -mod try; #[proc_macro_derive(Serialize, attributes(serde))] pub fn derive_serialize(input: TokenStream) -> TokenStream { diff --git a/vendor/serde_derive/src/pretend.rs b/vendor/serde_derive/src/pretend.rs index 7decbaa52..04868753b 100644 --- a/vendor/serde_derive/src/pretend.rs +++ b/vendor/serde_derive/src/pretend.rs @@ -1,7 +1,6 @@ +use crate::internals::ast::{Container, Data, Field, Style, Variant}; use proc_macro2::TokenStream; -use quote::format_ident; - -use internals::ast::{Container, Data, Field, Style, Variant}; +use quote::{format_ident, quote}; // Suppress dead_code warnings that would otherwise appear when using a remote // derive. Other than this pretend code, a struct annotated with remote derive diff --git a/vendor/serde_derive/src/ser.rs b/vendor/serde_derive/src/ser.rs index b9a9dce21..3be51ee52 100644 --- a/vendor/serde_derive/src/ser.rs +++ b/vendor/serde_derive/src/ser.rs @@ -1,14 +1,11 @@ +use crate::fragment::{Fragment, Match, Stmts}; +use crate::internals::ast::{Container, Data, Field, Style, Variant}; +use crate::internals::{attr, replace_receiver, Ctxt, Derive}; +use crate::{bound, dummy, pretend, this}; use proc_macro2::{Span, TokenStream}; +use quote::{quote, quote_spanned}; use syn::spanned::Spanned; -use syn::{self, Ident, Index, Member}; - -use bound; -use dummy; -use fragment::{Fragment, Match, Stmts}; -use internals::ast::{Container, Data, Field, Style, Variant}; -use internals::{attr, replace_receiver, Ctxt, Derive}; -use pretend; -use this; +use syn::{parse_quote, Ident, Index, Member}; pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> { replace_receiver(input); @@ -285,7 +282,7 @@ fn serialize_tuple_struct( .fold(quote!(0), |sum, expr| quote!(#sum + #expr)); quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len)); + let #let_mut __serde_state = _serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len)?; #(#serialize_stmts)* _serde::ser::SerializeTupleStruct::end(__serde_state) } @@ -307,7 +304,7 @@ fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTra 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)); + #func(&mut __serde_state, #tag, #type_name)?; } } _ => quote! {}, @@ -348,7 +345,7 @@ fn serialize_struct_as_struct( ); quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len)); + let #let_mut __serde_state = _serde::Serializer::serialize_struct(__serializer, #type_name, #len)?; #tag_field #(#serialize_fields)* _serde::ser::SerializeStruct::end(__serde_state) @@ -392,7 +389,7 @@ fn serialize_struct_as_map( }; quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len)); + let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, #len)?; #tag_field #(#serialize_fields)* _serde::ser::SerializeMap::end(__serde_state) @@ -404,7 +401,7 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont let self_var = ¶ms.self_var; - let arms: Vec<_> = variants + let mut arms: Vec<_> = variants .iter() .enumerate() .map(|(variant_index, variant)| { @@ -412,6 +409,12 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont }) .collect(); + if cattrs.remote().is_some() && cattrs.non_exhaustive() { + arms.push(quote! { + ref unrecognized => _serde::__private::Err(_serde::ser::Error::custom(_serde::__private::ser::CannotSerializeVariant(unrecognized))), + }); + } + quote_expr! { match *#self_var { #(#arms)* @@ -481,7 +484,14 @@ fn serialize_variant( serialize_internally_tagged_variant(params, variant, cattrs, tag) } (attr::TagType::Adjacent { tag, content }, false) => { - serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content) + serialize_adjacently_tagged_variant( + params, + variant, + cattrs, + variant_index, + tag, + content, + ) } (attr::TagType::None, _) | (_, true) => { serialize_untagged_variant(params, variant, cattrs) @@ -562,7 +572,7 @@ fn serialize_externally_tagged_variant( }, params, &variant.fields, - &type_name, + type_name, ), } } @@ -596,10 +606,10 @@ fn serialize_internally_tagged_variant( match effective_style(variant) { Style::Unit => { quote_block! { - let mut __struct = try!(_serde::Serializer::serialize_struct( - __serializer, #type_name, 1)); - try!(_serde::ser::SerializeStruct::serialize_field( - &mut __struct, #tag, #variant_name)); + let mut __struct = _serde::Serializer::serialize_struct( + __serializer, #type_name, 1)?; + _serde::ser::SerializeStruct::serialize_field( + &mut __struct, #tag, #variant_name)?; _serde::ser::SerializeStruct::end(__struct) } } @@ -627,7 +637,7 @@ fn serialize_internally_tagged_variant( StructVariant::InternallyTagged { tag, variant_name }, params, &variant.fields, - &type_name, + type_name, ), Style::Tuple => unreachable!("checked in serde_derive_internals"), } @@ -637,12 +647,20 @@ fn serialize_adjacently_tagged_variant( params: &Parameters, variant: &Variant, cattrs: &attr::Container, + variant_index: u32, tag: &str, content: &str, ) -> Fragment { let this_type = ¶ms.this_type; let type_name = cattrs.name().serialize_name(); let variant_name = variant.attrs.name().serialize_name(); + let serialize_variant = quote! { + &_serde::__private::ser::AdjacentlyTaggedEnumVariant { + enum_name: #type_name, + variant_index: #variant_index, + variant_name: #variant_name, + } + }; let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() { let ser = wrap_serialize_variant_with(params, path, variant); @@ -653,10 +671,10 @@ fn serialize_adjacently_tagged_variant( match effective_style(variant) { Style::Unit => { return quote_block! { - let mut __struct = try!(_serde::Serializer::serialize_struct( - __serializer, #type_name, 1)); - try!(_serde::ser::SerializeStruct::serialize_field( - &mut __struct, #tag, #variant_name)); + let mut __struct = _serde::Serializer::serialize_struct( + __serializer, #type_name, 1)?; + _serde::ser::SerializeStruct::serialize_field( + &mut __struct, #tag, #serialize_variant)?; _serde::ser::SerializeStruct::end(__struct) }; } @@ -670,12 +688,12 @@ fn serialize_adjacently_tagged_variant( let span = field.original.span(); let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field); return quote_block! { - let mut __struct = try!(_serde::Serializer::serialize_struct( - __serializer, #type_name, 2)); - try!(_serde::ser::SerializeStruct::serialize_field( - &mut __struct, #tag, #variant_name)); - try!(#func( - &mut __struct, #content, #field_expr)); + let mut __struct = _serde::Serializer::serialize_struct( + __serializer, #type_name, 2)?; + _serde::ser::SerializeStruct::serialize_field( + &mut __struct, #tag, #serialize_variant)?; + #func( + &mut __struct, #content, #field_expr)?; _serde::ser::SerializeStruct::end(__struct) }; } @@ -686,13 +704,13 @@ fn serialize_adjacently_tagged_variant( StructVariant::Untagged, params, &variant.fields, - &variant_name, + variant_name, ), } }); let fields_ty = variant.fields.iter().map(|f| &f.ty); - let fields_ident: &Vec<_> = &match variant.style { + let fields_ident: &[_] = &match variant.style { Style::Unit => { if variant.attrs.serialize_with().is_some() { vec![] @@ -735,15 +753,15 @@ fn serialize_adjacently_tagged_variant( } } - let mut __struct = try!(_serde::Serializer::serialize_struct( - __serializer, #type_name, 2)); - try!(_serde::ser::SerializeStruct::serialize_field( - &mut __struct, #tag, #variant_name)); - try!(_serde::ser::SerializeStruct::serialize_field( + let mut __struct = _serde::Serializer::serialize_struct( + __serializer, #type_name, 2)?; + _serde::ser::SerializeStruct::serialize_field( + &mut __struct, #tag, #serialize_variant)?; + _serde::ser::SerializeStruct::serialize_field( &mut __struct, #content, &__AdjacentlyTagged { data: (#(#fields_ident,)*), phantom: _serde::__private::PhantomData::<#this_type #ty_generics>, - })); + })?; _serde::ser::SerializeStruct::end(__struct) } } @@ -782,16 +800,16 @@ fn serialize_untagged_variant( Style::Tuple => serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields), Style::Struct => { let type_name = cattrs.name().serialize_name(); - serialize_struct_variant(StructVariant::Untagged, params, &variant.fields, &type_name) + serialize_struct_variant(StructVariant::Untagged, params, &variant.fields, type_name) } } } -enum TupleVariant { +enum TupleVariant<'a> { ExternallyTagged { - type_name: String, + type_name: &'a str, variant_index: u32, - variant_name: String, + variant_name: &'a str, }, Untagged, } @@ -833,21 +851,21 @@ fn serialize_tuple_variant( variant_name, } => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant( + let #let_mut __serde_state = _serde::Serializer::serialize_tuple_variant( __serializer, #type_name, #variant_index, #variant_name, - #len)); + #len)?; #(#serialize_stmts)* _serde::ser::SerializeTupleVariant::end(__serde_state) } } TupleVariant::Untagged => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple( + let #let_mut __serde_state = _serde::Serializer::serialize_tuple( __serializer, - #len)); + #len)?; #(#serialize_stmts)* _serde::ser::SerializeTuple::end(__serde_state) } @@ -858,11 +876,11 @@ fn serialize_tuple_variant( enum StructVariant<'a> { ExternallyTagged { variant_index: u32, - variant_name: String, + variant_name: &'a str, }, InternallyTagged { tag: &'a str, - variant_name: String, + variant_name: &'a str, }, Untagged, } @@ -910,40 +928,40 @@ fn serialize_struct_variant( variant_name, } => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant( + let #let_mut __serde_state = _serde::Serializer::serialize_struct_variant( __serializer, #name, #variant_index, #variant_name, #len, - )); + )?; #(#serialize_fields)* _serde::ser::SerializeStructVariant::end(__serde_state) } } StructVariant::InternallyTagged { tag, variant_name } => { quote_block! { - let mut __serde_state = try!(_serde::Serializer::serialize_struct( + let mut __serde_state = _serde::Serializer::serialize_struct( __serializer, #name, #len + 1, - )); - try!(_serde::ser::SerializeStruct::serialize_field( + )?; + _serde::ser::SerializeStruct::serialize_field( &mut __serde_state, #tag, #variant_name, - )); + )?; #(#serialize_fields)* _serde::ser::SerializeStruct::end(__serde_state) } } StructVariant::Untagged => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct( + let #let_mut __serde_state = _serde::Serializer::serialize_struct( __serializer, #name, #len, - )); + )?; #(#serialize_fields)* _serde::ser::SerializeStruct::end(__serde_state) } @@ -993,9 +1011,9 @@ fn serialize_struct_variant_with_flatten( __S: _serde::Serializer, { let (#(#members,)*) = self.data; - let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( + let #let_mut __serde_state = _serde::Serializer::serialize_map( __serializer, - _serde::__private::None)); + _serde::__private::None)?; #(#serialize_fields)* _serde::ser::SerializeMap::end(__serde_state) } @@ -1014,23 +1032,23 @@ fn serialize_struct_variant_with_flatten( } StructVariant::InternallyTagged { tag, variant_name } => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( + let #let_mut __serde_state = _serde::Serializer::serialize_map( __serializer, - _serde::__private::None)); - try!(_serde::ser::SerializeMap::serialize_entry( + _serde::__private::None)?; + _serde::ser::SerializeMap::serialize_entry( &mut __serde_state, #tag, #variant_name, - )); + )?; #(#serialize_fields)* _serde::ser::SerializeMap::end(__serde_state) } } StructVariant::Untagged => { quote_block! { - let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( + let #let_mut __serde_state = _serde::Serializer::serialize_map( __serializer, - _serde::__private::None)); + _serde::__private::None)?; #(#serialize_fields)* _serde::ser::SerializeMap::end(__serde_state) } @@ -1075,7 +1093,7 @@ fn serialize_tuple_struct_visitor( let span = field.original.span(); let func = tuple_trait.serialize_element(span); let ser = quote! { - try!(#func(&mut __serde_state, #field_expr)); + #func(&mut __serde_state, #field_expr)?; }; match skip { @@ -1119,12 +1137,12 @@ fn serialize_struct_visitor( let ser = if field.attrs.flatten() { let func = quote_spanned!(span=> _serde::Serialize::serialize); quote! { - try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state))); + #func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state))?; } } else { let func = struct_trait.serialize_field(span); quote! { - try!(#func(&mut __serde_state, #key_expr, #field_expr)); + #func(&mut __serde_state, #key_expr, #field_expr)?; } }; @@ -1136,7 +1154,7 @@ fn serialize_struct_visitor( if !#skip { #ser } else { - try!(#skip_func(&mut __serde_state, #key_expr)); + #skip_func(&mut __serde_state, #key_expr)?; } } } else { @@ -1236,7 +1254,7 @@ fn wrap_serialize_with( // Serialization of an empty struct results in code like: // -// let mut __serde_state = try!(serializer.serialize_struct("S", 0)); +// let mut __serde_state = serializer.serialize_struct("S", 0)?; // _serde::ser::SerializeStruct::end(__serde_state) // // where we want to omit the `mut` to avoid a warning. diff --git a/vendor/serde_derive/src/this.rs b/vendor/serde_derive/src/this.rs index 32731d089..941cea40c 100644 --- a/vendor/serde_derive/src/this.rs +++ b/vendor/serde_derive/src/this.rs @@ -1,4 +1,4 @@ -use internals::ast::Container; +use crate::internals::ast::Container; use syn::{Path, PathArguments, Token}; pub fn this_type(cont: &Container) -> Path { diff --git a/vendor/serde_derive/src/try.rs b/vendor/serde_derive/src/try.rs deleted file mode 100644 index 48cceebaa..000000000 --- a/vendor/serde_derive/src/try.rs +++ /dev/null @@ -1,24 +0,0 @@ -use proc_macro2::{Punct, Spacing, TokenStream}; - -// None of our generated code requires the `From::from` error conversion -// performed by the standard library's `try!` macro. With this simplified macro -// we see a significant improvement in type checking and borrow checking time of -// the generated code and a slight improvement in binary size. -pub fn replacement() -> TokenStream { - // Cannot pass `$expr` to `quote!` prior to Rust 1.17.0 so interpolate it. - let dollar = Punct::new('$', Spacing::Alone); - - quote! { - #[allow(unused_macros)] - macro_rules! try { - (#dollar __expr:expr) => { - match #dollar __expr { - _serde::__private::Ok(__val) => __val, - _serde::__private::Err(__err) => { - return _serde::__private::Err(__err); - } - } - } - } - } -} |