Add Discriminant::unstable_cmp

Provides an unstable ordering between `Discriminant<T>` values.

Author: bushrat011899

library/core/src/marker.rs

@@ -884,7 +884,17 @@ pub trait DiscriminantKind {
     /// The type of the discriminant, which must satisfy the trait
     /// bounds required by `mem::Discriminant`.
     #[lang = "discriminant_type"]
-    type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Send + Sync + Unpin;
+    type Discriminant: Clone
+        + Copy
+        + Debug
+        + Eq
+        + Hash
+        + Ord
+        + PartialEq
+        + PartialOrd
+        + Send
+        + Sync
+        + Unpin;
 }
 
 /// Used to determine whether a type contains

library/core/src/mem/mod.rs

@@ -1325,6 +1325,41 @@ impl<T> fmt::Debug for Discriminant<T> {
     }
 }
 
+impl<T> Discriminant<T> {
+    /// Returns the *unstable* ordering between `self` and `other`.
+    ///
+    /// [`Discriminant`] does not implement [`Ord`] as we do not guarantee a stable
+    /// ordering of discriminant values.
+    /// This will _typically_ sort enum variants by their declaration order, but
+    /// this is *not* guaranteed.
+    /// Likewise, non-enum values (e.g., `struct`s) will _typically_ be trivially
+    /// ordered as equivalent.
+    ///
+    /// Users of this function should instead rely on the [`Ord`] implementation
+    /// of `T` wherever possible.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cmp::Ordering;
+    /// use std::mem::discriminant;
+    ///
+    /// enum Foo { A(i32), B(i32) }
+    ///
+    /// // Equivalent arms will compare equal regardless of contained data
+    /// assert_eq!(discriminant(&Foo::A(1)).unstable_cmp(discriminant(&Foo::A(2))), Ordering::Equal);
+    ///
+    /// // Inequivalent arms will compare not-equal
+    /// assert_ne!(discriminant(&Foo::A(1)).unstable_cmp(discriminant(&Foo::B(1))), Ordering::Equal);
+    /// ```
+    #[unstable(feature = "discriminant_cmp", issue = "none", reason = "not yet created")]
+    #[must_use]
+    #[inline]
+    pub fn unstable_cmp(&self, other: &Self) -> Ordering {
+        <<T as DiscriminantKind>::Discriminant as Ord>::cmp(&self.0, &other.0)
+    }
+}
+
 /// Returns a value uniquely identifying the enum variant in `v`.
 ///
 /// If `T` is not an enum, calling this function will not result in undefined behavior, but the