Implement skip groups

Author: daxpedda

.config/topic.dic

@@ -4,6 +4,7 @@ CHANGELOG
 destructure/G
 enum/S
 FQS
+invariants
 io
 MSRV
 std's

README.md

@@ -138,7 +138,14 @@ assert_eq!(format!("{:?}", EnumExample::A(42)), "A");
 ```
 
 Selective skipping of fields for certain traits is also an option, both in
-`skip` and `skip_inner`:
+`skip` and `skip_inner`. To prevent breaking invariants defined for these
+traits, some of them can only be skipped in groups. The following groups are
+available:
+- [`Debug`]
+- `EqHashOrd`: Skips [`Eq`], [`Hash`], [`Ord`], [`PartialOrd`] and
+  [`PartialEq`].
+- [`Hash`]
+- `Zeroize`: Skips [`Zeroize`] and [`ZeroizeOnDrop`].
 
 ```rust
 #[derive_where(Debug, PartialEq)]

src/attr.rs

@@ -14,6 +14,6 @@ pub use self::{
 	default::Default,
 	field::FieldAttr,
 	item::{DeriveTrait, DeriveWhere, Generic, ItemAttr},
-	skip::Skip,
+	skip::{Skip, SkipGroup},
 	variant::VariantAttr,
 };

src/attr/default.rs

@@ -26,7 +26,7 @@ impl Default {
 				let mut impl_default = false;
 
 				for derive_where in derive_wheres {
-					if derive_where.trait_(&Trait::Default).is_some() {
+					if derive_where.contains(Trait::Default) {
 						impl_default = true;
 						break;
 					}

src/attr/item.rs

@@ -11,7 +11,7 @@ use syn::{
 	TraitBoundModifier, Type, TypeParamBound, TypePath, WhereClause, WherePredicate,
 };
 
-use crate::{util, Error, Item, Skip, Trait, TraitImpl, DERIVE_WHERE};
+use crate::{util, Error, Item, Skip, SkipGroup, Trait, TraitImpl, DERIVE_WHERE};
 
 /// Attributes on item.
 #[derive(Default)]
@@ -209,11 +209,11 @@ impl DeriveWhere {
 		})
 	}
 
-	/// Returns selected [`DeriveTrait`] if present.
-	pub fn trait_(&self, trait_: &Trait) -> Option<&DeriveTrait> {
+	/// Returns `true` if [`Trait`] is present.
+	pub fn contains(&self, trait_: Trait) -> bool {
 		self.traits
 			.iter()
-			.find(|derive_trait| derive_trait == trait_)
+			.any(|derive_trait| derive_trait == trait_)
 	}
 
 	/// Returns `true` if any [`CustomBound`](Generic::CustomBound) is present.
@@ -240,7 +240,9 @@ impl DeriveWhere {
 
 	/// Returns `true` if any [`Trait`] supports skipping.
 	pub fn any_skip(&self) -> bool {
-		self.traits.iter().any(|trait_| trait_.supports_skip())
+		self.traits
+			.iter()
+			.any(|trait_| SkipGroup::trait_supported(**trait_))
 	}
 
 	/// Create [`WhereClause`] for the given parameters.

src/attr/skip.rs

@@ -2,9 +2,9 @@
 
 use std::default::Default;
 
-use syn::{spanned::Spanned, Meta, NestedMeta, Result};
+use syn::{spanned::Spanned, Meta, NestedMeta, Path, Result};
 
-use crate::{DeriveWhere, Error, Trait, TraitImpl};
+use crate::{DeriveWhere, Error, Trait};
 
 /// Stores what [`Trait`]s to skip this field or variant for.
 #[cfg_attr(test, derive(Debug))]
@@ -14,7 +14,7 @@ pub enum Skip {
 	/// Field skipped for all [`Trait`]s that support it.
 	All,
 	/// Field skipped for the [`Trait`]s listed.
-	Traits(Vec<Trait>),
+	Traits(Vec<SkipGroup>),
 }
 
 impl Default for Skip {
@@ -102,37 +102,34 @@ impl Skip {
 
 				for nested_meta in &list.nested {
 					if let NestedMeta::Meta(Meta::Path(path)) = nested_meta {
-						let trait_ = Trait::from_path(path)?;
-
-						// Don't allow unsupported traits to be skipped.
-						if trait_.supports_skip() {
-							// Don't allow to skip the same trait twice.
-							if traits.contains(&trait_) {
-								return Err(Error::option_skip_duplicate(
-									path.span(),
-									trait_.as_str(),
-								));
-							} else {
-								// Don't allow to skip a trait already set to be skipped in the
-								// parent.
-								match skip_inner {
-									Some(skip_inner) if skip_inner.skip(&trait_) => {
-										return Err(Error::option_skip_inner(path.span()))
-									}
-									_ => {
-										// Don't allow to skip trait that isn't being implemented.
-										if derive_wheres.iter().any(|derive_where| {
-											derive_where.trait_(&trait_).is_some()
-										}) {
-											traits.push(trait_)
-										} else {
-											return Err(Error::option_skip_trait(path.span()));
-										}
+						let skip_group = SkipGroup::from_path(path)?;
+
+						// Don't allow to skip the same trait twice.
+						if traits.contains(&skip_group) {
+							return Err(Error::option_skip_duplicate(
+								path.span(),
+								skip_group.as_str(),
+							));
+						} else {
+							// Don't allow to skip a trait already set to be skipped in the
+							// parent.
+							match skip_inner {
+								Some(skip_inner) if skip_inner.group_skipped(skip_group) => {
+									return Err(Error::option_skip_inner(path.span()))
+								}
+								_ => {
+									// Don't allow to skip trait that isn't being implemented.
+									if derive_wheres.iter().any(|derive_where| {
+										skip_group
+											.traits()
+											.any(|trait_| derive_where.contains(trait_))
+									}) {
+										traits.push(skip_group)
+									} else {
+										return Err(Error::option_skip_trait(path.span()));
 									}
 								}
 							}
-						} else {
-							return Err(Error::option_skip_support(path.span(), trait_.as_str()));
 						}
 					} else {
 						return Err(Error::option_syntax(nested_meta.span()));
@@ -147,15 +144,118 @@ impl Skip {
 
 	/// Returns `true` if this item, variant or field is skipped with the given
 	/// [`Trait`].
-	pub fn skip(&self, trait_: &Trait) -> bool {
+	pub fn trait_skipped(&self, trait_: Trait) -> bool {
+		match self {
+			Skip::None => false,
+			Skip::All => SkipGroup::trait_supported(trait_),
+			Skip::Traits(skip_groups) => skip_groups
+				.iter()
+				.any(|skip_group| skip_group.traits().any(|this_trait| this_trait == trait_)),
+		}
+	}
+
+	/// Returns `true` if this item, variant or field is skipped with the given
+	/// [`SkipGroup`].
+	pub fn group_skipped(&self, group: SkipGroup) -> bool {
 		match self {
 			Skip::None => false,
-			Skip::All => trait_.supports_skip(),
-			Skip::Traits(traits) => {
-				let skip = traits.contains(trait_);
-				debug_assert!(!skip || trait_.supports_skip());
-				skip
+			Skip::All => true,
+			Skip::Traits(groups) => groups.iter().any(|this_group| *this_group == group),
+		}
+	}
+}
+
+/// Available groups of [`Trait`]s to skip.
+#[derive(Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(test, derive(Debug))]
+pub enum SkipGroup {
+	/// [`Debug`].
+	Debug,
+	/// [`Eq`], [`Hash`], [`Ord`], [`PartialEq`] and [`PartialOrd`].
+	EqHashOrd,
+	/// [`Hash`].
+	Hash,
+	/// [`Zeroize`](https://docs.rs/zeroize/latest/zeroize/trait.Zeroize.html) and
+	/// [`ZeroizeOnDrop`](https://docs.rs/zeroize/latest/zeroize/trait.ZeroizeOnDrop.html).
+	#[cfg(feature = "zeroize")]
+	Zeroize,
+}
+
+impl SkipGroup {
+	/// Create [`SkipGroup`] from [`Path`].
+	fn from_path(path: &Path) -> Result<Self> {
+		if let Some(ident) = path.get_ident() {
+			use SkipGroup::*;
+
+			match ident.to_string().as_str() {
+				"Debug" => Ok(Debug),
+				"EqHashOrd" => Ok(EqHashOrd),
+				"Hash" => Ok(Hash),
+				#[cfg(feature = "zeroize")]
+				"Zeroize" => Ok(Zeroize),
+				_ => Err(Error::skip_group(path.span())),
 			}
+		} else {
+			Err(Error::skip_group(path.span()))
+		}
+	}
+
+	/// [`str`] representation of this [`Trait`].
+	/// Used to compare against [`Ident`](struct@syn::Ident)s and create error
+	/// messages.
+	const fn as_str(self) -> &'static str {
+		match self {
+			Self::Debug => "Debug",
+			Self::EqHashOrd => "EqHashOrd",
+			Self::Hash => "Hash",
+			#[cfg(feature = "zeroize")]
+			Self::Zeroize => "Zeroize",
+		}
+	}
+
+	/// [`Trait`]s supported by this group.
+	fn traits(self) -> impl Iterator<Item = Trait> {
+		match self {
+			Self::Debug => [Some(Trait::Debug), None, None, None, None]
+				.into_iter()
+				.flatten(),
+			Self::EqHashOrd => [
+				Some(Trait::Eq),
+				Some(Trait::Hash),
+				Some(Trait::Ord),
+				Some(Trait::PartialEq),
+				Some(Trait::PartialOrd),
+			]
+			.into_iter()
+			.flatten(),
+			Self::Hash => [Some(Trait::Hash), None, None, None, None]
+				.into_iter()
+				.flatten(),
+			#[cfg(feature = "zeroize")]
+			Self::Zeroize => [
+				Some(Trait::Zeroize),
+				Some(Trait::ZeroizeOnDrop),
+				None,
+				None,
+				None,
+			]
+			.into_iter()
+			.flatten(),
+		}
+	}
+
+	/// Returns `true` if [`Trait`] is supported by any group.
+	pub fn trait_supported(trait_: Trait) -> bool {
+		match trait_ {
+			Trait::Clone | Trait::Copy | Trait::Default => false,
+			Trait::Debug
+			| Trait::Eq
+			| Trait::Hash
+			| Trait::Ord
+			| Trait::PartialEq
+			| Trait::PartialOrd => true,
+			#[cfg(feature = "zeroize")]
+			Trait::Zeroize | Trait::ZeroizeOnDrop => true,
 		}
 	}
 }

src/attr/zeroize_fqs.rs

@@ -19,7 +19,7 @@ impl ZeroizeFqs {
 
 		if !derive_wheres
 			.iter()
-			.any(|derive_where| derive_where.trait_(&Trait::Zeroize).is_some())
+			.any(|derive_where| derive_where.contains(Trait::Zeroize))
 		{
 			return Err(Error::zeroize(meta.span()));
 		}

src/data.rs

@@ -257,22 +257,22 @@ impl<'a> Data<'a> {
 	}
 
 	/// Returns `true` if this [`Data`] has no [`Fields`].
-	pub fn is_empty(&self, trait_: &Trait) -> bool {
+	pub fn is_empty(&self, trait_: Trait) -> bool {
 		self.iter_fields(trait_).count() == 0
 	}
 
 	/// Returns `true` if a field is skipped with that [`Trait`].
-	pub fn any_skip_trait(&self, trait_: &Trait) -> bool {
-		self.skip_inner.skip(trait_)
+	pub fn any_skip_trait(&self, trait_: Trait) -> bool {
+		self.skip_inner.trait_skipped(trait_)
 			|| match self.fields() {
 				Either::Left(fields) => fields.any_skip_trait(trait_),
 				Either::Right(_) => false,
 			}
 	}
 
 	/// Returns `true` if all fields are skipped with that [`Trait`].
-	fn skip(&self, trait_: &Trait) -> bool {
-		self.skip_inner.skip(trait_)
+	fn skip(&self, trait_: Trait) -> bool {
+		self.skip_inner.trait_skipped(trait_)
 			|| match self.fields() {
 				Either::Left(fields) => fields.skip(trait_),
 				Either::Right(_) => false,
@@ -302,9 +302,9 @@ impl<'a> Data<'a> {
 
 	/// Returns an [`Iterator`] over [`Field`]s.
 	pub fn iter_fields(
-		&'a self,
-		trait_: &'a Trait,
-	) -> impl 'a + Iterator<Item = &'a Field> + DoubleEndedIterator {
+		&self,
+		trait_: Trait,
+	) -> impl '_ + Iterator<Item = &'_ Field> + DoubleEndedIterator {
 		if self.skip(trait_) {
 			[].iter()
 		} else {
@@ -317,25 +317,25 @@ impl<'a> Data<'a> {
 	}
 
 	/// Returns an [`Iterator`] over [`Member`]s.
-	pub fn iter_field_ident(&'a self, trait_: &'a Trait) -> impl 'a + Iterator<Item = &'a Member> {
+	pub fn iter_field_ident(&self, trait_: Trait) -> impl '_ + Iterator<Item = &'_ Member> {
 		self.iter_fields(trait_).map(|field| &field.member)
 	}
 
 	/// Returns an [`Iterator`] over [`struct@Ident`]s used as temporary
 	/// variables for destructuring `self`.
 	pub fn iter_self_ident(
-		&'a self,
-		trait_: &'a Trait,
-	) -> impl Iterator<Item = &'a Ident> + DoubleEndedIterator {
+		&self,
+		trait_: Trait,
+	) -> impl Iterator<Item = &'_ Ident> + DoubleEndedIterator {
 		self.iter_fields(trait_).map(|field| &field.self_ident)
 	}
 
 	/// Returns an [`Iterator`] over [`struct@Ident`]s used as temporary
 	/// variables for destructuring `other`.
 	pub fn iter_other_ident(
-		&'a self,
-		trait_: &'a Trait,
-	) -> impl Iterator<Item = &'a Ident> + DoubleEndedIterator {
+		&self,
+		trait_: Trait,
+	) -> impl Iterator<Item = &'_ Ident> + DoubleEndedIterator {
 		self.iter_fields(trait_).map(|field| &field.other_ident)
 	}
 }

src/data/field.rs

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

src/data/fields.rs

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