Make mask types opaque (linebender#218)

This is necessary for eventual AVX-512 support. Part of linebender#179.

This does not add any AVX-512 stuff yet, just lays the groundwork by
abstracting away the internal representation.

Contrary to what the description of linebender#196 said, we don't actually need
i64 vectors in the public API so long as we're not providing direct
conversions between mask types and integer vector types, which aren't
available even on main.

Summary of changes:

- Add `SimdMask<S>` trait independent from `SimdBase<S>`.
- Remove integer-vector-style APIs from masks:
  - `Deref`
  - Indexing
  - `Bytes`
  - public `SimdSplit` / `SimdCombine`
  - public `slide` / `slide_within_blocks`
  - public byte conversions
- Remove scalar bit-op overloads for masks, so masks support
mask-to-mask `& | ^ !` but not `mask & -1`.

This was extricated from a larger changeset I had locally that also
added some std::simd API compatibility functions, but that was getting
too complicated to review. I'm happy to add more APIs if there's desire
and review capacity for them.

A port of vello to this API can be found [here](
https://github.com/linebender/vello/compare/main...Shnatsel:opaque-masks?expand=1).

Author: Shnatsel

fearless_simd/src/generated/avx2.rs

@@ -9,11 +9,12 @@ use crate::{Level, Simd, SimdBase, seal::Seal};
 
 /// Element-wise selection between two SIMD vectors using `self`.
 pub trait Select<T: Seal>: Seal {
-    /// For each element of this mask, select the first operand if the element is all ones, and select the second
-    /// operand if the element is all zeroes.
+    /// For each logical lane of this mask, select the first operand if the lane is true, and select the second
+    /// operand if the lane is false.
     ///
-    /// If a mask element is *not* all ones or all zeroes, the result is unspecified. It may vary depending on
-    /// architecture, feature level, the mask elements' width, the mask vector's width, or library version.
+    /// Masks may be converted to and from signed integer lane arrays for compatibility with older APIs. For those
+    /// conversions, false is encoded as all zeroes (integer value 0) and true is encoded as all ones (integer value -1).
+    /// If a mask is constructed from any other integer bit pattern, the result of this operation is unspecified.
     fn select(self, if_true: T, if_false: T) -> T;
 }
 

fearless_simd/src/generated/fallback.rs

@@ -13,6 +13,19 @@ pub(crate) fn generic_op_name(op: &str, ty: &VecType) -> Ident {
     Ident::new(&format!("{op}_{}", ty.rust_name()), Span::call_site())
 }
 
+/// For backends that store masks as all-zero/all-one integer lanes, convert the public
+/// `bool` mask splat argument into the backend's lane representation.
+pub(crate) fn integer_lane_mask_splat_arg(vec_ty: &VecType) -> TokenStream {
+    if vec_ty.scalar != ScalarType::Mask {
+        return TokenStream::new();
+    }
+
+    let scalar = vec_ty.scalar.rust(vec_ty.scalar_bits);
+    quote! {
+        let val: #scalar = if val { !0 } else { 0 };
+    }
+}
+
 /// Implementation based on split/combine
 ///
 /// Only suitable for lane-wise and block-wise operations