constify {float}::total_cmp()

Author: npmccallum

library/core/src/num/f128.rs

@@ -1196,7 +1196,8 @@ impl f128 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f128", issue = "116909")]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i128;
         let mut right = other.to_bits() as i128;
 

library/core/src/num/f16.rs

@@ -1175,7 +1175,8 @@ impl f16 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f16", issue = "116909")]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i16;
         let mut right = other.to_bits() as i16;
 

library/core/src/num/f32.rs

@@ -1353,9 +1353,10 @@ impl f32 {
     /// }
     /// ```
     #[stable(feature = "total_cmp", since = "1.62.0")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     #[must_use]
     #[inline]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i32;
         let mut right = other.to_bits() as i32;
 

library/core/src/num/f64.rs

@@ -1351,9 +1351,10 @@ impl f64 {
     /// }
     /// ```
     #[stable(feature = "total_cmp", since = "1.62.0")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     #[must_use]
     #[inline]
-    pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
+    pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
         let mut left = self.to_bits() as i64;
         let mut right = other.to_bits() as i64;
 

tests/ui/consts/const-total-cmp.rs

@@ -0,0 +1,113 @@
+//@ run-pass
+
+#![feature(const_cmp, f16, f128)]
+
+use std::cmp::Ordering;
+
+fn main() {
+    // Test f32::total_cmp in const context
+    const F32_EQUAL: Ordering = (1.0_f32).total_cmp(&1.0_f32);
+    assert_eq!(F32_EQUAL, Ordering::Equal);
+
+    const F32_LESS: Ordering = (1.0_f32).total_cmp(&2.0_f32);
+    assert_eq!(F32_LESS, Ordering::Less);
+
+    const F32_GREATER: Ordering = (2.0_f32).total_cmp(&1.0_f32);
+    assert_eq!(F32_GREATER, Ordering::Greater);
+
+    // Test special values for f32
+    const F32_NEG_ZERO_VS_POS_ZERO: Ordering = (-0.0_f32).total_cmp(&0.0_f32);
+    assert_eq!(F32_NEG_ZERO_VS_POS_ZERO, Ordering::Less);
+
+    const F32_NAN_VS_FINITE: Ordering = f32::NAN.total_cmp(&1.0_f32);
+    assert_eq!(F32_NAN_VS_FINITE, Ordering::Greater);
+
+    const F32_INFINITY_VS_FINITE: Ordering = f32::INFINITY.total_cmp(&1.0_f32);
+    assert_eq!(F32_INFINITY_VS_FINITE, Ordering::Greater);
+
+    const F32_NEG_INFINITY_VS_FINITE: Ordering = f32::NEG_INFINITY.total_cmp(&1.0_f32);
+    assert_eq!(F32_NEG_INFINITY_VS_FINITE, Ordering::Less);
+
+    // Test f64::total_cmp in const context
+    const F64_EQUAL: Ordering = (1.0_f64).total_cmp(&1.0_f64);
+    assert_eq!(F64_EQUAL, Ordering::Equal);
+
+    const F64_LESS: Ordering = (1.0_f64).total_cmp(&2.0_f64);
+    assert_eq!(F64_LESS, Ordering::Less);
+
+    const F64_GREATER: Ordering = (2.0_f64).total_cmp(&1.0_f64);
+    assert_eq!(F64_GREATER, Ordering::Greater);
+
+    // Test special values for f64
+    const F64_NEG_ZERO_VS_POS_ZERO: Ordering = (-0.0_f64).total_cmp(&0.0_f64);
+    assert_eq!(F64_NEG_ZERO_VS_POS_ZERO, Ordering::Less);
+
+    const F64_NAN_VS_FINITE: Ordering = f64::NAN.total_cmp(&1.0_f64);
+    assert_eq!(F64_NAN_VS_FINITE, Ordering::Greater);
+
+    const F64_INFINITY_VS_FINITE: Ordering = f64::INFINITY.total_cmp(&1.0_f64);
+    assert_eq!(F64_INFINITY_VS_FINITE, Ordering::Greater);
+
+    const F64_NEG_INFINITY_VS_FINITE: Ordering = f64::NEG_INFINITY.total_cmp(&1.0_f64);
+    assert_eq!(F64_NEG_INFINITY_VS_FINITE, Ordering::Less);
+
+    // Test edge cases: comparing NaNs with each other
+    const F32_NAN_VS_NAN: Ordering = f32::NAN.total_cmp(&f32::NAN);
+    assert_eq!(F32_NAN_VS_NAN, Ordering::Equal);
+
+    const F64_NAN_VS_NAN: Ordering = f64::NAN.total_cmp(&f64::NAN);
+    assert_eq!(F64_NAN_VS_NAN, Ordering::Equal);
+
+    // Test subnormal numbers
+    const F32_SUBNORMAL_CMP: Ordering = f32::MIN_POSITIVE.total_cmp(&(f32::MIN_POSITIVE / 2.0));
+    assert_eq!(F32_SUBNORMAL_CMP, Ordering::Greater);
+
+    const F64_SUBNORMAL_CMP: Ordering = f64::MIN_POSITIVE.total_cmp(&(f64::MIN_POSITIVE / 2.0));
+    assert_eq!(F64_SUBNORMAL_CMP, Ordering::Greater);
+
+    // Test f16::total_cmp in const context
+    const F16_EQUAL: Ordering = (1.0_f16).total_cmp(&1.0_f16);
+    assert_eq!(F16_EQUAL, Ordering::Equal);
+
+    const F16_LESS: Ordering = (1.0_f16).total_cmp(&2.0_f16);
+    assert_eq!(F16_LESS, Ordering::Less);
+
+    const F16_GREATER: Ordering = (2.0_f16).total_cmp(&1.0_f16);
+    assert_eq!(F16_GREATER, Ordering::Greater);
+
+    // Test special values for f16
+    const F16_NEG_ZERO_VS_POS_ZERO: Ordering = (-0.0_f16).total_cmp(&0.0_f16);
+    assert_eq!(F16_NEG_ZERO_VS_POS_ZERO, Ordering::Less);
+
+    const F16_NAN_VS_FINITE: Ordering = f16::NAN.total_cmp(&1.0_f16);
+    assert_eq!(F16_NAN_VS_FINITE, Ordering::Greater);
+
+    const F16_INFINITY_VS_FINITE: Ordering = f16::INFINITY.total_cmp(&1.0_f16);
+    assert_eq!(F16_INFINITY_VS_FINITE, Ordering::Greater);
+
+    const F16_NAN_VS_NAN: Ordering = f16::NAN.total_cmp(&f16::NAN);
+    assert_eq!(F16_NAN_VS_NAN, Ordering::Equal);
+
+    // Test f128::total_cmp in const context
+    const F128_EQUAL: Ordering = (1.0_f128).total_cmp(&1.0_f128);
+    assert_eq!(F128_EQUAL, Ordering::Equal);
+
+    const F128_LESS: Ordering = (1.0_f128).total_cmp(&2.0_f128);
+    assert_eq!(F128_LESS, Ordering::Less);
+
+    const F128_GREATER: Ordering = (2.0_f128).total_cmp(&1.0_f128);
+    assert_eq!(F128_GREATER, Ordering::Greater);
+
+    // Test special values for f128
+    const F128_NEG_ZERO_VS_POS_ZERO: Ordering = (-0.0_f128).total_cmp(&0.0_f128);
+    assert_eq!(F128_NEG_ZERO_VS_POS_ZERO, Ordering::Less);
+
+    const F128_NAN_VS_FINITE: Ordering = f128::NAN.total_cmp(&1.0_f128);
+    assert_eq!(F128_NAN_VS_FINITE, Ordering::Greater);
+
+    const F128_INFINITY_VS_FINITE: Ordering = f128::INFINITY.total_cmp(&1.0_f128);
+    assert_eq!(F128_INFINITY_VS_FINITE, Ordering::Greater);
+
+    const F128_NAN_VS_NAN: Ordering = f128::NAN.total_cmp(&f128::NAN);
+    assert_eq!(F128_NAN_VS_NAN, Ordering::Equal);
+}