Fix various lints

Mostly allowing correct mathematical operations and fixing some
pointer casts to clippy's preferences.

Author: workingjubilee

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);

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;

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)]

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]

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());

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)]

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;
                         }

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], ...]

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);
                         }

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)]

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;

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;

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);

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.));