Fix various lints

workingjubilee · workingjubilee · commit cbee1bd6f18b · 2020-09-23T16:36:55.000-07:00
Mostly allowing correct mathematical operations and fixing some
pointer casts to clippy's preferences.
Also:
Remove superfluous unit return
Allow mut of const temporaries
Use more precise PI const
Don't index in loop
diff --git a/examples/stencil/src/lib.rs b/examples/stencil/src/lib.rs
@@ -97,7 +97,7 @@ impl Data {
     pub fn exec<F>(&mut self, f: F)
     where
         F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,
-            &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),
+            &[f32; 4], &[f32], &mut [f32], &mut [f32]),
     {
         f(
             self.t.0, self.t.1,
diff --git a/examples/stencil/src/main.rs b/examples/stencil/src/main.rs
@@ -8,7 +8,7 @@ use std::env;
 fn run<F>(name: &str, f: F)
 where
     F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,
-        &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),
+        &[f32; 4], &[f32], &mut [f32], &mut [f32]),
 {
     let mut d = Data::benchmark();
     let t = time::Duration::span(move || d.exec(f));
diff --git a/examples/stencil/src/simd.rs b/examples/stencil/src/simd.rs
@@ -36,12 +36,12 @@ pub(crate) fn step_x8(
 
                         let sum = {
                             let i = i as i32;
-                            (a_cur!(i, 0, 0)
+                            a_cur!(i, 0, 0)
                                 + a_cur!(-i, 0, 0)
                                 + a_cur!(0, i, 0)
                                 + a_cur!(0, -i, 0)
                                 + a_cur!(0, 0, i)
-                                + a_cur!(0, 0, -i))
+                                + a_cur!(0, 0, -i)
                         };
 
                         div = coef.mul_adde(sum, div);
diff --git a/src/api/bit_manip.rs b/src/api/bit_manip.rs
@@ -37,6 +37,7 @@ macro_rules! impl_bit_manip {
             paste::item_with_macros! {
                 #[allow(overflowing_literals)]
                 pub mod [<$id _bit_manip>] {
+                    #![allow(const_item_mutation)]
                     use super::*;
 
                     const LANE_WIDTH: usize = mem::size_of::<$elem_ty>() * 8;
diff --git a/src/api/default.rs b/src/api/default.rs
@@ -12,6 +12,8 @@ macro_rules! impl_default {
         test_if!{
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _default>] {
                     use super::*;
                     #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
diff --git a/src/api/from/from_array.rs b/src/api/from/from_array.rs
@@ -56,6 +56,8 @@ macro_rules! impl_from_array {
         test_if! {
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 mod [<$id _from>] {
                     use super::*;
                     #[test]
diff --git a/src/api/hash.rs b/src/api/hash.rs
@@ -36,6 +36,8 @@ macro_rules! impl_hash {
                         let mut v_hash = a_hash.clone();
                         a.hash(&mut a_hash);
 
+                        // Integer within mantissa^1 range.
+                        #[allow(clippy::float_cmp)]
                         let v = $id::splat(42 as $elem_ty);
                         v.hash(&mut v_hash);
                         assert_eq!(a_hash.finish(), v_hash.finish());
diff --git a/src/api/minimal/iuf.rs b/src/api/minimal/iuf.rs
@@ -101,6 +101,8 @@ macro_rules! impl_minimal_iuf {
         test_if!{
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _minimal>] {
                     use super::*;
                     #[cfg_attr(not(target_arch = "wasm32"), test)]
diff --git a/src/api/minimal/ptr.rs b/src/api/minimal/ptr.rs
@@ -550,11 +550,7 @@ macro_rules! impl_minimal_p {
                         ];
 
                         for i in 0..$elem_count {
-                            let ptr = unsafe {
-                                crate::mem::transmute(
-                                    &values[i] as *const i32
-                                )
-                            };
+                            let ptr = &values[i] as *const i32 as *mut i32;
                             vec = vec.replace(i, ptr);
                             array[i] = ptr;
                         }
@@ -1025,11 +1021,7 @@ macro_rules! impl_minimal_p {
                         ];
 
                         for i in 0..$elem_count {
-                            let ptr = unsafe {
-                                crate::mem::transmute(
-                                    &values[i] as *const i32
-                                )
-                            };
+                            let ptr = &values[i] as *const i32 as *mut i32;
                             vec = vec.replace(i, ptr);
                             array[i] = ptr;
                         }
diff --git a/src/api/ptr/gather_scatter.rs b/src/api/ptr/gather_scatter.rs
@@ -49,9 +49,9 @@ macro_rules! impl_ptr_read {
                         let mut ptr = $id::<i32>::null();
 
                         for i in 0..$elem_count {
-                            ptr = ptr.replace(i, unsafe {
-                                crate::mem::transmute(&v[i] as *const i32)
-                            });
+                            ptr = ptr.replace(i,
+                                &v[i] as *const i32 as *mut i32
+                            );
                         }
 
                         // all mask elements are true:
@@ -161,7 +161,7 @@ macro_rules! impl_ptr_write {
                         let mut ptr = $id::<i32>::null();
                         for i in 0..$elem_count {
                             ptr = ptr.replace(i, unsafe {
-                                crate::mem::transmute(arr.as_ptr().add(i))
+                                arr.as_ptr().add(i) as *mut i32
                             });
                         }
                         // ptr = [&arr[0], &arr[1], ...]
diff --git a/src/api/reductions/float_arithmetic.rs b/src/api/reductions/float_arithmetic.rs
@@ -93,6 +93,8 @@ macro_rules! impl_reduction_float_arithmetic {
         test_if! {
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _reduction_float_arith>] {
                     use super::*;
                     fn alternating(x: usize) -> $id {
@@ -225,7 +227,7 @@ macro_rules! impl_reduction_float_arithmetic {
                         let mut v = $id::splat(0. as $elem_ty);
                         for i in 0..$id::lanes() {
                             let c = if i % 2 == 0 { 1e3 } else { -1. };
-                            start *= 3.14 * c;
+                            start *= ::core::$elem_ty::consts::PI * c;
                             scalar_reduction += start;
                             v = v.replace(i, start);
                         }
@@ -278,7 +280,7 @@ macro_rules! impl_reduction_float_arithmetic {
                         let mut v = $id::splat(0. as $elem_ty);
                         for i in 0..$id::lanes() {
                             let c = if i % 2 == 0 { 1e3 } else { -1. };
-                            start *= 3.14 * c;
+                            start *= ::core::$elem_ty::consts::PI * c;
                             scalar_reduction *= start;
                             v = v.replace(i, start);
                         }
diff --git a/src/api/reductions/min_max.rs b/src/api/reductions/min_max.rs
@@ -76,6 +76,8 @@ macro_rules! impl_reduction_min_max {
         }
         test_if! {$test_tt:
         paste::item! {
+            // Comparisons use integer casts within mantissa^1 range.
+            #[allow(clippy::float_cmp)]
             pub mod [<$id _reduction_min_max>] {
                 use super::*;
                 #[cfg_attr(not(target_arch = "wasm32"), test)]
@@ -124,6 +126,8 @@ macro_rules! test_reduction_float_min_max {
         test_if!{
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _reduction_min_max_nan>] {
                     use super::*;
                     #[cfg_attr(not(target_arch = "wasm32"), test)]
diff --git a/src/api/slice/from_slice.rs b/src/api/slice/from_slice.rs
@@ -84,6 +84,8 @@ macro_rules! impl_slice_from_slice {
         test_if! {
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _slice_from_slice>] {
                     use super::*;
                     use crate::iter::Iterator;
diff --git a/src/api/slice/write_to_slice.rs b/src/api/slice/write_to_slice.rs
@@ -86,6 +86,8 @@ macro_rules! impl_slice_write_to_slice {
         test_if! {
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 pub mod [<$id _slice_write_to_slice>] {
                     use super::*;
                     use crate::iter::Iterator;
diff --git a/src/testing/utils.rs b/src/testing/utils.rs
@@ -1,6 +1,8 @@
 //! Testing utilities
 
 #![allow(dead_code)]
+// FIXME: Or don't. But it's true this is a problematic comparison.
+#![allow(clippy::neg_cmp_op_on_partial_ord)]
 
 use crate::{cmp::PartialOrd, fmt::Debug, LexicographicallyOrdered};
 
@@ -19,14 +21,19 @@ pub fn test_lt<T>(
     assert!(a <= b, "{:?}, {:?}", a, b);
     assert!(b >= a, "{:?}, {:?}", a, b);
 
-    // Irreflexivity
-    assert!(!(a < a), "{:?}, {:?}", a, b);
-    assert!(!(b < b), "{:?}, {:?}", a, b);
-    assert!(!(a > a), "{:?}, {:?}", a, b);
-    assert!(!(b > b), "{:?}, {:?}", a, b);
+    // The elegance of the mathematical expression of irreflexivity is more
+    // than clippy can handle.
+    #[allow(clippy::eq_op)]
+    {
+        // Irreflexivity
+        assert!(!(a < a), "{:?}, {:?}", a, b);
+        assert!(!(b < b), "{:?}, {:?}", a, b);
+        assert!(!(a > a), "{:?}, {:?}", a, b);
+        assert!(!(b > b), "{:?}, {:?}", a, b);
 
-    assert!(a <= a, "{:?}, {:?}", a, b);
-    assert!(b <= b, "{:?}, {:?}", a, b);
+        assert!(a <= a, "{:?}, {:?}", a, b);
+        assert!(b <= b, "{:?}, {:?}", a, b);
+    }
 }
 
 /// Tests PartialOrd for `a` and `b` where `a <= b` is true.
@@ -38,8 +45,8 @@ pub fn test_le<T>(
     assert!(a <= b, "{:?}, {:?}", a, b);
     assert!(b >= a, "{:?}, {:?}", a, b);
 
-    assert!(a == b || a < b, "{:?}, {:?}", a, b);
-    assert!(a == b || b > a, "{:?}, {:?}", a, b);
+    assert!(a <= b, "{:?}, {:?}", a, b);
+    assert!(b >= a, "{:?}, {:?}", a, b);
 
     if a == b {
         assert!(!(a < b), "{:?}, {:?}", a, b);
diff --git a/tests/endianness.rs b/tests/endianness.rs
@@ -82,10 +82,15 @@ fn endian_array_union() {
         vec: f32x4,
     }
     let x: [f32; 4] = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data };
-    assert_eq!(x[0], 0_f32);
-    assert_eq!(x[1], 1_f32);
-    assert_eq!(x[2], 2_f32);
-    assert_eq!(x[3], 3_f32);
+    // As all of these are integer values within the mantissa^1 range, it
+    // would be very unusual for them to actually fail to compare.
+    #[allow(clippy::float_cmp)]
+    {
+        assert_eq!(x[0], 0_f32);
+        assert_eq!(x[1], 1_f32);
+        assert_eq!(x[2], 2_f32);
+        assert_eq!(x[3], 3_f32);
+    }
     let y: f32x4 = unsafe { A { data: [3., 2., 1., 0.] }.vec };
     assert_eq!(y, f32x4::new(3., 2., 1., 0.));
 
@@ -100,8 +105,8 @@ fn endian_array_union() {
     );
     let x: [i8; 16] = unsafe { B { vec: x }.data };
 
-    for i in 0..16 {
-        assert_eq!(x[i], i as i8);
+    for (i, v) in x.iter().enumerate() {
+        assert_eq!(i as i8, *v);
     }
 
     #[rustfmt::skip]
@@ -145,10 +150,15 @@ fn endian_tuple_access() {
         vec: f32x4,
     }
     let x: F32x4T = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data };
-    assert_eq!(x.0, 0_f32);
-    assert_eq!(x.1, 1_f32);
-    assert_eq!(x.2, 2_f32);
-    assert_eq!(x.3, 3_f32);
+    // As all of these are integer values within the mantissa^1 range, it
+    // would be very unusual for them to actually fail to compare.
+    #[allow(clippy::float_cmp)]
+    {
+        assert_eq!(x.0, 0_f32);
+        assert_eq!(x.1, 1_f32);
+        assert_eq!(x.2, 2_f32);
+        assert_eq!(x.3, 3_f32);
+    }
     let y: f32x4 = unsafe { A { data: (3., 2., 1., 0.) }.vec };
     assert_eq!(y, f32x4::new(3., 2., 1., 0.));
 

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ impl Data {`
`97`	`97`	`pub fn exec<F>(&mut self, f: F)`
`98`	`98`	`where`
`99`	`99`	`F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,`
`100`		`- &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),`
	`100`	`+ &[f32; 4], &[f32], &mut [f32], &mut [f32]),`
`101`	`101`	`{`
`102`	`102`	`f(`
`103`	`103`	`self.t.0, self.t.1,`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ use std::env;`
`8`	`8`	`fn run<F>(name: &str, f: F)`
`9`	`9`	`where`
`10`	`10`	`F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,`
`11`		`- &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),`
	`11`	`+ &[f32; 4], &[f32], &mut [f32], &mut [f32]),`
`12`	`12`	`{`
`13`	`13`	`let mut d = Data::benchmark();`
`14`	`14`	`let t = time::Duration::span(move \|\| d.exec(f));`