Re-use #[serde(crate = "...")]

Author: daxpedda

src/attr/item.rs

@@ -70,20 +70,20 @@ impl ItemAttr {
 								else {
 									self_
 										.derive_wheres
-										.push(DeriveWhere::from_attr(span, data, attr)?);
+										.push(DeriveWhere::from_attr(attrs, span, data, attr)?);
 								}
 							}
 							_ => self_
 								.derive_wheres
-								.push(DeriveWhere::from_attr(span, data, attr)?),
+								.push(DeriveWhere::from_attr(attrs, span, data, attr)?),
 						}
 					}
 					// Anything list that isn't using `,` as separator, is because we expect
 					// `A, B; C`.
 					else {
 						self_
 							.derive_wheres
-							.push(DeriveWhere::from_attr(span, data, attr)?)
+							.push(DeriveWhere::from_attr(attrs, span, data, attr)?)
 					}
 				} else {
 					return Err(Error::option_syntax(attr.meta.span()));
@@ -167,7 +167,7 @@ pub struct DeriveWhere {
 
 impl DeriveWhere {
 	/// Create [`DeriveWhere`] from [`Attribute`].
-	fn from_attr(span: Span, data: &Data, attr: &Attribute) -> Result<Self> {
+	fn from_attr(attrs: &[Attribute], span: Span, data: &Data, attr: &Attribute) -> Result<Self> {
 		attr.parse_args_with(|input: ParseStream| {
 			// Parse the attribute input, this should either be:
 			// - Comma separated traits.
@@ -184,7 +184,7 @@ impl DeriveWhere {
 				// Start with parsing a trait.
 				// Not checking for duplicates here, we do that after merging `derive_where`s
 				// with the same bounds.
-				let (span, trait_) = DeriveTrait::from_stream(span, data, input)?;
+				let (span, trait_) = DeriveTrait::from_stream(attrs, span, data, input)?;
 				spans.push(span);
 				traits.push(trait_);
 

src/error.rs

@@ -74,7 +74,7 @@ impl Error {
 	}
 
 	/// Unsupported option in attribute.
-	#[cfg(any(feature = "serde", feature = "zeroize"))]
+	#[cfg(feature = "zeroize")]
 	pub fn option_trait(span: Span, attribute: &str) -> syn::Error {
 		syn::Error::new(span, format!("`{}` doesn't support this option", attribute))
 	}
@@ -167,7 +167,8 @@ impl Error {
 		)
 	}
 
-	/// Invalid value for the `derive_where` or `Zeroize` `crate` option.
+	/// Invalid value for the `derive_where`, `serde` or `Zeroize` `crate`
+	/// option.
 	pub fn path(span: Span, parse_error: syn::Error) -> syn::Error {
 		syn::Error::new(span, format!("expected path, {}", parse_error))
 	}

src/trait_.rs

@@ -29,8 +29,8 @@ use syn::{
 	parse::{Parse, ParseStream},
 	punctuated::Punctuated,
 	spanned::Spanned,
-	DeriveInput, Ident, ImplGenerics, Meta, Path, Result, Token, TraitBound, TraitBoundModifier,
-	TypeGenerics, TypeParamBound, WhereClause,
+	Attribute, DeriveInput, Ident, ImplGenerics, Meta, Path, Result, Token, TraitBound,
+	TraitBoundModifier, TypeGenerics, TypeParamBound, WhereClause,
 };
 
 use crate::{util::MetaListExt, Data, DeriveWhere, Error, Item, SplitGenerics};
@@ -148,10 +148,11 @@ impl Trait {
 	/// Re-direct to [`TraitImpl::parse_derive_trait()`].
 	pub fn parse_derive_trait(
 		&self,
+		attrs: &[Attribute],
 		span: Span,
-		list: Punctuated<Meta, Token![,]>,
+		list: Option<Punctuated<Meta, Token![,]>>,
 	) -> Result<DeriveTrait> {
-		trait_dispatch!(self, parse_derive_trait(span, list))
+		trait_dispatch!(self, parse_derive_trait(attrs, span, list))
 	}
 
 	/// Re-direct to [`TraitImpl::supports_union()`].
@@ -256,7 +257,12 @@ impl DeriveTrait {
 	}
 
 	/// Create [`DeriveTrait`] from [`ParseStream`].
-	pub fn from_stream(span: Span, data: &syn::Data, input: ParseStream) -> Result<(Span, Self)> {
+	pub fn from_stream(
+		attrs: &[Attribute],
+		span: Span,
+		data: &syn::Data,
+		input: ParseStream,
+	) -> Result<(Span, Self)> {
 		match Meta::parse(input) {
 			Ok(meta) => {
 				let trait_ = Trait::from_path(meta.path())?;
@@ -269,12 +275,18 @@ impl DeriveTrait {
 				}
 
 				match &meta {
-					Meta::Path(path) => Ok((path.span(), trait_.default_derive_trait())),
+					Meta::Path(path) => Ok((
+						path.span(),
+						trait_.parse_derive_trait(attrs, meta.span(), None)?,
+					)),
 					Meta::List(list) => {
 						let nested = list.parse_non_empty_nested_metas()?;
 
 						// This will return an error if no options are supported.
-						Ok((list.span(), trait_.parse_derive_trait(meta.span(), nested)?))
+						Ok((
+							list.span(),
+							trait_.parse_derive_trait(attrs, meta.span(), Some(nested))?,
+						))
 					}
 					Meta::NameValue(name_value) => Err(Error::option_syntax(name_value.span())),
 				}
@@ -299,11 +311,19 @@ pub trait TraitImpl: Deref<Target = Trait> {
 		Self: Sized;
 
 	/// Parse a `derive_where` trait with it's options.
-	fn parse_derive_trait(span: Span, _list: Punctuated<Meta, Token![,]>) -> Result<DeriveTrait>
+	fn parse_derive_trait(
+		_attrs: &[Attribute],
+		span: Span,
+		list: Option<Punctuated<Meta, Token![,]>>,
+	) -> Result<DeriveTrait>
 	where
 		Self: Sized,
 	{
-		Err(Error::options(span, Self::as_str()))
+		if list.is_some() {
+			Err(Error::options(span, Self::as_str()))
+		} else {
+			Ok(Self::default_derive_trait())
+		}
 	}
 
 	/// Returns `true` if [`Trait`] supports unions.

src/trait_/deserialize.rs

@@ -5,8 +5,8 @@ use std::{borrow::Cow, ops::Deref};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-	punctuated::Punctuated, DeriveInput, Ident, ImplGenerics, Meta, Path, Result, TypeGenerics,
-	WhereClause,
+	punctuated::Punctuated, Attribute, DeriveInput, Ident, ImplGenerics, Meta, Path, Result,
+	TypeGenerics, WhereClause,
 };
 
 use super::serde;
@@ -34,12 +34,16 @@ impl TraitImpl for Deserialize {
 		DeriveTrait::Deserialize(Self { crate_: None })
 	}
 
-	fn parse_derive_trait(span: Span, list: Punctuated<Meta, syn::Token![,]>) -> Result<DeriveTrait>
+	fn parse_derive_trait(
+		attrs: &[Attribute],
+		span: Span,
+		list: Option<Punctuated<Meta, syn::Token![,]>>,
+	) -> Result<DeriveTrait>
 	where
 		Self: Sized,
 	{
 		Ok(DeriveTrait::Deserialize(Self {
-			crate_: serde::parse_derive_trait(Trait::Deserialize, span, list)?,
+			crate_: serde::parse_derive_trait(Trait::Deserialize, attrs, span, list)?,
 		}))
 	}
 

src/trait_/serde.rs

@@ -4,58 +4,68 @@
 
 use proc_macro2::Span;
 use syn::{
-	punctuated::Punctuated, spanned::Spanned, Expr, ExprLit, ExprPath, Lit, Meta, Path, Token,
+	punctuated::Punctuated, spanned::Spanned, Attribute, Expr, ExprLit, Lit, Meta, Path, Token,
 };
 
-use crate::{util, Error, Result, Trait};
+use crate::{Error, Result, Trait};
 
 /// Parses
 pub fn parse_derive_trait(
 	trait_: Trait,
-	_span: Span,
-	list: Punctuated<Meta, Token![,]>,
+	attrs: &[Attribute],
+	span: Span,
+	list: Option<Punctuated<Meta, Token![,]>>,
 ) -> Result<Option<Path>> {
-	// This is already checked in `DeriveTrait::from_stream`.
-	debug_assert!(!list.is_empty());
+	if list.is_some() {
+		return Err(Error::options(span, trait_.as_str()));
+	}
 
 	let mut crate_ = None;
 
-	for meta in list {
-		match &meta {
-			Meta::Path(path) => {
-				return Err(Error::option_trait(path.span(), trait_.as_str()));
-			}
-			Meta::NameValue(name_value) => {
-				if name_value.path.is_ident("crate") {
-					// Check for duplicate `crate` option.
-					if crate_.is_none() {
-						let path = match &name_value.value {
-							Expr::Lit(ExprLit {
-								lit: Lit::Str(lit_str),
-								..
-							}) => match lit_str.parse::<Path>() {
-								Ok(path) => path,
-								Err(error) => return Err(Error::path(lit_str.span(), error)),
-							},
-							Expr::Path(ExprPath { path, .. }) => path.clone(),
-							_ => return Err(Error::option_syntax(name_value.value.span())),
-						};
-
-						if path == util::path_from_strs(&["serde"]) {
-							return Err(Error::path_unnecessary(path.span(), "::serde"));
-						}
+	for attr in attrs {
+		if !attr.path().is_ident("serde") {
+			continue;
+		}
+
+		if let Meta::List(list) = &attr.meta {
+			if let Ok(nested) =
+				list.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)
+			{
+				if nested.len() != 1 {
+					continue;
+				}
+
+				let meta = &nested[0];
 
-						crate_ = Some(path);
-					} else {
-						return Err(Error::option_duplicate(name_value.span(), "crate"));
+				if !meta.path().is_ident("crate") {
+					continue;
+				}
+
+				match &meta {
+					Meta::NameValue(name_value) => {
+						// Check for duplicate `crate` option.
+						if crate_.is_none() {
+							let path = match &name_value.value {
+								Expr::Lit(ExprLit {
+									lit: Lit::Str(lit_str),
+									..
+								}) => match lit_str.parse::<Path>() {
+									Ok(path) => path,
+									Err(error) => return Err(Error::path(lit_str.span(), error)),
+								},
+								_ => return Err(Error::option_syntax(name_value.value.span())),
+							};
+
+							crate_ = Some(path);
+						} else {
+							return Err(Error::option_duplicate(name_value.span(), "crate"));
+						}
+					}
+					_ => {
+						return Err(Error::option_syntax(meta.span()));
 					}
-				} else {
-					return Err(Error::option_trait(name_value.path.span(), trait_.as_str()));
 				}
 			}
-			_ => {
-				return Err(Error::option_syntax(meta.span()));
-			}
 		}
 	}
 

src/trait_/serialize.rs

@@ -5,8 +5,8 @@ use std::{borrow::Cow, ops::Deref};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-	punctuated::Punctuated, DeriveInput, Ident, ImplGenerics, Meta, Path, Result, TypeGenerics,
-	WhereClause,
+	punctuated::Punctuated, Attribute, DeriveInput, Ident, ImplGenerics, Meta, Path, Result,
+	TypeGenerics, WhereClause,
 };
 
 use super::serde;
@@ -34,12 +34,16 @@ impl TraitImpl for Serialize {
 		DeriveTrait::Serialize(Self { crate_: None })
 	}
 
-	fn parse_derive_trait(span: Span, list: Punctuated<Meta, syn::Token![,]>) -> Result<DeriveTrait>
+	fn parse_derive_trait(
+		attrs: &[Attribute],
+		span: Span,
+		list: Option<Punctuated<Meta, syn::Token![,]>>,
+	) -> Result<DeriveTrait>
 	where
 		Self: Sized,
 	{
 		Ok(DeriveTrait::Serialize(Self {
-			crate_: serde::parse_derive_trait(Trait::Serialize, span, list)?,
+			crate_: serde::parse_derive_trait(Trait::Serialize, attrs, span, list)?,
 		}))
 	}
 

src/trait_/zeroize.rs

@@ -5,8 +5,8 @@ use std::ops::Deref;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-	punctuated::Punctuated, spanned::Spanned, Expr, ExprLit, ExprPath, Lit, Meta, Path, Result,
-	Token,
+	punctuated::Punctuated, spanned::Spanned, Attribute, Expr, ExprLit, ExprPath, Lit, Meta, Path,
+	Result, Token,
 };
 
 use crate::{
@@ -29,9 +29,16 @@ impl TraitImpl for Zeroize {
 		DeriveTrait::Zeroize(Self { crate_: None })
 	}
 
-	fn parse_derive_trait(_span: Span, list: Punctuated<Meta, Token![,]>) -> Result<DeriveTrait> {
-		// This is already checked in `DeriveTrait::from_stream`.
-		debug_assert!(!list.is_empty());
+	fn parse_derive_trait(
+		_: &[Attribute],
+		_span: Span,
+		list: Option<Punctuated<Meta, Token![,]>>,
+	) -> Result<DeriveTrait> {
+		let list = if let Some(list) = list {
+			list
+		} else {
+			return Ok(Self::default_derive_trait());
+		};
 
 		let mut crate_ = None;
 

src/trait_/zeroize_on_drop.rs

@@ -5,8 +5,8 @@ use std::{borrow::Cow, iter, ops::Deref};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-	punctuated::Punctuated, spanned::Spanned, DeriveInput, Expr, ExprLit, ExprPath, Ident,
-	ImplGenerics, Lit, Meta, Path, Result, Token, TypeGenerics, WhereClause,
+	punctuated::Punctuated, spanned::Spanned, Attribute, DeriveInput, Expr, ExprLit, ExprPath,
+	Ident, ImplGenerics, Lit, Meta, Path, Result, Token, TypeGenerics, WhereClause,
 };
 
 use crate::{util, DeriveTrait, DeriveWhere, Error, Item, SplitGenerics, Trait, TraitImpl};
@@ -34,9 +34,16 @@ impl TraitImpl for ZeroizeOnDrop {
 		})
 	}
 
-	fn parse_derive_trait(_span: Span, list: Punctuated<Meta, Token![,]>) -> Result<DeriveTrait> {
-		// This is already checked in `DeriveTrait::from_stream`.
-		debug_assert!(!list.is_empty());
+	fn parse_derive_trait(
+		_: &[Attribute],
+		_: Span,
+		list: Option<Punctuated<Meta, Token![,]>>,
+	) -> Result<DeriveTrait> {
+		let list = if let Some(list) = list {
+			list
+		} else {
+			return Ok(Self::default_derive_trait());
+		};
 
 		let mut crate_ = None;
 		#[cfg_attr(not(feature = "zeroize-on-drop"), allow(unused_mut))]

test-crates/crate_/src/lib.rs

@@ -5,20 +5,14 @@ use core::marker::PhantomData;
 use derive_where_::derive_where;
 
 #[derive_where(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(
-	feature = "serde",
-	derive_where(Deserialize(crate = serde_), Serialize(crate = serde_))
-)]
+#[cfg_attr(feature = "serde", derive_where(Deserialize, Serialize))]
 #[cfg_attr(feature = "serde", serde(crate = "serde_"))]
 #[cfg_attr(feature = "zeroize", derive_where(Zeroize(crate = zeroize_)))]
 #[derive_where(crate = derive_where_)]
 pub struct Test<T>(PhantomData<T>);
 
 #[derive_where(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(
-	feature = "serde",
-	derive_where(Deserialize(crate = "serde_"), Serialize(crate = "serde_"))
-)]
+#[cfg_attr(feature = "serde", derive_where(Deserialize, Serialize))]
 #[cfg_attr(feature = "serde", serde(crate = "serde_"))]
 #[cfg_attr(feature = "zeroize", derive_where(Zeroize(crate = "zeroize_")))]
 #[derive_where(crate = "derive_where_")]