simd: generator doc says what it emits (NEON per-quad intrinsics); probe fns crate-private

Two CodeRabbit nits on #306. The generator's module doc still described the
NEON output as "plain `u32` for NEON's per-lane loop" — the shape that
scalarised and was replaced by per-128-bit-quad `vandq/vorrq/veorq/vbicq`
bodies. `safe_intrinsic_probe`'s functions are not an API and are never
called (the observable is whether `cargo check` accepts each arm), so they
are `pub(crate)` with the dead-code lint silenced rather than given doc
examples that would have to be cfg-gated per architecture. `--check` is
still green; the probe still reproduces E0133 on the C arm.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01X6y3drwKSE2zSgoexheLFX

Author: claude

tools/gen_ternlog_bodies.py

@@ -12,7 +12,9 @@
 an 8-bit truth table into a minimal Boolean DAG, checks it against a
 bit-serial reference for all 256 tables, and then PRINTS each backend's body
 in that backend's own vocabulary (operator traits on the array-backed lane
-types; plain `u32` for NEON's per-lane loop; `v128_*` intrinsics for WASM).
+types; `vandq/vorrq/veorq/vbicq_u{32,64}` NEON intrinsics per 128-bit quad —
+NOT a per-lane `u32` loop, which LLVM scalarised (536 scalar / 4 vector ops
+measured); `v128_*` intrinsics for WASM).
 The emitted text is pasted into the backend file between GEN markers by
 `--apply`; it is committed source, and the generator is its provenance.
 

tools/safe_intrinsic_probe/src/lib.rs

@@ -1,41 +1,47 @@
 #![forbid(unsafe_code)]
 //! Which SIMD intrinsics are callable from SAFE code on rustc 1.98.1, per arch.
+//!
+//! Nothing here is an API and nothing calls these functions: the OBSERVABLE
+//! is whether `cargo check` accepts or rejects each arm (E0133), so they are
+//! crate-private and the dead-code lint is silenced rather than satisfied by
+//! fake callers or doc examples that would have to be `#[cfg]`-gated per arch.
+#![allow(dead_code)]
 #[cfg(target_arch = "aarch64")]
 pub mod a64 {
     use core::arch::aarch64::*;
     /// A: plain fn, baseline-feature intrinsic (neon).
     #[cfg(probe_a)]
-    pub fn plain_neon(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { vandq_u32(a, b) }
+    pub(crate) fn plain_neon(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { vandq_u32(a, b) }
     /// B: annotated fn, same call.
     #[target_feature(enable = "neon")]
-    pub fn annotated_neon(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { vandq_u32(a, b) }
+    pub(crate) fn annotated_neon(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { vandq_u32(a, b) }
     /// C: plain fn calling the annotated SAFE fn.
     #[cfg(probe_c)]
-    pub fn plain_calls_annotated(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { annotated_neon(a, b) }
+    pub(crate) fn plain_calls_annotated(a: uint32x4_t, b: uint32x4_t) -> uint32x4_t { annotated_neon(a, b) }
 }
 #[cfg(target_arch = "x86_64")]
 pub mod x86 {
     use core::arch::x86_64::*;
     /// A: plain fn, sse2 (baseline for x86_64).
     #[cfg(probe_a)]
-    pub fn plain_sse2(a: __m128i, b: __m128i) -> __m128i { _mm_and_si128(a, b) }
+    pub(crate) fn plain_sse2(a: __m128i, b: __m128i) -> __m128i { _mm_and_si128(a, b) }
     /// A2: plain fn, avx2 (baseline only under -Ctarget-cpu=x86-64-v3).
     #[cfg(probe_a2)]
-    pub fn plain_avx2(a: __m256i, b: __m256i) -> __m256i { _mm256_and_si256(a, b) }
+    pub(crate) fn plain_avx2(a: __m256i, b: __m256i) -> __m256i { _mm256_and_si256(a, b) }
     /// A3: plain fn, avx512f ternarylogic (baseline only under x86-64-v4).
     #[cfg(probe_a3)]
-    pub fn plain_avx512(a: __m512i, b: __m512i, c: __m512i) -> __m512i { _mm512_ternarylogic_epi64::<0x96>(a, b, c) }
+    pub(crate) fn plain_avx512(a: __m512i, b: __m512i, c: __m512i) -> __m512i { _mm512_ternarylogic_epi64::<0x96>(a, b, c) }
     /// B: annotated fn.
     #[target_feature(enable = "avx2")]
-    pub fn annotated_avx2(a: __m256i, b: __m256i) -> __m256i { _mm256_and_si256(a, b) }
+    pub(crate) fn annotated_avx2(a: __m256i, b: __m256i) -> __m256i { _mm256_and_si256(a, b) }
     /// C: plain fn calling annotated safe fn.
     #[cfg(probe_c)]
-    pub fn plain_calls_annotated(a: __m256i, b: __m256i) -> __m256i { annotated_avx2(a, b) }
+    pub(crate) fn plain_calls_annotated(a: __m256i, b: __m256i) -> __m256i { annotated_avx2(a, b) }
 }
 #[cfg(target_arch = "wasm32")]
 pub mod w {
     use core::arch::wasm32::*;
     /// A: plain fn, simd128 intrinsic.
     #[cfg(probe_a)]
-    pub fn plain_wasm(a: v128, b: v128) -> v128 { v128_and(a, b) }
+    pub(crate) fn plain_wasm(a: v128, b: v128) -> v128 { v128_and(a, b) }
 }