Avoid is_some_and so the generic MIR is simpler

Author: scottmcm

library/core/src/cmp.rs

@@ -397,6 +397,12 @@ pub enum Ordering {
 }
 
 impl Ordering {
+    #[inline]
+    const fn as_raw(self) -> i8 {
+        // FIXME(const-hack): just use `PartialOrd` against `Equal` once that's const
+        crate::intrinsics::discriminant_value(&self)
+    }
+
     /// Returns `true` if the ordering is the `Equal` variant.
     ///
     /// # Examples
@@ -413,7 +419,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_eq(self) -> bool {
-        matches!(self, Equal)
+        self.as_raw() == 0
     }
 
     /// Returns `true` if the ordering is not the `Equal` variant.
@@ -432,7 +438,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_ne(self) -> bool {
-        !matches!(self, Equal)
+        self.as_raw() != 0
     }
 
     /// Returns `true` if the ordering is the `Less` variant.
@@ -451,7 +457,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_lt(self) -> bool {
-        matches!(self, Less)
+        self.as_raw() < 0
     }
 
     /// Returns `true` if the ordering is the `Greater` variant.
@@ -470,7 +476,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_gt(self) -> bool {
-        matches!(self, Greater)
+        self.as_raw() > 0
     }
 
     /// Returns `true` if the ordering is either the `Less` or `Equal` variant.
@@ -489,7 +495,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_le(self) -> bool {
-        !matches!(self, Greater)
+        self.as_raw() <= 0
     }
 
     /// Returns `true` if the ordering is either the `Greater` or `Equal` variant.
@@ -508,7 +514,7 @@ impl Ordering {
     #[rustc_const_stable(feature = "ordering_helpers", since = "1.53.0")]
     #[stable(feature = "ordering_helpers", since = "1.53.0")]
     pub const fn is_ge(self) -> bool {
-        !matches!(self, Less)
+        self.as_raw() >= 0
     }
 
     /// Reverses the `Ordering`.
@@ -1369,7 +1375,9 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_lt"]
     fn lt(&self, other: &Rhs) -> bool {
-        self.partial_cmp(other).is_some_and(Ordering::is_lt)
+        // FIXME(#137901): ideally these would just use `is_some_and`,
+        // but at the time of writing that doesn't inline in the generic MIR.
+        if let Some(c) = self.partial_cmp(other) { c.is_lt() } else { false }
     }
 
     /// Tests less than or equal to (for `self` and `other`) and is used by the
@@ -1387,7 +1395,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_le"]
     fn le(&self, other: &Rhs) -> bool {
-        self.partial_cmp(other).is_some_and(Ordering::is_le)
+        if let Some(c) = self.partial_cmp(other) { c.is_le() } else { false }
     }
 
     /// Tests greater than (for `self` and `other`) and is used by the `>`
@@ -1405,7 +1413,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_gt"]
     fn gt(&self, other: &Rhs) -> bool {
-        self.partial_cmp(other).is_some_and(Ordering::is_gt)
+        if let Some(c) = self.partial_cmp(other) { c.is_gt() } else { false }
     }
 
     /// Tests greater than or equal to (for `self` and `other`) and is used by
@@ -1423,7 +1431,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_ge"]
     fn ge(&self, other: &Rhs) -> bool {
-        self.partial_cmp(other).is_some_and(Ordering::is_ge)
+        if let Some(c) = self.partial_cmp(other) { c.is_ge() } else { false }
     }
 }
 

tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir

@@ -6,31 +6,34 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
     let mut _0: bool;
     scope 1 (inlined <MultiField as PartialOrd>::le) {
         let mut _11: std::option::Option<std::cmp::Ordering>;
-        scope 2 (inlined Option::<std::cmp::Ordering>::is_some_and::<fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le}>) {
+        scope 2 {
             let _12: std::cmp::Ordering;
-            let mut _13: (std::cmp::Ordering,);
-            scope 3 {
+            scope 3 (inlined std::cmp::Ordering::is_le) {
+                let mut _13: i8;
+                scope 4 (inlined std::cmp::Ordering::as_raw) {
+                }
             }
-        }
-        scope 4 (inlined <MultiField as PartialOrd>::partial_cmp) {
-            let mut _6: std::option::Option<std::cmp::Ordering>;
-            let mut _7: i8;
-            scope 5 {
-            }
-            scope 6 (inlined std::cmp::impls::<impl PartialOrd for char>::partial_cmp) {
-                let mut _3: char;
-                let mut _4: char;
-                let mut _5: std::cmp::Ordering;
-            }
-            scope 7 (inlined std::cmp::impls::<impl PartialOrd for i16>::partial_cmp) {
-                let mut _8: i16;
-                let mut _9: i16;
-                let mut _10: std::cmp::Ordering;
+            scope 5 (inlined <MultiField as PartialOrd>::partial_cmp) {
+                let mut _6: std::option::Option<std::cmp::Ordering>;
+                let mut _7: i8;
+                scope 6 {
+                }
+                scope 7 (inlined std::cmp::impls::<impl PartialOrd for char>::partial_cmp) {
+                    let mut _3: char;
+                    let mut _4: char;
+                    let mut _5: std::cmp::Ordering;
+                }
+                scope 8 (inlined std::cmp::impls::<impl PartialOrd for i16>::partial_cmp) {
+                    let mut _8: i16;
+                    let mut _9: i16;
+                    let mut _10: std::cmp::Ordering;
+                }
             }
         }
     }
 
     bb0: {
+        StorageLive(_12);
         StorageLive(_11);
         StorageLive(_5);
         StorageLive(_7);
@@ -59,29 +62,24 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
         StorageDead(_10);
         StorageDead(_7);
         StorageDead(_5);
-        StorageLive(_12);
         goto -> bb3;
     }
 
     bb2: {
         _11 = copy _6;
         StorageDead(_7);
         StorageDead(_5);
-        StorageLive(_12);
         goto -> bb3;
     }
 
     bb3: {
-        _12 = move ((_11 as Some).0: std::cmp::Ordering);
+        _12 = copy ((_11 as Some).0: std::cmp::Ordering);
         StorageLive(_13);
-        _13 = (copy _12,);
-        _0 = <fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le} as FnOnce<(std::cmp::Ordering,)>>::call_once(std::cmp::Ordering::is_le, move _13) -> [return: bb4, unwind unreachable];
-    }
-
-    bb4: {
+        _13 = discriminant(_12);
+        _0 = Le(move _13, const 0_i8);
         StorageDead(_13);
-        StorageDead(_12);
         StorageDead(_11);
+        StorageDead(_12);
         return;
     }
 }