Overhaul use-case checking

Author: daxpedda

src/attr/item.rs

@@ -104,7 +104,7 @@ pub struct DeriveWhere {
 	/// Save [`Span`] for error messages.
 	pub span: Span,
 	/// [traits](DeriveTrait) to implement.
-	pub traits: Vec<DeriveTrait>,
+	pub traits: Vec<DeriveTraitWrapper>,
 	/// [generics](Generic) for where clause.
 	pub generics: Vec<Generic>,
 }
@@ -125,7 +125,7 @@ impl DeriveWhere {
 				// Start with parsing a trait.
 				// Not checking for duplicates here, because these should produce a Rust error
 				// anyway.
-				traits.push(DeriveTrait::from_stream(span, data, input)?);
+				traits.push(DeriveTraitWrapper::from_stream(span, data, input)?);
 
 				if !input.is_empty() {
 					let mut fork = input.fork();
@@ -178,7 +178,8 @@ impl DeriveWhere {
 	pub fn trait_(&self, trait_: &Trait) -> Option<&DeriveTrait> {
 		self.traits
 			.iter()
-			.find(|derive_trait| &***derive_trait == trait_)
+			.map(|wrapper| &wrapper.trait_)
+			.find(|derive_trait| derive_trait == trait_)
 	}
 
 	/// Returns `true` if any [`CustomBound`](Generic::CustomBound) is present.
@@ -275,6 +276,14 @@ impl Parse for Generic {
 	}
 }
 
+/// Wrapper around [`DeriveTrait`] to add [`Span`].
+pub struct DeriveTraitWrapper {
+	/// [`Span`] for error messages.
+	pub span: Span,
+	/// Trait in this wrapper.
+	trait_: DeriveTrait,
+}
+
 /// Trait to implement.
 pub enum DeriveTrait {
 	/// [`Clone`].
@@ -305,6 +314,14 @@ pub enum DeriveTrait {
 	},
 }
 
+impl Deref for DeriveTraitWrapper {
+	type Target = DeriveTrait;
+
+	fn deref(&self) -> &Self::Target {
+		&self.trait_
+	}
+}
+
 impl Deref for DeriveTrait {
 	type Target = Trait;
 
@@ -327,7 +344,21 @@ impl Deref for DeriveTrait {
 	}
 }
 
-impl DeriveTrait {
+impl PartialEq<Trait> for &DeriveTraitWrapper {
+	fn eq(&self, other: &Trait) -> bool {
+		let trait_: &DeriveTrait = self;
+		trait_ == *other
+	}
+}
+
+impl PartialEq<Trait> for &DeriveTrait {
+	fn eq(&self, other: &Trait) -> bool {
+		let trait_: &Trait = self;
+		trait_ == other
+	}
+}
+
+impl DeriveTraitWrapper {
 	/// Create [`DeriveTrait`] from [`ParseStream`].
 	fn from_stream(span: Span, data: &Data, input: ParseStream) -> Result<Self> {
 		match Meta::parse(input) {
@@ -342,23 +373,31 @@ impl DeriveTrait {
 				}
 
 				match meta {
-					Meta::Path(_) => Ok(trait_.default_derive_trait()),
+					Meta::Path(path) => Ok(Self {
+						span: path.span(),
+						trait_: trait_.default_derive_trait(),
+					}),
 					Meta::List(list) => {
 						if list.nested.is_empty() {
 							return Err(Error::option_empty(list.span()));
 						}
 
-						// This will return an error if no options are supported.
-						trait_.parse_derive_trait(list)
+						Ok(Self {
+							span: list.span(),
+							// This will return an error if no options are supported.
+							trait_: trait_.parse_derive_trait(list)?,
+						})
 					}
 					Meta::NameValue(name_value) => Err(Error::option_syntax(name_value.span())),
 				}
 			}
 			Err(error) => Err(Error::trait_syntax(error.span())),
 		}
 	}
+}
 
-	/// Returns fully qualified path for this trait.
+impl DeriveTrait {
+	/// Returns fully qualified [`Path`] for this trait.
 	pub fn path(&self) -> Path {
 		use DeriveTrait::*;
 

src/attr/skip.rs

@@ -167,12 +167,4 @@ impl Skip {
 			}
 		}
 	}
-
-	/// Returns `true` if any field is skipped.
-	pub fn any_skip(&self) -> bool {
-		match self {
-			Skip::None => false,
-			Skip::All | Skip::Traits(_) => true,
-		}
-	}
 }

src/data.rs

@@ -261,15 +261,6 @@ impl<'a> Data<'a> {
 		self.iter_fields(trait_).count() == 0
 	}
 
-	/// Returns `true` if any field is skipped.
-	pub fn any_skip(&self) -> bool {
-		self.skip_inner.any_skip()
-			|| match self.fields() {
-				Either::Left(fields) => fields.any_skip(),
-				Either::Right(_) => false,
-			}
-	}
-
 	/// Returns `true` if a field is skipped with that [`Trait`].
 	pub fn any_skip_trait(&self, trait_: &Trait) -> bool {
 		self.skip_inner.skip(trait_)

src/data/field.rs

@@ -124,11 +124,6 @@ impl<'a> Field<'a> {
 		}
 	}
 
-	/// Returns `true` if this field is skipped with any [`Trait`].
-	pub fn any_skip(&self) -> bool {
-		self.attr.skip.any_skip()
-	}
-
 	/// Returns `true` if this field is skipped with the given [`Trait`].
 	pub fn skip(&self, trait_: &Trait) -> bool {
 		self.attr.skip.skip(trait_)

src/data/fields.rs

@@ -146,11 +146,6 @@ impl<'a> Fields<'a> {
 		pattern
 	}
 
-	/// Returns `true` if any field is skipped.
-	pub fn any_skip(&self) -> bool {
-		self.fields.iter().any(|field| field.any_skip())
-	}
-
 	/// Returns `true` if any field is skipped with that [`Trait`].
 	pub fn any_skip_trait(&self, trait_: &Trait) -> bool {
 		self.fields.iter().any(|field| field.skip(trait_))

src/error.rs

@@ -20,21 +20,11 @@ impl Error {
 	}
 
 	/// Item has no use-case because it's covered by standard `#[derive(..)]`.
-	pub fn item(span: Span) -> syn::Error {
+	pub fn use_case(span: Span) -> syn::Error {
 		syn::Error::new(
 			span,
-			"derive-where doesn't support items without generics, `skip` attributes or `enum`s \
-			 implementing `Default`, as this can already be handled by standard `#[derive(..)]`",
-		)
-	}
-
-	/// Using the same generic type parameters as the item is unsupported,
-	/// because it's covered by standard `#[derive(..)]`.
-	pub fn generics(span: Span) -> syn::Error {
-		syn::Error::new(
-			span,
-			"derive-where doesn't support items with the same generic type parameters as the \
-			 item, as this can already be handled by standard `#[derive(..)]`",
+			"this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement \
+			 `Default` on an enum, of different generic type parameters",
 		)
 	}
 

src/input.rs

@@ -89,43 +89,6 @@ impl<'a> Input<'a> {
 			}
 		};
 
-		// Don't allow no use-case compared to std `derive`.
-		let mut found_use_case = false;
-		// Any generics used.
-		found_use_case |= generics.params.iter().any(|generic_param|
-				// MSRV: `matches!` was added in 1.42.0.
-				match generic_param {
-				GenericParam::Type(_) => true,
-				GenericParam::Lifetime(_) | GenericParam::Const(_) => false,
-			});
-		// Any field is skipped.
-		found_use_case |= item.any_skip();
-		// `Default` is used on an enum.
-		found_use_case |= item.any_default(&derive_wheres);
-		#[cfg(feature = "zeroize")]
-		{
-			// `Zeroize(crate = "..")` is used.
-			found_use_case |= derive_wheres.iter().any(|derive_where| {
-				#[allow(clippy::match_like_matches_macro)]
-				{
-					if let Some(DeriveTrait::Zeroize {
-						crate_: Some(_), ..
-					}) = derive_where.trait_(&Trait::Zeroize)
-					{
-						true
-					} else {
-						false
-					}
-				}
-			});
-			// `Zeroize(fqs)` is used on any field.
-			found_use_case |= item.any_fqs();
-		}
-
-		if !found_use_case {
-			return Err(Error::item(span));
-		}
-
 		// Don't allow generic constraints be the same as generics on item unless there
 		// is a use-case for it.
 		// Count number of generic type parameters.
@@ -168,40 +131,32 @@ impl<'a> Input<'a> {
 			// The `for` loop should short-circuit to the `'outer` loop if not all generic
 			// type parameters were found.
 
-			// Make sure we aren't using any other features.
-			let mut found_use_case = false;
-			// `Default` is used on an enum.
-			found_use_case |= match item {
-				Item::Enum { .. } => derive_where.trait_(&Trait::Default).is_some(),
-				Item::Item(_) => false,
-			};
-			// Any field is skipped with a corresponding `Trait`.
-			found_use_case |= derive_where
-				.traits
-				.iter()
-				.any(|trait_| item.any_skip_trait(trait_));
-			#[cfg(feature = "zeroize")]
-			{
-				// `Zeroize(crate = "..")` is used.
-				found_use_case |= {
-					#[allow(clippy::match_like_matches_macro)]
+			// Don't allow no use-case compared to std `derive`.
+			for trait_ in &derive_where.traits {
+				// `Default` is used on an enum.
+				if trait_ == Trait::Default && item.is_enum() {
+					continue;
+				}
+				// Any field is skipped with a corresponding `Trait`.
+				if item.any_skip_trait(trait_) {
+					continue;
+				}
+				#[cfg(feature = "zeroize")]
+				{
+					// `Zeroize(crate = "..")` is used.
+					if let DeriveTrait::Zeroize {
+						crate_: Some(_), ..
+					} = **trait_
 					{
-						if let Some(DeriveTrait::Zeroize {
-							crate_: Some(_), ..
-						}) = derive_where.trait_(&Trait::Zeroize)
-						{
-							true
-						} else {
-							false
-						}
+						continue;
 					}
-				};
-				// `Zeroize(fqs)` is used on any field.
-				found_use_case |= derive_where.trait_(&Trait::Zeroize).is_some() && item.any_fqs();
-			}
+					// `Zeroize(fqs)` is used on any field.
+					if trait_ == Trait::Zeroize && item.any_fqs() {
+						continue;
+					}
+				}
 
-			if !found_use_case {
-				return Err(Error::generics(derive_where.span));
+				return Err(Error::use_case(trait_.span));
 			}
 		}
 

src/item.rs

@@ -2,7 +2,7 @@
 
 use syn::Ident;
 
-use crate::{Data, DeriveWhere, Trait};
+use crate::{Data, Trait};
 
 /// Fields or variants of an item.
 #[allow(clippy::large_enum_variant)]
@@ -19,39 +19,27 @@ pub enum Item<'a> {
 }
 
 impl Item<'_> {
-	/// Return [`struct@Ident`] of this [`Item`].
+	/// Returns [`struct@Ident`] of this [`Item`].
 	pub fn ident(&self) -> &Ident {
 		match self {
 			Item::Item(data) => data.ident,
 			Item::Enum { ident, .. } => ident,
 		}
 	}
 
-	/// Returns `true` if any field is skipped with that [`Trait`].
-	pub fn any_skip_trait(&self, trait_: &Trait) -> bool {
-		match self {
-			Item::Item(data) => data.any_skip_trait(trait_),
-			Item::Enum { variants, .. } => variants.iter().any(|data| data.any_skip_trait(trait_)),
-		}
-	}
-
-	/// Returns `true` if any field is skipped.
-	pub fn any_skip(&self) -> bool {
+	/// Returns `true` if this [`Item`] if an enum.
+	pub fn is_enum(&self) -> bool {
 		match self {
-			Item::Item(data) => data.any_skip(),
-			Item::Enum { variants, .. } => variants.iter().any(|data| data.any_skip()),
+			Item::Enum { .. } => true,
+			Item::Item(_) => false,
 		}
 	}
 
-	/// Returns `true` if any field uses `default`.
-	// MSRV: `matches!` was added in 1.42.0.
-	#[allow(clippy::match_like_matches_macro)]
-	pub fn any_default(&self, derive_wheres: &[DeriveWhere]) -> bool {
+	/// Returns `true` if any field is skipped with that [`Trait`].
+	pub fn any_skip_trait(&self, trait_: &Trait) -> bool {
 		match self {
-			Item::Enum { .. } => derive_wheres
-				.iter()
-				.any(|derive_where| derive_where.trait_(&Trait::Default).is_some()),
-			_ => false,
+			Item::Item(data) => data.any_skip_trait(trait_),
+			Item::Enum { variants, .. } => variants.iter().any(|data| data.any_skip_trait(trait_)),
 		}
 	}