Account for as conversion requiring Copy/Clone

Author: daxpedda

README.md

@@ -285,10 +285,9 @@ Unions only support [`Clone`] and [`Copy`].
   default too. Without this feature [`transmute`] is
   used to convert [`Discriminant`] to a [`i32`],
   which is the underlying type.
-- `safe`: Implements [`Ord`] and [`PartialOrd`] on enums with a non-default
-  representation and at least one non-empty variant without unsafely
-  accessing the discriminant. This is much slower, but might be preferred if
-  you don't trust derive-where. It also replaces all cases of
+- `safe`: `safe`: Uses only safe ways to access the discriminant of the enum
+  for [`Ord`] and [`PartialOrd`]. This is much slower, but might be
+  preferred if you don't trust derive-where. It also replaces all cases of
   [`core::hint::unreachable_unchecked`] in [`Ord`], [`PartialEq`] and
   [`PartialOrd`], which is what std uses, with [`unreachable`].
 - `zeroize`: Allows deriving [`Zeroize`] and [`zeroize`][method@zeroize] on

src/item.rs

@@ -98,11 +98,11 @@ impl Item<'_> {
 /// Type of discriminant used.
 #[cfg_attr(test, derive(Debug))]
 pub enum Discriminant {
+	/// The enum has only a single variant.
+	Single,
 	/// The enum uses the default representation but has a non-unit variant or
 	/// an enum with a C representation without an integer representation.
 	Unknown,
-	/// The enum has only a single variant.
-	Single,
 	/// The enum uses the default representation and has only unit variants.
 	UnitDefault,
 	/// The enum uses a non-default representation and has only unit variants.

src/lib.rs

@@ -324,10 +324,9 @@
 //!   default too. Without this feature [`transmute`](core::mem::transmute) is
 //!   used to convert [`Discriminant`](core::mem::Discriminant) to a [`i32`],
 //!   which is the underlying type.
-//! - `safe`: Implements [`Ord`] and [`PartialOrd`] on enums with a non-default
-//!   representation and at least one non-empty variant without unsafely
-//!   accessing the discriminant. This is much slower, but might be preferred if
-//!   you don't trust derive-where. It also replaces all cases of
+//! - `safe`: `safe`: Uses only safe ways to access the discriminant of the enum
+//!   for [`Ord`] and [`PartialOrd`]. This is much slower, but might be
+//!   preferred if you don't trust derive-where. It also replaces all cases of
 //!   [`core::hint::unreachable_unchecked`] in [`Ord`], [`PartialEq`] and
 //!   [`PartialOrd`], which is what std uses, with [`unreachable`].
 //! - `zeroize`: Allows deriving [`Zeroize`] and [`zeroize`][method@zeroize] on

src/trait_/common_ord.rs

@@ -7,10 +7,15 @@ use syn::PatOr;
 
 #[cfg(not(feature = "nightly"))]
 use crate::Discriminant;
-use crate::{data::SimpleType, Data, DeriveTrait, Item};
+use crate::{Data, DeriveTrait, Item, SimpleType, Trait};
 
 /// Build signature for [`PartialOrd`] and [`Ord`].
-pub fn build_ord_signature(item: &Item, trait_: &DeriveTrait, body: &TokenStream) -> TokenStream {
+pub fn build_ord_signature(
+	item: &Item,
+	traits: &[DeriveTrait],
+	trait_: &DeriveTrait,
+	body: &TokenStream,
+) -> TokenStream {
 	let mut equal = quote! { ::core::cmp::Ordering::Equal };
 
 	// Add `Option` to `Ordering` if we are implementing `PartialOrd`.
@@ -122,23 +127,50 @@ pub fn build_ord_signature(item: &Item, trait_: &DeriveTrait, body: &TokenStream
 						Discriminant::Single => {
 							unreachable!("we should only generate this code with multiple variants")
 						}
-						Discriminant::UnitDefault => quote! {
-							#path::#method(
-								self as isize,
-								__other as isize,
-							)
-						},
+						Discriminant::UnitDefault => {
+							if traits.iter().any(|trait_| trait_ == Trait::Copy) {
+								quote! {
+									#path::#method(
+										*self as isize,
+										*__other as isize,
+									)
+								}
+							} else if traits.iter().any(|trait_| trait_ == Trait::Clone) {
+								quote! {
+									#path::#method(
+										self.clone() as isize,
+										__other.clone() as isize,
+									)
+								}
+							} else {
+								build_recursive_order(trait_, variants, &incomparable)
+							}
+						}
 						Discriminant::Unknown => {
 							build_recursive_order(trait_, variants, &incomparable)
 						}
-						Discriminant::UnitRepr(repr) => quote! {
-							#path::#method(
-								self as #repr,
-								__other as #repr,
-							)
-						},
+						#[cfg(feature = "safe")]
+						Discriminant::UnitRepr(repr) => {
+							if traits.iter().any(|trait_| trait_ == Trait::Copy) {
+								quote! {
+									#path::#method(
+										*self as #repr,
+										*__other as #repr,
+									)
+								}
+							} else if traits.iter().any(|trait_| trait_ == Trait::Clone) {
+								quote! {
+									#path::#method(
+										self.clone() as #repr,
+										__other.clone() as #repr,
+									)
+								}
+							} else {
+								build_recursive_order(trait_, variants, &incomparable)
+							}
+						}
 						#[cfg(not(feature = "safe"))]
-						Discriminant::Repr(repr) => {
+						Discriminant::UnitRepr(repr) | Discriminant::Repr(repr) => {
 							quote! {
 								#path::#method(
 									unsafe { *<*const _>::from(self).cast::<#repr>() },

src/trait_/ord.rs

@@ -23,11 +23,11 @@ impl TraitImpl for Ord {
 		&self,
 		_any_bound: bool,
 		item: &Item,
-		_traits: &[DeriveTrait],
+		traits: &[DeriveTrait],
 		trait_: &DeriveTrait,
 		body: &TokenStream,
 	) -> TokenStream {
-		let body = common_ord::build_ord_signature(item, trait_, body);
+		let body = common_ord::build_ord_signature(item, traits, trait_, body);
 
 		quote! {
 			#[inline]

src/trait_/partial_ord.rs

@@ -32,7 +32,7 @@ impl TraitImpl for PartialOrd {
 				::core::option::Option::Some(::core::cmp::Ord::cmp(self, __other))
 			}
 		} else {
-			common_ord::build_ord_signature(item, trait_, body)
+			common_ord::build_ord_signature(item, traits, trait_, body)
 		};
 
 		quote! {