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,11 @@ 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)
+        // All the `is_*` methods are implemented as comparisons against zero
+        // to follow how clang's libcxx implements their equivalents in
+        // <https://github.com/llvm/llvm-project/blob/60486292b79885b7800b082754153202bef5b1f0/libcxx/include/__compare/is_eq.h#L23-L28>
+
+        self.as_raw() == 0
     }
 
     /// Returns `true` if the ordering is not the `Equal` variant.
@@ -432,7 +442,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 +461,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 +480,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 +499,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 +518,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 +1379,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): weirdly, passing these as `Ordering::is_lt` doesn't
+        // MIR-inline, thus the "unnecessary" closure form here.
+        self.partial_cmp(other).is_some_and(|c| c.is_lt())
     }
 
     /// Tests less than or equal to (for `self` and `other`) and is used by the
@@ -1387,7 +1399,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)
+        self.partial_cmp(other).is_some_and(|c| c.is_le())
     }
 
     /// Tests greater than (for `self` and `other`) and is used by the `>`
@@ -1405,7 +1417,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)
+        self.partial_cmp(other).is_some_and(|c| c.is_gt())
     }
 
     /// Tests greater than or equal to (for `self` and `other`) and is used by
@@ -1423,7 +1435,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)
+        self.partial_cmp(other).is_some_and(|c| c.is_ge())
     }
 }
 

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

@@ -6,23 +6,29 @@ 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 (inlined Option::<std::cmp::Ordering>::is_some_and::<{closure@<MultiField as PartialOrd>::le::{closure#0}}>) {
             let _12: std::cmp::Ordering;
-            let mut _13: (std::cmp::Ordering,);
             scope 3 {
+                scope 4 (inlined <MultiField as PartialOrd>::le::{closure#0}) {
+                    scope 5 (inlined std::cmp::Ordering::is_le) {
+                        let mut _13: i8;
+                        scope 6 (inlined std::cmp::Ordering::as_raw) {
+                        }
+                    }
+                }
             }
         }
-        scope 4 (inlined <MultiField as PartialOrd>::partial_cmp) {
+        scope 7 (inlined <MultiField as PartialOrd>::partial_cmp) {
             let mut _6: std::option::Option<std::cmp::Ordering>;
             let mut _7: i8;
-            scope 5 {
+            scope 8 {
             }
-            scope 6 (inlined std::cmp::impls::<impl PartialOrd for char>::partial_cmp) {
+            scope 9 (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) {
+            scope 10 (inlined std::cmp::impls::<impl PartialOrd for i16>::partial_cmp) {
                 let mut _8: i16;
                 let mut _9: i16;
                 let mut _10: std::cmp::Ordering;
@@ -31,6 +37,7 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool {
     }
 
     bb0: {
+        StorageLive(_12);
         StorageLive(_11);
         StorageLive(_5);
         StorageLive(_7);
@@ -59,29 +66,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);
         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;
     }
 }

tests/mir-opt/pre-codegen/derived_ord.rs

@@ -1,4 +1,3 @@
-// skip-filecheck
 //@ compile-flags: -O -Zmir-opt-level=2 -Cdebuginfo=0
 
 #![crate_type = "lib"]
@@ -9,6 +8,24 @@ pub struct MultiField(char, i16);
 // Because this isn't derived by the impl, it's not on the `{impl#0}-partial_cmp`,
 // and thus we need to call it to see what the inlined generic one produces.
 pub fn demo_le(a: &MultiField, b: &MultiField) -> bool {
+    // CHECK-LABEL: fn demo_le
+    // CHECK: inlined <MultiField as PartialOrd>::le
+    // CHECK: inlined{{.+}}is_some_and
+    // CHECK: inlined <MultiField as PartialOrd>::partial_cmp
+
+    // CHECK: [[A0:_[0-9]+]] = copy ((*_1).0: char);
+    // CHECK: [[B0:_[0-9]+]] = copy ((*_2).0: char);
+    // CHECK: Cmp(move [[A0]], move [[B0]]);
+
+    // CHECK: [[D0:_[0-9]+]] = discriminant({{.+}});
+    // CHECK: switchInt(move [[D0]]) -> [0: bb{{[0-9]+}}, otherwise: bb{{[0-9]+}}];
+
+    // CHECK: [[A1:_[0-9]+]] = copy ((*_1).1: i16);
+    // CHECK: [[B1:_[0-9]+]] = copy ((*_2).1: i16);
+    // CHECK: Cmp(move [[A1]], move [[B1]]);
+
+    // CHECK: [[D1:_[0-9]+]] = discriminant({{.+}});
+    // CHECK: _0 = Le(move [[D1]], const 0_i8);
     *a <= *b
 }
 

tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir

@@ -1,6 +1,6 @@
-// MIR for `<impl at $DIR/derived_ord.rs:6:10: 6:20>::partial_cmp` after PreCodegen
+// MIR for `<impl at $DIR/derived_ord.rs:5:10: 5:20>::partial_cmp` after PreCodegen
 
-fn <impl at $DIR/derived_ord.rs:6:10: 6:20>::partial_cmp(_1: &MultiField, _2: &MultiField) -> Option<std::cmp::Ordering> {
+fn <impl at $DIR/derived_ord.rs:5:10: 5:20>::partial_cmp(_1: &MultiField, _2: &MultiField) -> Option<std::cmp::Ordering> {
     debug self => _1;
     debug other => _2;
     let mut _0: std::option::Option<std::cmp::Ordering>;