Document allowed vector lengths

Author: calebzulawski

crates/core_simd/src/masks.rs

@@ -118,6 +118,9 @@ impl_element! { isize, usize }
 /// The layout of this type is unspecified, and may change between platforms
 /// and/or Rust versions, and code should not assume that it is equivalent to
 /// `[T; N]`.
+///
+/// `N` cannot be 0 and may be at most 64. This limit may be increased in
+/// the future.
 #[repr(transparent)]
 pub struct Mask<T, const N: usize>(Simd<T, N>)
 where

crates/core_simd/src/simd/num/int.rs

@@ -240,16 +240,9 @@ pub trait SimdInt: Copy + Sealed {
 macro_rules! impl_trait {
     { $($ty:ident ($unsigned:ident)),* } => {
         $(
-        impl<const N: usize> Sealed for Simd<$ty, N>
-        where
+        impl<const N: usize> Sealed for Simd<$ty, N> {}
 
-        {
-        }
-
-        impl<const N: usize> SimdInt for Simd<$ty, N>
-        where
-
-        {
+        impl<const N: usize> SimdInt for Simd<$ty, N> {
             type Mask = Mask<<$ty as SimdElement>::Mask, N>;
             type Scalar = $ty;
             type Unsigned = Simd<$unsigned, N>;

crates/core_simd/src/swizzle_dyn.rs

@@ -181,9 +181,7 @@ unsafe fn transize<T, const N: usize>(
     f: unsafe fn(T, T) -> T,
     a: Simd<u8, N>,
     b: Simd<u8, N>,
-) -> Simd<u8, N>
-where
-{
+) -> Simd<u8, N> {
     // SAFETY: Same obligation to use this function as to use mem::transmute_copy.
     unsafe { mem::transmute_copy(&f(mem::transmute_copy(&a), mem::transmute_copy(&b))) }
 }
@@ -192,9 +190,7 @@ where
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 #[allow(unused)]
 #[inline(always)]
-fn zeroing_idxs<const N: usize>(idxs: Simd<u8, N>) -> Simd<u8, N>
-where
-{
+fn zeroing_idxs<const N: usize>(idxs: Simd<u8, N>) -> Simd<u8, N> {
     use crate::simd::{Select, cmp::SimdPartialOrd};
     idxs.simd_lt(Simd::splat(N as u8))
         .select(idxs, Simd::splat(u8::MAX))

crates/core_simd/src/vector.rs

@@ -51,6 +51,8 @@ use crate::simd::{
 /// Thus it is sound to [`transmute`] `Simd<T, N>` to `[T; N]` and should optimize to "zero cost",
 /// but the reverse transmutation may require a copy the compiler cannot simply elide.
 ///
+/// `N` cannot be 0 and may be at most 64. This limit may be increased in the future.
+///
 /// # ABI "Features"
 /// Due to Rust's safety guarantees, `Simd<T, N>` is currently passed and returned via memory,
 /// not SIMD registers, except as an optimization. Using `#[inline]` on functions that accept