Release 1.0.158

Fixes these being treated as "tests" by `cargo test` in serde_derive:

    running 3 tests
    test src/internals/check.rs - internals::check::check_remote_generic (line 23) ... FAILED
    test src/internals/check.rs - internals::check::check_remote_generic (line 29) ... FAILED
    test src/lib.rs - (line 3) ... ok

    failures:

    ---- src/internals/check.rs - internals::check::check_remote_generic (line 23) stdout ----
    error: unknown start of token: \u{2026}
     --> src/internals/check.rs:25:20
      |
    4 | struct Generic<T> {…}
      |                    ^

    error: cannot find attribute `serde` in this scope
     --> src/internals/check.rs:24:3
      |
    3 | #[serde(remote = "Generic")]
      |   ^^^^^
      |
      = note: `serde` is in scope, but it is a crate, not an attribute

    error[E0392]: parameter `T` is never used
     --> src/internals/check.rs:25:16
      |
    4 | struct Generic<T> {…}
      |                ^ unused parameter
      |
      = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
      = help: if you intended `T` to be a const parameter, use `const T: usize` instead

    ---- src/internals/check.rs - internals::check::check_remote_generic (line 29) stdout ----
    error: unknown start of token: \u{2026}
     --> src/internals/check.rs:31:21
      |
    4 | struct ConcreteDef {…}
      |                     ^

    error: cannot find attribute `serde` in this scope
     --> src/internals/check.rs:30:3
      |
    3 | #[serde(remote = "Generic<T>")]
      |   ^^^^^
      |
      = note: `serde` is in scope, but it is a crate, not an attribute

.github/workflows/ci.yml

@@ -108,12 +108,12 @@ jobs:
       - run: cd serde && cargo build
 
   derive:
-    name: Rust 1.31.0
+    name: Rust 1.56.0
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
       - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@1.31.0
+      - uses: dtolnay/rust-toolchain@1.56.0
       - run: cd serde && cargo check --no-default-features
       - run: cd serde && cargo check
       - run: cd serde_derive && cargo check

README.md

@@ -1,13 +1,13 @@
-# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![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_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-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.**
 

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.154" # remember to update html_root_url and serde_derive dependency
+version = "1.0.158" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std"]
@@ -15,7 +15,7 @@ repository = "https://github.com/serde-rs/serde"
 rust-version = "1.19"
 
 [dependencies]
-serde_derive = { version = "=1.0.154", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.158", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
@@ -27,6 +27,7 @@ doc-scrape-examples = false
 features = ["derive", "rc"]
 
 [package.metadata.docs.rs]
+features = ["derive"]
 targets = ["x86_64-unknown-linux-gnu"]
 
 

serde/build.rs

@@ -78,11 +78,6 @@ fn main() {
         println!("cargo:rustc-cfg=no_num_nonzero");
     }
 
-    // Current minimum supported version of serde_derive crate is Rust 1.31.
-    if minor < 31 {
-        println!("cargo:rustc-cfg=no_serde_derive");
-    }
-
     // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
     // stabilized in Rust 1.34:
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
@@ -94,6 +89,11 @@ fn main() {
         println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
     }
 
+    // Current minimum supported version of serde_derive crate is Rust 1.56.
+    if minor < 56 {
+        println!("cargo:rustc-cfg=no_serde_derive");
+    }
+
     // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60.
     if minor < 60 {
         println!("cargo:rustc-cfg=no_target_has_atomic");
@@ -114,6 +114,12 @@ fn main() {
             println!("cargo:rustc-cfg=no_std_atomic");
         }
     }
+
+    // Support for core::ffi::CStr and alloc::ffi::CString stabilized in Rust 1.64.
+    // https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html#c-compatible-ffi-types-in-core-and-alloc
+    if minor < 64 {
+        println!("cargo:rustc-cfg=no_core_cstr");
+    }
 }
 
 fn rustc_minor_version() -> Option<u32> {

serde/src/de/impls.rs

@@ -666,10 +666,10 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 struct CStringVisitor;
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl<'de> Visitor<'de> for CStringVisitor {
     type Value = CString;
 
@@ -720,7 +720,7 @@ impl<'de> Visitor<'de> for CStringVisitor {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl<'de> Deserialize<'de> for CString {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -747,7 +747,10 @@ macro_rules! forwarded_impl {
     }
 }
 
-#[cfg(all(feature = "std", not(no_de_boxed_c_str)))]
+#[cfg(all(
+    any(feature = "std", all(not(no_core_cstr), feature = "alloc")),
+    not(no_de_boxed_c_str)
+))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 
 #[cfg(not(no_core_reverse))]

serde/src/lib.rs

@@ -93,7 +93,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.154")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.158")]
 // 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
@@ -219,13 +219,23 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
+    #[cfg(all(not(no_core_cstr), not(feature = "std")))]
+    pub use core::ffi::CStr;
+    #[cfg(feature = "std")]
+    pub use std::ffi::CStr;
+
+    #[cfg(all(not(no_core_cstr), feature = "alloc", not(feature = "std")))]
+    pub use alloc::ffi::CString;
+    #[cfg(feature = "std")]
+    pub use std::ffi::CString;
+
     #[cfg(feature = "std")]
     pub use std::{error, net};
 
     #[cfg(feature = "std")]
     pub use std::collections::{HashMap, HashSet};
     #[cfg(feature = "std")]
-    pub use std::ffi::{CStr, CString, OsStr, OsString};
+    pub use std::ffi::{OsStr, OsString};
     #[cfg(feature = "std")]
     pub use std::hash::{BuildHasher, Hash};
     #[cfg(feature = "std")]
@@ -328,9 +338,10 @@ mod std_error;
 #[allow(unused_imports)]
 #[macro_use]
 extern crate serde_derive;
+
+/// Derive macro available if serde is built with `features = ["derive"]`.
 #[cfg(feature = "serde_derive")]
-#[doc(hidden)]
-pub use serde_derive::*;
+pub use serde_derive::{Deserialize, Serialize};
 
 #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
 mod actually_private {

serde/src/ser/impls.rs

@@ -72,7 +72,7 @@ impl<'a> Serialize for fmt::Arguments<'a> {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", not(no_core_cstr)))]
 impl Serialize for CStr {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -83,7 +83,7 @@ impl Serialize for CStr {
     }
 }
 
-#[cfg(feature = "std")]
+#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
 impl Serialize for CString {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.154" # remember to update html_root_url
+version = "1.0.158" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -11,7 +11,7 @@ keywords = ["serde", "serialization", "no_std", "derive"]
 license = "MIT OR Apache-2.0"
 readme = "crates-io.md"
 repository = "https://github.com/serde-rs/serde"
-rust-version = "1.31"
+rust-version = "1.56"
 
 [features]
 default = []
@@ -24,7 +24,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = "1.0.104"
+syn = "2.0.3"
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/src/bound.rs

@@ -200,10 +200,16 @@ pub fn with_bound(
                     for arg in &arguments.args {
                         match arg {
                             syn::GenericArgument::Type(arg) => self.visit_type(arg),
-                            syn::GenericArgument::Binding(arg) => self.visit_type(&arg.ty),
+                            syn::GenericArgument::AssocType(arg) => self.visit_type(&arg.ty),
                             syn::GenericArgument::Lifetime(_)
-                            | syn::GenericArgument::Constraint(_)
-                            | syn::GenericArgument::Const(_) => {}
+                            | syn::GenericArgument::Const(_)
+                            | syn::GenericArgument::AssocConst(_)
+                            | syn::GenericArgument::Constraint(_) => {}
+                            #[cfg_attr(
+                                all(test, exhaustive),
+                                deny(non_exhaustive_omitted_patterns)
+                            )]
+                            _ => {}
                         }
                     }
                 }
@@ -226,7 +232,9 @@ pub fn with_bound(
         fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
             match bound {
                 syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
-                syn::TypeParamBound::Lifetime(_) => {}
+                syn::TypeParamBound::Lifetime(_) | syn::TypeParamBound::Verbatim(_) => {}
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                _ => {}
             }
         }
 
@@ -334,7 +342,7 @@ pub fn with_self_bound(
 
 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
     let bound = syn::Lifetime::new(lifetime, Span::call_site());
-    let def = syn::LifetimeDef {
+    let def = syn::LifetimeParam {
         attrs: Vec::new(),
         lifetime: bound.clone(),
         colon_token: None,

serde_derive/src/de.rs

@@ -244,9 +244,9 @@ impl BorrowedLifetimes {
         }
     }
 
-    fn de_lifetime_def(&self) -> Option<syn::LifetimeDef> {
+    fn de_lifetime_param(&self) -> Option<syn::LifetimeParam> {
         match self {
-            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeDef {
+            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeParam {
                 attrs: Vec::new(),
                 lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
@@ -3011,7 +3011,7 @@ struct InPlaceImplGenerics<'a>(&'a Parameters);
 impl<'a> ToTokens for DeImplGenerics<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut generics = self.0.generics.clone();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
+        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
             generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
                 .into_iter()
                 .chain(generics.params)
@@ -3046,7 +3046,7 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
             .into_iter()
             .chain(generics.params)
             .collect();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_def() {
+        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
             generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
                 .into_iter()
                 .chain(generics.params)
@@ -3071,8 +3071,8 @@ struct InPlaceTypeGenerics<'a>(&'a Parameters);
 impl<'a> ToTokens for DeTypeGenerics<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let mut generics = self.0.generics.clone();
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
+        if self.0.borrowed.de_lifetime_param().is_some() {
+            let def = syn::LifetimeParam {
                 attrs: Vec::new(),
                 lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
@@ -3097,8 +3097,8 @@ impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
             .chain(generics.params)
             .collect();
 
-        if self.0.borrowed.de_lifetime_def().is_some() {
-            let def = syn::LifetimeDef {
+        if self.0.borrowed.de_lifetime_param().is_some() {
+            let def = syn::LifetimeParam {
                 attrs: Vec::new(),
                 lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
@@ -3122,8 +3122,8 @@ impl<'a> DeTypeGenerics<'a> {
 }
 
 #[cfg(feature = "deserialize_in_place")]
-fn place_lifetime() -> syn::LifetimeDef {
-    syn::LifetimeDef {
+fn place_lifetime() -> syn::LifetimeParam {
+    syn::LifetimeParam {
         attrs: Vec::new(),
         lifetime: syn::Lifetime::new("'place", Span::call_site()),
         colon_token: None,

serde_derive/src/internals/check.rs

@@ -3,8 +3,8 @@ use internals::attr::{Identifier, TagType};
 use 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.
+// 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_remote_generic(cx, cont);
     check_getter(cx, cont);
@@ -17,18 +17,18 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     check_from_and_try_from(cx, cont);
 }
 
-/// Remote derive definition type must have either all of the generics of the
-/// remote type:
-///
-///     #[serde(remote = "Generic")]
-///     struct Generic<T> {…}
-///
-/// or none of them, i.e. defining impls for one concrete instantiation of the
-/// remote type only:
-///
-///     #[serde(remote = "Generic<T>")]
-///     struct ConcreteDef {…}
-///
+// Remote derive definition type must have either all of the generics of the
+// remote type:
+//
+//     #[serde(remote = "Generic")]
+//     struct Generic<T> {…}
+//
+// or none of them, i.e. defining impls for one concrete instantiation of the
+// remote type only:
+//
+//     #[serde(remote = "Generic<T>")]
+//     struct ConcreteDef {…}
+//
 fn check_remote_generic(cx: &Ctxt, cont: &Container) {
     if let Some(remote) = cont.attrs.remote() {
         let local_has_generic = !cont.generics.params.is_empty();
@@ -39,8 +39,8 @@ fn check_remote_generic(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Getters are only allowed inside structs (not enums) with the `remote`
-/// attribute.
+// Getters are only allowed inside structs (not enums) with the `remote`
+// attribute.
 fn check_getter(cx: &Ctxt, cont: &Container) {
     match cont.data {
         Data::Enum(_) => {
@@ -62,7 +62,7 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Flattening has some restrictions we can test.
+// Flattening has some restrictions we can test.
 fn check_flatten(cx: &Ctxt, cont: &Container) {
     match &cont.data {
         Data::Enum(variants) => {
@@ -101,12 +101,12 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
     }
 }
 
-/// The `other` attribute must be used at most once and it must be the last
-/// variant of an enum.
-///
-/// Inside a `variant_identifier` all variants must be unit variants. Inside a
-/// `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.
+// The `other` attribute must be used at most once and it must be the last
+// variant of an enum.
+//
+// Inside a `variant_identifier` all variants must be unit variants. Inside a
+// `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(variants) => variants,
@@ -189,8 +189,8 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Skip-(de)serializing attributes are not allowed on variants marked
-/// (de)serialize_with.
+// 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(variants) => variants,
@@ -264,10 +264,9 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// The tag of an internally-tagged struct variant must not be
-/// the same as either one of its fields, as this would result in
-/// duplicate keys in the serialized output and/or ambiguity in
-/// the to-be-deserialized input.
+// The tag of an internally-tagged struct variant must not be the same as either
+// one of its fields, as this would result in 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(variants) => variants,
@@ -313,8 +312,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.
+// 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 { tag, content } => (tag, content),
@@ -332,7 +331,7 @@ fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
     }
 }
 
-/// Enums and unit structs cannot be transparent.
+// Enums and unit structs cannot be transparent.
 fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     if !cont.attrs.transparent() {
         return;

serde_derive/src/internals/receiver.rs

@@ -179,10 +179,13 @@ impl ReplaceReceiver<'_> {
                 for arg in &mut arguments.args {
                     match arg {
                         GenericArgument::Type(arg) => self.visit_type_mut(arg),
-                        GenericArgument::Binding(arg) => self.visit_type_mut(&mut arg.ty),
+                        GenericArgument::AssocType(arg) => self.visit_type_mut(&mut arg.ty),
                         GenericArgument::Lifetime(_)
-                        | GenericArgument::Constraint(_)
-                        | GenericArgument::Const(_) => {}
+                        | GenericArgument::Const(_)
+                        | GenericArgument::AssocConst(_)
+                        | GenericArgument::Constraint(_) => {}
+                        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                        _ => {}
                     }
                 }
             }
@@ -205,7 +208,9 @@ impl ReplaceReceiver<'_> {
     fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
         match bound {
             TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
-            TypeParamBound::Lifetime(_) => {}
+            TypeParamBound::Lifetime(_) | TypeParamBound::Verbatim(_) => {}
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+            _ => {}
         }
     }
 
@@ -229,7 +234,9 @@ impl ReplaceReceiver<'_> {
                             self.visit_type_param_bound_mut(bound);
                         }
                     }
-                    WherePredicate::Lifetime(_) | WherePredicate::Eq(_) => {}
+                    WherePredicate::Lifetime(_) => {}
+                    #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
+                    _ => {}
                 }
             }
         }

serde_derive/src/internals/symbol.rs

@@ -13,6 +13,7 @@ pub const DEFAULT: Symbol = Symbol("default");
 pub const DENY_UNKNOWN_FIELDS: Symbol = Symbol("deny_unknown_fields");
 pub const DESERIALIZE: Symbol = Symbol("deserialize");
 pub const DESERIALIZE_WITH: Symbol = Symbol("deserialize_with");
+pub const EXPECTING: Symbol = Symbol("expecting");
 pub const FIELD_IDENTIFIER: Symbol = Symbol("field_identifier");
 pub const FLATTEN: Symbol = Symbol("flatten");
 pub const FROM: Symbol = Symbol("from");
@@ -22,6 +23,7 @@ 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 REPR: Symbol = Symbol("repr");
 pub const SERDE: Symbol = Symbol("serde");
 pub const SERIALIZE: Symbol = Symbol("serialize");
 pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with");
@@ -35,7 +37,6 @@ pub const TRY_FROM: Symbol = Symbol("try_from");
 pub const UNTAGGED: Symbol = Symbol("untagged");
 pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
 pub const WITH: Symbol = Symbol("with");
-pub const EXPECTING: Symbol = Symbol("expecting");
 
 impl PartialEq<Symbol> for Ident {
     fn eq(&self, word: &Symbol) -> bool {

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.154")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.158")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(

serde_derive_internals/Cargo.toml

@@ -9,7 +9,7 @@ include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
 keywords = ["serde", "serialization"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/serde-rs/serde"
-rust-version = "1.31"
+rust-version = "1.56"
 
 [lib]
 path = "lib.rs"
@@ -17,7 +17,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.104", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "2.0", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/lib.rs

@@ -31,6 +31,7 @@
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
     clippy::similar_names,
+    clippy::single_match_else,
     clippy::struct_excessive_bools,
     clippy::too_many_lines,
     clippy::unused_self,

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.154" # remember to update html_root_url
+version = "1.0.158" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["development-tools::testing"]

serde_test/src/lib.rs

@@ -140,7 +140,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.154")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.158")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]

test_suite/Cargo.toml

@@ -12,6 +12,7 @@ unstable = ["serde/unstable"]
 serde = { path = "../serde" }
 
 [dev-dependencies]
+automod = "1.0"
 fnv = "1.0"
 rustversion = "1.0"
 serde = { path = "../serde", features = ["rc", "derive"] }

test_suite/tests/regression.rs

@@ -0,0 +1,3 @@
+mod regression {
+    automod::dir!("tests/regression");
+}

test_suite/tests/regression/issue2371.rs

@@ -0,0 +1,43 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Nested;
+
+#[derive(Deserialize)]
+pub enum ExternallyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "tag")]
+pub enum InternallyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "tag", content = "content")]
+pub enum AdjacentlyTagged {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum UntaggedWorkaround {
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: &'static str,
+    },
+}

test_suite/tests/regression/issue2409.rs

@@ -0,0 +1,11 @@
+use serde::Deserialize;
+
+macro_rules! bug {
+    ($serde_path:literal) => {
+        #[derive(Deserialize)]
+        #[serde(crate = $serde_path)]
+        pub struct Struct;
+    };
+}
+
+bug!("serde");

test_suite/tests/test_gen.rs

@@ -257,6 +257,16 @@ fn test_gen() {
     }
     assert::<VariantWithTraits2<X, X>>();
 
+    type PhantomDataAlias<T> = PhantomData<T>;
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(bound = "")]
+    struct PhantomDataWrapper<T> {
+        #[serde(default)]
+        field: PhantomDataAlias<T>,
+    }
+    assert::<PhantomDataWrapper<X>>();
+
     #[derive(Serialize, Deserialize)]
     struct CowStr<'a>(Cow<'a, str>);
     assert::<CowStr>();
@@ -892,53 +902,3 @@ pub struct RemotePackedNonCopyDef {
 impl Drop for RemotePackedNonCopyDef {
     fn drop(&mut self) {}
 }
-
-//////////////////////////////////////////////////////////////////////////
-
-/// Regression tests for <https://github.com/serde-rs/serde/issues/2371>
-#[allow(dead_code)]
-mod static_and_flatten {
-    use super::*;
-
-    #[derive(Deserialize)]
-    struct Nested;
-
-    #[derive(Deserialize)]
-    enum ExternallyTagged {
-        Flatten {
-            #[serde(flatten)]
-            nested: Nested,
-            string: &'static str,
-        },
-    }
-
-    #[derive(Deserialize)]
-    #[serde(tag = "tag")]
-    enum InternallyTagged {
-        Flatten {
-            #[serde(flatten)]
-            nested: Nested,
-            string: &'static str,
-        },
-    }
-
-    #[derive(Deserialize)]
-    #[serde(tag = "tag", content = "content")]
-    enum AdjacentlyTagged {
-        Flatten {
-            #[serde(flatten)]
-            nested: Nested,
-            string: &'static str,
-        },
-    }
-
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    enum UntaggedWorkaround {
-        Flatten {
-            #[serde(flatten)]
-            nested: Nested,
-            string: &'static str,
-        },
-    }
-}

test_suite/tests/ui/borrow/duplicate_variant.stderr

@@ -1,5 +1,5 @@
 error: duplicate serde attribute `borrow`
- --> tests/ui/borrow/duplicate_variant.rs:8:13
+ --> tests/ui/borrow/duplicate_variant.rs:9:15
   |
-8 |     #[serde(borrow)]
-  |             ^^^^^^
+9 |     S(#[serde(borrow)] Str<'a>),
+  |               ^^^^^^

test_suite/tests/ui/borrow/empty_lifetimes.rs

@@ -3,6 +3,8 @@ use serde_derive::Deserialize;
 #[derive(Deserialize)]
 struct Test<'a> {
     #[serde(borrow = "")]
+    r: &'a str,
+    #[serde(borrow = "  ")]
     s: &'a str,
 }
 

test_suite/tests/ui/borrow/empty_lifetimes.stderr

@@ -3,3 +3,9 @@ error: at least one lifetime must be borrowed
   |
 5 |     #[serde(borrow = "")]
   |                      ^^
+
+error: at least one lifetime must be borrowed
+ --> tests/ui/borrow/empty_lifetimes.rs:7:22
+  |
+7 |     #[serde(borrow = "  ")]
+  |                      ^^^^

test_suite/tests/ui/malformed/cut_off.stderr

@@ -1,4 +1,4 @@
-error: unexpected end of input, expected literal
+error: unexpected end of input, expected an expression
  --> tests/ui/malformed/cut_off.rs:4:17
   |
 4 | #[serde(rename =)]

test_suite/tests/ui/malformed/not_list.stderr

@@ -1,11 +1,11 @@
-error: expected #[serde(...)]
+error: expected attribute arguments in parentheses: #[serde(...)]
  --> tests/ui/malformed/not_list.rs:4:3
   |
 4 | #[serde]
   |   ^^^^^
 
-error: expected #[serde(...)]
- --> tests/ui/malformed/not_list.rs:5:3
+error: expected parentheses: #[serde(...)]
+ --> tests/ui/malformed/not_list.rs:5:9
   |
 5 | #[serde = "?"]
-  |   ^^^^^^^^^^^
+  |         ^

test_suite/tests/ui/malformed/trailing_expr.rs

@@ -0,0 +1,9 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+struct S {
+    #[serde(skip_serializing_if, x.is_empty())]
+    x: Vec<()>,
+}
+
+fn main() {}

test_suite/tests/ui/malformed/trailing_expr.stderr

@@ -0,0 +1,5 @@
+error: expected `=`
+ --> tests/ui/malformed/trailing_expr.rs:5:32
+  |
+5 |     #[serde(skip_serializing_if, x.is_empty())]
+  |                                ^

test_suite/tests/ui/unexpected-literal/container.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde container attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/container.rs:4:9
   |
 4 | #[serde("literal")]

test_suite/tests/ui/unexpected-literal/field.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde field attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/field.rs:5:13
   |
 5 |     #[serde("literal")]

test_suite/tests/ui/unexpected-literal/variant.stderr

@@ -1,4 +1,4 @@
-error: unexpected literal in serde variant attribute
+error: unexpected literal in nested attribute, expected ident
  --> tests/ui/unexpected-literal/variant.rs:5:13
   |
 5 |     #[serde("literal")]