Remove FRepr

Author: mattico

src/float/mod.rs

@@ -135,30 +135,3 @@ impl Float for f64 {
         (1i32.wrapping_sub(shift as i32), significand << shift as Self::Int)
     }
 }
-
-// TODO: Move this to F32/F64 in qc.rs
-#[cfg(test)]
-#[derive(Copy, Clone)]
-pub struct FRepr<F>(F);
-
-#[cfg(test)]
-impl<F: Float> PartialEq for FRepr<F> {
-    fn eq(&self, other: &FRepr<F>) -> bool {
-        // NOTE(cfg) for some reason, on hard float targets, our implementation doesn't
-        // match the output of its gcc_s counterpart. Until we investigate further, we'll
-        // just avoid testing against gcc_s on those targets. Do note that our
-        // implementation matches the output of the FPU instruction on *hard* float targets
-        // and matches its gcc_s counterpart on *soft* float targets.
-        if cfg!(gnueabihf) {
-            return true
-        }
-        self.0.eq_repr(other.0)
-    }
-}
-
-#[cfg(test)]
-impl<F: fmt::Debug> fmt::Debug for FRepr<F> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}

src/float/pow.rs

@@ -31,22 +31,22 @@ pow!(__powidf2: f64, i32);
 
 #[cfg(test)]
 mod tests {
-    use float::{Float, FRepr};
+    use float::{Float};
     use qc::{I32, U32, U64};
 
     check! {
         fn __powisf2(f: extern fn(f32, i32) -> f32, 
                      a: U32, 
-                     b: I32) -> Option<FRepr<f32> > {
+                     b: I32) -> Option<F32> {
             let (a, b) = (f32::from_repr(a.0), b.0);
-            Some(FRepr(f(a, b)))
+            Some(F32(f(a, b)))
         }
 
         fn __powidf2(f: extern fn(f64, i32) -> f64, 
                      a: U64, 
-                     b: I32) -> Option<FRepr<f64> > {
+                     b: I32) -> Option<F64> {
             let (a, b) = (f64::from_repr(a.0), b.0);
-            Some(FRepr(f(a, b)))
+            Some(F64(f(a, b)))
         }
     }
 }