Fix 07c42af to work on stable

Author: Mark-Simulacrum

src/librustc_const_math/float.rs

@@ -38,19 +38,18 @@ impl ConstFloat {
     }
 
     /// Compares the values if they are of the same type
-    pub fn try_cmp(self, rhs: Self) -> Result<Ordering, ConstMathErr> {
+    pub fn try_cmp(self, rhs: Self) -> Result<Option<Ordering>, ConstMathErr> {
         match (self.ty, rhs.ty) {
             (ast::FloatTy::F64, ast::FloatTy::F64)  => {
                 let a = Double::from_bits(self.bits);
                 let b = Double::from_bits(rhs.bits);
-                // This is pretty bad but it is the existing behavior.
-                Ok(a.partial_cmp(&b).unwrap_or(Ordering::Greater))
+                Ok(a.partial_cmp(&b))
             }
 
             (ast::FloatTy::F32, ast::FloatTy::F32) => {
                 let a = Single::from_bits(self.bits);
                 let b = Single::from_bits(rhs.bits);
-                Ok(a.partial_cmp(&b).unwrap_or(Ordering::Greater))
+                Ok(a.partial_cmp(&b))
             }
 
             _ => Err(CmpBetweenUnequalTypes),

src/librustc_mir/hair/pattern/mod.rs

@@ -1115,7 +1115,12 @@ pub fn compare_const_vals<'a, 'tcx>(
                         ty,
                     };
                     // FIXME(oli-obk): report cmp errors?
-                    l.try_cmp(r).ok()
+                    // FIXME: Just returning Ordering::Greater here is the previous behavior but may
+                    // not be what we want. It means that NaN > NaN is true, which if false.
+                    match l.try_cmp(r) {
+                        Ok(opt) => Some(opt.unwrap_or(Ordering::Greater)),
+                        _ => None,
+                    }
                 },
                 ty::TyInt(_) => {
                     let a = interpret::sign_extend(tcx, a, ty).expect("layout error for TyInt");

src/librustc_mir/interpret/operator.rs

@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use rustc::mir;
 use rustc::ty::{self, Ty};
 use rustc_const_math::ConstFloat;
@@ -133,13 +135,24 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                 bits: r,
                 ty,
             };
+            let cmp = |l: ConstFloat, r: ConstFloat| -> Option<Ordering> {
+                l.try_cmp(r).unwrap_or(None)
+            };
             match op {
-                Eq => PrimVal::from_bool(l == r),
-                Ne => PrimVal::from_bool(l != r),
-                Lt => PrimVal::from_bool(l < r),
-                Le => PrimVal::from_bool(l <= r),
-                Gt => PrimVal::from_bool(l > r),
-                Ge => PrimVal::from_bool(l >= r),
+                Eq => PrimVal::from_bool(cmp(l, r) == Some(Ordering::Equal)),
+                Ne => PrimVal::from_bool(cmp(l, r) != Some(Ordering::Equal)),
+                Lt => PrimVal::from_bool(cmp(l, r) == Some(Ordering::Less)),
+                Gt => PrimVal::from_bool(cmp(l, r) == Some(Ordering::Greater)),
+                Le => PrimVal::from_bool(match cmp(l, r) {
+                    Some(Ordering::Less) => true,
+                    Some(Ordering::Equal) => true,
+                    _ => false,
+                }),
+                Ge => PrimVal::from_bool(match cmp(l, r) {
+                    Some(Ordering::Greater) => true,
+                    Some(Ordering::Equal) => true,
+                    _ => false,
+                }),
                 Add => PrimVal::Bytes((l + r).unwrap().bits),
                 Sub => PrimVal::Bytes((l - r).unwrap().bits),
                 Mul => PrimVal::Bytes((l * r).unwrap().bits),