Lint SIMD code, fix generic expectation failures

Author: clarfonthey

.github/workflows/rust.yml

@@ -21,7 +21,7 @@ jobs:
       run: curl -fsSL https://github.com/tamasfe/taplo/releases/latest/download/taplo-linux-x86_64.gz | gzip -d - | install -m 755 /dev/stdin /usr/local/bin/taplo
     - env:
         TARGET: i586-unknown-linux-gnu
-      run: sh ci/tools.sh
+      run: bash ci/tools.sh
 
   basics:
     runs-on: ubuntu-latest

ci/tools.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 set -ex
 
@@ -36,7 +36,63 @@ if retry rustup component add rustfmt ; then
 fi
 
 if retry rustup component add clippy ; then
-    cargo clippy --all --tests --features serde,rayon -- -D warnings
+    # we want all targets that have dedicated SIMD implementations,
+    # plus one that uses the generic implementation,
+    # since we can't lint cfg-disabled code
+    TARGETS=()
+
+    # associative array of cfgs from rustc
+    declare -A CFG
+    for cfg in $(rustc --print cfg); do
+        # bash is very upset about quotes and equal signs in keys
+        cfg="${cfg//\"/}"
+        cfg="${cfg//=/_}"
+        printf "\n%s\n" "$cfg" >&2
+        CFG["$cfg"]=1
+    done
+
+    HOST_IS_GENERIC=1
+
+    # SSE2
+    if (( CFG[target_feature_sse2] && (CFG[target_arch_x86] || CFG[target_arch_x86_64]) )); then
+        printf "\nHost target supports SSE2\n" >&2
+        TARGETS+=(--target "$(rustc --print host-tuple)")
+        HOST_IS_GENERIC=0
+    elif retry rustup target add x86_64-unknown-linux-gnu; then
+        printf "\nTesting x86_64-unknown-linux-gnu\n" >&2
+        TARGETS+=(--target x86_64-unknown-linux-gnu)
+    fi
+
+    # NEON
+    if (( CFG[target_arch_aarch64] && CFG[target_feature_neon] && CFG[target_endian_little] )); then
+        printf "\nHost target supports NEON\n" >&2
+        TARGETS+=(--target "$(rustc --print host-tuple)")
+        HOST_IS_GENERIC=0
+    elif retry rustup target add aarch64-unknown-linux-gnu; then
+        printf "\nTesting aarch64-unknown-linux-gnu\n" >&2
+        TARGETS+=(--target aarch64-unknown-linux-gnu)
+    fi
+
+    # LSX
+    if (( CFG[target_arch_loongarch64] && CFG[target_feature_lsx] )); then
+        printf "\nHost target supports LSX\n" >&2
+        TARGETS+=(--target "$(rustc --print host-tuple)")
+        HOST_IS_GENERIC=0
+    elif retry rustup target add loongarch64-unknown-linux-gnu; then
+        printf "\nTesting loongarch64-unknown-linux-gnu\n" >&2
+        TARGETS+=(--target loongarch64-unknown-linux-gnu)
+    fi
+
+    # Generic
+    if (( HOST_IS_GENERIC )); then
+        printf "\nHost target support is generic\n" >&2
+        TARGETS+=(--target "$(rustc --print host-tuple)")
+    elif retry rustup target add i686-unknown-linux-gnu; then
+        printf "\nTesting i686-unknown-linux-gnu\n" >&2
+        TARGETS+=(--target i686-unknown-linux-gnu)
+    fi
+
+    cargo clippy --all --tests --features serde,rayon "${TARGETS[@]}" -- -D warnings
 fi
 
 if command -v taplo ; then

src/control/group/generic.rs

@@ -24,7 +24,6 @@ pub(crate) type BitMaskWord = GroupWord;
 pub(crate) type NonZeroBitMaskWord = NonZeroGroupWord;
 pub(crate) const BITMASK_STRIDE: usize = 8;
 // We only care about the highest bit of each tag for the mask.
-#[expect(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
 const BITMASK_MASK: BitMaskWord = u64::from_ne_bytes([Tag::DELETED.0; 8]) as GroupWord;
 pub(crate) const BITMASK_ITER_MASK: BitMaskWord = !0;
 
@@ -70,15 +69,13 @@ impl Group {
 
     /// Loads a group of tags starting at the given address.
     #[inline]
-    #[expect(clippy::cast_ptr_alignment)] // unaligned load
     pub(crate) unsafe fn load(ptr: *const Tag) -> Self {
         unsafe { Group(ptr::read_unaligned(ptr.cast())) }
     }
 
     /// Loads a group of tags starting at the given address, which must be
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
-    #[expect(clippy::cast_ptr_alignment)]
     pub(crate) unsafe fn load_aligned(ptr: *const Tag) -> Self {
         debug_assert_eq!(ptr.align_offset(mem::align_of::<Self>()), 0);
         unsafe { Group(ptr::read(ptr.cast())) }
@@ -87,7 +84,6 @@ impl Group {
     /// Stores the group of tags to the given address, which must be
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
-    #[expect(clippy::cast_ptr_alignment)]
     pub(crate) unsafe fn store_aligned(self, ptr: *mut Tag) {
         debug_assert_eq!(ptr.align_offset(mem::align_of::<Self>()), 0);
         unsafe {

src/control/group/mod.rs

@@ -1,3 +1,10 @@
+// TESTING NOTE:
+//
+// Because this module uses `cfg(..)` to select an implementation, it will not
+// be linted without being run on targets that actually load each of these
+// modules. Be sure to edit `ci/tools.sh` to add in the necessary cfgs if you
+// change these, so that your implementation gets properly linted.
+
 cfg_if! {
     // Use the SSE2 implementation if possible: it allows us to scan 16 buckets
     // at once instead of 8. We don't bother with AVX since it would require