Remove FIXME due to a LLVM bug

This bug has been resolved: bugs.llvm.org/show_bug.cgi?id=36982

Author: JohnTitor

src/api/reductions/min_max.rs

@@ -160,35 +160,25 @@ macro_rules! test_reduction_float_min_max {
                             // targets:
                             if i == $id::lanes() - 1 &&
                                 target_with_broken_last_lane_nan {
-                                // FIXME:
-                                // https://github.com/rust-lang-nursery/packed_simd/issues/5
-                                //
-                                // If there is a NaN, the result should always
-                                // the smallest element, but currently when the
-                                // last element is NaN the current
-                                // implementation incorrectly returns NaN.
-                                //
-                                // The targets mentioned above use different
-                                // codegen that produces the correct result.
-                                //
-                                // These asserts detect if this behavior changes
-                                    assert!(v.min_element().is_nan(),
-                                            // FIXME: ^^^ should be -3.
+                                    assert_eq!(v.min_element(), -3.,
                                             "[A]: nan at {} => {} | {:?}",
                                             i, v.min_element(), v);
 
                                 // If we replace all the elements in the vector
                                 // up-to the `i-th` lane with `NaN`s, the result
                                 // is still always `-3.` unless all elements of
                                 // the vector are `NaN`s:
-                                //
-                                // This is also broken:
                                 for j in 0..i {
                                     v = v.replace(j, n);
-                                    assert!(v.min_element().is_nan(),
-                                            // FIXME: ^^^ should be -3.
+                                    if j == i-1 {
+                                        assert!(v.min_element().is_nan(),
                                             "[B]: nan at {} => {} | {:?}",
                                             i, v.min_element(), v);
+                                    } else {
+                                        assert_eq!(v.min_element(), -3.,
+                                            "[B]: nan at {} => {} | {:?}",
+                                            i, v.min_element(), v);
+                                    }
                                 }
 
                                 // We are done here, since we were in the last
@@ -280,36 +270,25 @@ macro_rules! test_reduction_float_min_max {
                             // targets:
                             if i == $id::lanes() - 1 &&
                               target_with_broken_last_lane_nan {
-                                // FIXME:
-                                // https://github.com/rust-lang-nursery/packed_simd/issues/5
-                                //
-                                // If there is a NaN, the result should
-                                // always the largest element, but currently
-                                // when the last element is NaN the current
-                                // implementation incorrectly returns NaN.
-                                //
-                                // The targets mentioned above use different
-                                // codegen that produces the correct result.
-                                //
-                                // These asserts detect if this behavior
-                                // changes
-                                assert!(v.max_element().is_nan(),
-                                        // FIXME: ^^^ should be -3.
+                                assert_eq!(v.max_element(), -3.,
                                         "[A]: nan at {} => {} | {:?}",
                                         i, v.max_element(), v);
 
                                 // If we replace all the elements in the vector
                                 // up-to the `i-th` lane with `NaN`s, the result
                                 // is still always `-3.` unless all elements of
                                 // the vector are `NaN`s:
-                                //
-                                // This is also broken:
                                 for j in 0..i {
                                     v = v.replace(j, n);
-                                    assert!(v.max_element().is_nan(),
-                                            // FIXME: ^^^ should be -3.
+                                    if j == i-1 {
+                                        assert!(v.min_element().is_nan(),
+                                        "[B]: nan at {} => {} | {:?}",
+                                        i, v.min_element(), v);
+                                    } else {
+                                        assert_eq!(v.max_element(), -3.,
                                             "[B]: nan at {} => {} | {:?}",
                                             i, v.max_element(), v);
+                                    }
                                 }
 
                                 // We are done here, since we were in the last

src/lib.rs

@@ -262,7 +262,7 @@ mod api;
 mod codegen;
 mod sealed;
 
-pub use crate::sealed::{Simd as SimdVector, Shuffle, SimdArray, Mask};
+pub use crate::sealed::{Mask, Shuffle, Simd as SimdVector, SimdArray};
 
 /// Packed SIMD vector type.
 ///