Incomparable variant attribute

Author: ModProg

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Added
+- `incomparable` variant and item attribute for `PartialEq` and `PartialOrd`
+  derives, yielding false on all comparisons but `!=`.
+
 ## [1.0.0] - 2022-07-16
 - No changes.
 
@@ -31,6 +36,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release.
 
+[unreleased]: https://github.com/ModProg/derive-where/compare/v1.0.0...HEAD
 [1.0.0]: https://github.com/ModProg/derive-where/compare/v1.0.0-rc.3...v1.0.0
 [1.0.0-rc.3]: https://github.com/ModProg/derive-where/compare/v1.0.0-rc.2...v1.0.0-rc.3
 [1.0.0-rc.2]: https://github.com/ModProg/derive-where/compare/v1.0.0-rc.1...v1.0.0-rc.2

Cargo.toml

@@ -39,6 +39,7 @@ syn = { version = "1.0.56", default-features = false, features = [
 ] }
 
 [dev-dependencies]
+pretty_assertions = "1"
 trybuild = { version = "1.0.18", default-features = false }
 zeroize_ = { version = "1.5", package = "zeroize", default-features = false }
 

README.md

@@ -162,6 +162,43 @@ assert_ne!(
 );
 ```
 
+### Incomparable variants/items
+
+Similar to the `skip` attribute, `incomparable` can be used to skip variants
+or items in [`PartialEq`] and [`PartialOrd`] trait implementations, meaning
+they will always yield `false` for `eq` and `None` for `partial_cmp`. This
+results in all comparisons but `!=`, i.e. `==`, `<`, `<=`, `>=` and `>`,
+with the marked variant or struct evaluating to `false`.
+
+```rust
+# use derive_where::derive_where;
+#[derive(Debug)]
+#[derive_where(PartialEq, PartialOrd)]
+enum EnumExample {
+	#[derive_where(incomparable)]
+	Incomparable,
+	Comparable,
+}
+assert_eq!(EnumExample::Comparable, EnumExample::Comparable);
+assert_ne!(EnumExample::Incomparable, EnumExample::Incomparable);
+assert!(!(EnumExample::Comparable >= EnumExample::Incomparable));
+assert!(!(EnumExample::Comparable <= EnumExample::Incomparable));
+assert!(!(EnumExample::Incomparable >= EnumExample::Incomparable));
+assert!(!(EnumExample::Incomparable <= EnumExample::Incomparable));
+
+#[derive(Debug)]
+#[derive_where(PartialEq, PartialOrd)]
+#[derive_where(incomparable)]
+struct StructExample;
+
+assert_ne!(StructExample, StructExample);
+assert!(!(StructExample >= StructExample));
+assert!(!(StructExample <= StructExample));
+```
+
+Note that it is not possible to use `incomparable` with [`Eq`] or [`Ord`] as
+that would break their invariants.
+
 ### `Zeroize` options
 
 `Zeroize` has two options:

src/attr.rs

@@ -2,6 +2,7 @@
 
 mod default;
 mod field;
+mod incomparable;
 mod item;
 mod skip;
 mod variant;
@@ -13,6 +14,7 @@ pub use self::zeroize_fqs::ZeroizeFqs;
 pub use self::{
 	default::Default,
 	field::FieldAttr,
+	incomparable::Incomparable,
 	item::{DeriveTrait, DeriveWhere, Generic, ItemAttr},
 	skip::{Skip, SkipGroup},
 	variant::VariantAttr,

src/attr/default.rs

@@ -15,7 +15,7 @@ impl Default {
 	/// Token used for the `default` option.
 	pub const DEFAULT: &'static str = "default";
 
-	/// Adds a [`Meta`] to this [`Default`](self).
+	/// Adds a [`Meta`] to this [`Default`](Self).
 	pub fn add_attribute(&mut self, meta: &Meta, derive_wheres: &[DeriveWhere]) -> Result<()> {
 		debug_assert!(meta.path().is_ident(Self::DEFAULT));
 

src/attr/incomparable.rs

@@ -0,0 +1,52 @@
+//! Attribute parsing for the `incomparable` option.
+
+use proc_macro2::Span;
+use syn::{spanned::Spanned, Meta, Result};
+
+use crate::{attr::DeriveTrait, DeriveWhere, Error};
+
+/// Stores if this variant should be incomparable when implementing
+/// [`PartialEq`] or [`PartialOrd`].
+#[derive(Clone, Copy, Default)]
+#[cfg_attr(test, derive(Debug))]
+pub struct Incomparable(pub Option<Span>);
+
+impl Incomparable {
+	/// Token used for the `incomparable` option.
+	pub const INCOMPARABLE: &'static str = "incomparable";
+
+	/// Adds a [`Meta`] to this [`Incomparable`].
+	pub fn add_attribute(&mut self, meta: &Meta, derive_wheres: &[DeriveWhere]) -> Result<()> {
+		debug_assert!(meta.path().is_ident(Self::INCOMPARABLE));
+
+		if let Meta::Path(path) = meta {
+			if self.0.is_some() {
+				Err(Error::option_duplicate(path.span(), Self::INCOMPARABLE))
+			} else {
+				let mut impl_cmp = false;
+
+				for trait_ in derive_wheres
+					.iter()
+					.flat_map(|derive_where| derive_where.traits.iter())
+				{
+					match trait_ {
+						DeriveTrait::Eq | DeriveTrait::Ord => {
+							return Err(Error::non_partial_incomparable(path.span()));
+						}
+						DeriveTrait::PartialEq | DeriveTrait::PartialOrd => impl_cmp = true,
+						_ => {}
+					}
+				}
+
+				if impl_cmp {
+					self.0 = Some(path.span());
+					Ok(())
+				} else {
+					Err(Error::incomparable(path.span()))
+				}
+			}
+		} else {
+			Err(Error::option_syntax(meta.span()))
+		}
+	}
+}

src/attr/item.rs

@@ -11,13 +11,16 @@ use syn::{
 	TraitBoundModifier, Type, TypeParamBound, TypePath, WhereClause, WherePredicate,
 };
 
-use crate::{util, Error, Item, Skip, SkipGroup, Trait, TraitImpl, DERIVE_WHERE};
+use crate::{util, Error, Incomparable, Item, Skip, SkipGroup, Trait, TraitImpl, DERIVE_WHERE};
 
 /// Attributes on item.
 #[derive(Default)]
 pub struct ItemAttr {
 	/// [`Trait`]s to skip all fields for.
 	pub skip_inner: Skip,
+	/// Comparing item will yield `false` for [`PartialEq`] and [`None`] for
+	/// [`PartialOrd`].
+	pub incomparable: Incomparable,
 	/// [`DeriveWhere`]s on this item.
 	pub derive_wheres: Vec<DeriveWhere>,
 }
@@ -27,6 +30,7 @@ impl ItemAttr {
 	pub fn from_attrs(span: Span, data: &Data, attrs: &[Attribute]) -> Result<Self> {
 		let mut self_ = ItemAttr::default();
 		let mut skip_inners = Vec::new();
+		let mut incomparables = Vec::new();
 
 		for attr in attrs {
 			if attr.path.is_ident(DERIVE_WHERE) {
@@ -52,6 +56,9 @@ impl ItemAttr {
 										// Don't parse `Skip` yet, because it needs access to all
 										// `DeriveWhere`s.
 										skip_inners.push(meta);
+									} else if meta.path().is_ident(Incomparable::INCOMPARABLE) {
+										// Needs to be parsed after all traits are known.
+										incomparables.push(meta)
 									} else if meta.path().is_ident("crate") {
 										// Do nothing, we checked this before
 										// already.
@@ -119,14 +126,20 @@ impl ItemAttr {
 			}
 		}
 
-		// Delayed parsing of `skip_inner` to get access to all traits to be
-		// implemented.
+		// Delayed parsing of `skip_inner` and `incomparable` to get access to all
+		// traits to be implemented.
 		for meta in skip_inners {
 			self_
 				.skip_inner
 				.add_attribute(&self_.derive_wheres, None, &meta)?;
 		}
 
+		for meta in incomparables {
+			self_
+				.incomparable
+				.add_attribute(&meta, &self_.derive_wheres)?;
+		}
+
 		Ok(self_)
 	}
 }

src/attr/variant.rs

@@ -2,7 +2,7 @@
 
 use syn::{spanned::Spanned, Attribute, Fields, Meta, NestedMeta, Result, Variant};
 
-use crate::{Default, DeriveWhere, Error, Skip, DERIVE_WHERE};
+use crate::{Default, DeriveWhere, Error, Incomparable, Skip, DERIVE_WHERE};
 
 /// Attributes on variant.
 #[derive(Default)]
@@ -11,6 +11,9 @@ pub struct VariantAttr {
 	pub default: Default,
 	/// [`Trait`](crate::Trait)s to skip all fields for.
 	pub skip_inner: Skip,
+	/// Comparing variant will yield `false` for [`PartialEq`] and [`None`] for
+	/// [`PartialOrd`].
+	pub incomparable: Incomparable,
 }
 
 impl VariantAttr {
@@ -67,6 +70,8 @@ impl VariantAttr {
 							}
 						} else if meta.path().is_ident(Default::DEFAULT) {
 							self.default.add_attribute(meta, derive_wheres)?;
+						} else if meta.path().is_ident(Incomparable::INCOMPARABLE) {
+							self.incomparable.add_attribute(meta, derive_wheres)?;
 						} else {
 							return Err(Error::option(meta.path().span()));
 						}