Manually implement derived NonZero traits.

library/core/src/num/nonzero.rs

@@ -1,6 +1,9 @@
 //! Definitions of integer that is known not to equal zero.
 
+use crate::cmp::Ordering;
 use crate::fmt;
+use crate::hash::{Hash, Hasher};
+use crate::marker::StructuralPartialEq;
 use crate::ops::{BitOr, BitOrAssign, Div, Neg, Rem};
 use crate::str::FromStr;
 
@@ -31,13 +34,6 @@ pub trait ZeroablePrimitive: Sized + Copy + private::Sealed {
     type NonZero;
 }
 
-#[unstable(
-    feature = "nonzero_internals",
-    reason = "implementation detail which may disappear or be replaced at any time",
-    issue = "none"
-)]
-pub(crate) type NonZero<T> = <T as ZeroablePrimitive>::NonZero;
-
 macro_rules! impl_zeroable_primitive {
     ($NonZero:ident ( $primitive:ty )) => {
         #[unstable(
@@ -71,6 +67,107 @@ impl_zeroable_primitive!(NonZeroI64(i64));
 impl_zeroable_primitive!(NonZeroI128(i128));
 impl_zeroable_primitive!(NonZeroIsize(isize));
 
+#[unstable(
+    feature = "nonzero_internals",
+    reason = "implementation detail which may disappear or be replaced at any time",
+    issue = "none"
+)]
+pub(crate) type NonZero<T> = <T as ZeroablePrimitive>::NonZero;
+
+macro_rules! impl_nonzero_traits {
+    (#[$stability:meta] $Ty:ty) => {
+        #[$stability]
+        impl Clone for $Ty {
+            #[inline]
+            fn clone(&self) -> Self {
+                // SAFETY: The contained value is non-zero.
+                unsafe { Self(self.get()) }
+            }
+        }
+
+        #[$stability]
+        impl PartialEq for $Ty {
+            #[inline]
+            fn eq(&self, other: &Self) -> bool {
+                self.get() == other.get()
+            }
+
+            #[inline]
+            fn ne(&self, other: &Self) -> bool {
+                self.get() != other.get()
+            }
+        }
+
+        #[unstable(feature = "structural_match", issue = "31434")]
+        impl StructuralPartialEq for $Ty {}
+
+        #[$stability]
+        impl PartialOrd for $Ty {
+            #[inline]
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                self.get().partial_cmp(&other.get())
+            }
+
+            #[inline]
+            fn lt(&self, other: &Self) -> bool {
+                self.get() < other.get()
+            }
+
+            #[inline]
+            fn le(&self, other: &Self) -> bool {
+                self.get() <= other.get()
+            }
+
+            #[inline]
+            fn gt(&self, other: &Self) -> bool {
+                self.get() > other.get()
+            }
+
+            #[inline]
+            fn ge(&self, other: &Self) -> bool {
+                self.get() >= other.get()
+            }
+        }
+
+        #[$stability]
+        impl Ord for $Ty {
+            #[inline]
+            fn cmp(&self, other: &Self) -> Ordering {
+                self.get().cmp(&other.get())
+            }
+
+            #[inline]
+            fn max(self, other: Self) -> Self {
+                // SAFETY: The maximum of two non-zero values is still non-zero.
+                unsafe { Self(self.get().max(other.get())) }
+            }
+
+            #[inline]
+            fn min(self, other: Self) -> Self {
+                // SAFETY: The minimum of two non-zero values is still non-zero.
+                unsafe { Self(self.get().min(other.get())) }
+            }
+
+            #[inline]
+            fn clamp(self, min: Self, max: Self) -> Self {
+                // SAFETY: A non-zero value clamped between two non-zero values is still non-zero.
+                unsafe { Self(self.get().clamp(min.get(), max.get())) }
+            }
+        }
+
+        #[$stability]
+        impl Hash for $Ty {
+            #[inline]
+            fn hash<H>(&self, state: &mut H)
+            where
+                H: Hasher,
+            {
+                self.get().hash(state)
+            }
+        }
+    };
+}
+
 macro_rules! impl_nonzero_fmt {
     ( #[$stability: meta] ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
         $(
@@ -128,13 +225,15 @@ macro_rules! nonzero_integer {
         ///
         /// [null pointer optimization]: crate::option#representation
         #[$stability]
-        #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+        #[derive(Copy, Eq)]
         #[repr(transparent)]
         #[rustc_layout_scalar_valid_range_start(1)]
         #[rustc_nonnull_optimization_guaranteed]
         #[rustc_diagnostic_item = stringify!($Ty)]
         pub struct $Ty($Int);
 
+        impl_nonzero_traits!(#[$stability] $Ty);
+
         impl $Ty {
             /// Creates a non-zero without checking whether the value is non-zero.
             /// This results in undefined behaviour if the value is zero.

tests/ui/unsafe/ranged_ints3.rs

@@ -5,6 +5,7 @@ use std::cell::Cell;
 #[rustc_layout_scalar_valid_range_start(1)]
 #[repr(transparent)]
 pub(crate) struct NonZero<T>(pub(crate) T);
+
 fn main() {
     let mut x = unsafe { NonZero(Cell::new(1)) };
     let y = &x.0; //~ ERROR borrow of layout constrained field with interior mutability

tests/ui/unsafe/ranged_ints3_match.rs

@@ -5,6 +5,7 @@ use std::cell::Cell;
 #[rustc_layout_scalar_valid_range_start(1)]
 #[repr(transparent)]
 pub(crate) struct NonZero<T>(pub(crate) T);
+
 fn main() {
     let mut x = unsafe { NonZero(Cell::new(1)) };
     match x {