Touch up PR 2879

serde_derive/src/de.rs

@@ -1,6 +1,6 @@
+use crate::deprecated::allow_deprecated;
 use crate::fragment::{Expr, Fragment, Match, Stmts};
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
-use crate::internals::deprecated::allow_deprecated;
 use crate::internals::name::Name;
 use crate::internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
 use crate::{bound, dummy, pretend, private, this};
@@ -23,13 +23,12 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
     precondition(&ctxt, &cont);
     ctxt.check()?;
 
-    let allow_deprecated = allow_deprecated(input)?;
-
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
     let body = Stmts(deserialize_body(&cont, &params));
     let delife = params.borrowed.de_lifetime();
+    let allow_deprecated = allow_deprecated(input);
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;

serde_derive/src/deprecated.rs

@@ -0,0 +1,56 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub fn allow_deprecated(input: &syn::DeriveInput) -> Option<TokenStream> {
+    if should_allow_deprecated(input) {
+        Some(quote! { #[allow(deprecated)] })
+    } else {
+        None
+    }
+}
+
+/// Determine if an `#[allow(deprecated)]` should be added to the derived impl.
+///
+/// This should happen if the derive input or an enum variant it contains has
+/// one of:
+///   - `#[deprecated]`
+///   - `#[allow(deprecated)]`
+fn should_allow_deprecated(input: &syn::DeriveInput) -> bool {
+    if contains_deprecated(&input.attrs) {
+        return true;
+    }
+    if let syn::Data::Enum(data_enum) = &input.data {
+        for variant in &data_enum.variants {
+            if contains_deprecated(&variant.attrs) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// Check whether the given attributes contains one of:
+///   - `#[deprecated]`
+///   - `#[allow(deprecated)]`
+fn contains_deprecated(attrs: &[syn::Attribute]) -> bool {
+    for attr in attrs {
+        if attr.path().is_ident("deprecated") {
+            return true;
+        }
+        if let syn::Meta::List(meta_list) = &attr.meta {
+            if meta_list.path.is_ident("allow") {
+                let mut allow_deprecated = false;
+                let _ = meta_list.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("deprecated") {
+                        allow_deprecated = true;
+                    }
+                    Ok(())
+                });
+                if allow_deprecated {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}

serde_derive/src/internals/deprecated.rs

@@ -1,58 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-
-pub fn allow_deprecated(input: &syn::DeriveInput) -> syn::Result<TokenStream> {
-    if should_allow_deprecated(input)? {
-        Ok(quote! { #[allow(deprecated)]})
-    } else {
-        Ok(TokenStream::default())
-    }
-}
-
-/// Determine if an `#[allow(deprecated)]` should be added to the derived impl.
-///
-/// This should happen if the derive input or a variant of the enum (if derive input is an enum)
-/// has on of:
-///   - `#[deprecated]`
-///   - `#[allow(deprecated)]`
-fn should_allow_deprecated(input: &syn::DeriveInput) -> syn::Result<bool> {
-    if contains_deprecated_attrs(&input.attrs)? {
-        return Ok(true);
-    }
-    if let syn::Data::Enum(data_enum) = &input.data {
-        for variant in &data_enum.variants {
-            if contains_deprecated_attrs(&variant.attrs)? {
-                return Ok(true);
-            }
-        }
-    }
-    Ok(false)
-}
-
-/// Check whether a set of attributes contains one of:
-///   - `#[deprecated]`
-///   - `#[allow(deprecated)]`
-fn contains_deprecated_attrs(attrs: &[syn::Attribute]) -> syn::Result<bool> {
-    for attr in attrs {
-        if let syn::Meta::Path(path) = &attr.meta {
-            if path.is_ident("deprecated") {
-                return Ok(true);
-            }
-        }
-        if let syn::Meta::List(meta_list) = &attr.meta {
-            if meta_list.path.is_ident("allow") {
-                let mut deprecated_allowed = false;
-                meta_list.parse_nested_meta(|meta| {
-                    if meta.path.is_ident("deprecated") {
-                        deprecated_allowed = true;
-                    }
-                    Ok(())
-                })?;
-                if deprecated_allowed {
-                    return Ok(true);
-                }
-            }
-        }
-    }
-    Ok(false)
-}

serde_derive/src/internals/mod.rs

@@ -1,6 +1,5 @@
 pub mod ast;
 pub mod attr;
-pub mod deprecated;
 pub mod name;
 
 mod case;

serde_derive/src/lib.rs

@@ -86,6 +86,7 @@ mod bound;
 mod fragment;
 
 mod de;
+mod deprecated;
 mod dummy;
 mod pretend;
 mod ser;

serde_derive/src/ser.rs

@@ -1,6 +1,6 @@
+use crate::deprecated::allow_deprecated;
 use crate::fragment::{Fragment, Match, Stmts};
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
-use crate::internals::deprecated::allow_deprecated;
 use crate::internals::name::Name;
 use crate::internals::{attr, replace_receiver, Ctxt, Derive};
 use crate::{bound, dummy, pretend, private, this};
@@ -19,12 +19,12 @@ pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<Toke
     };
     precondition(&ctxt, &cont);
     ctxt.check()?;
-    let allow_deprecated = allow_deprecated(input)?;
 
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
     let body = Stmts(serialize_body(&cont, &params));
+    let allow_deprecated = allow_deprecated(input);
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;

test_suite/tests/test_deprecated.rs

@@ -3,32 +3,28 @@
 
 use serde_derive::{Deserialize, Serialize};
 
-/// deprecated enum
 #[derive(Serialize, Deserialize)]
 #[deprecated]
-enum E1 {
+enum DeprecatedEnum {
     A,
     B,
 }
 
-/// deprecated struct
 #[derive(Serialize, Deserialize)]
 #[deprecated]
-struct S1 {
+struct DeprecatedStruct {
     a: bool,
 }
 
-/// deprecated enum variant
 #[derive(Serialize, Deserialize)]
-enum E2 {
+enum DeprecatedVariant {
     A,
     #[deprecated]
     B,
 }
 
-/// deprecated struct field
 #[derive(Serialize, Deserialize)]
-struct S2 {
+struct DeprecatedField {
     #[deprecated]
     a: bool,
 }