Rename Mask::from_int_unchecked to Mask::from_simd_unchecked

okaneco · okaneco · commit 3a70dd6a69e0 · 2025-09-05T14:32:40.000-04:00
diff --git a/crates/core_simd/src/masks.rs b/crates/core_simd/src/masks.rs
@@ -157,7 +157,7 @@ where
             let bytes: [u8; N] = mem::transmute_copy(&array);
             let bools: Simd<i8, N> =
                 core::intrinsics::simd::simd_ne(Simd::from_array(bytes), Simd::splat(0u8));
-            Mask::from_int_unchecked(core::intrinsics::simd::simd_cast(bools))
+            Mask::from_simd_unchecked(core::intrinsics::simd::simd_cast(bools))
         }
     }
 
@@ -188,11 +188,11 @@ where
     /// All elements must be either 0 or -1.
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
-    pub unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
+    pub unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {
         // Safety: the caller must confirm this invariant
         unsafe {
             core::intrinsics::assume(<T as Sealed>::valid(value));
-            Self(mask_impl::Mask::from_int_unchecked(value))
+            Self(mask_impl::Mask::from_simd_unchecked(value))
         }
     }
 
@@ -207,7 +207,7 @@ where
     pub fn from_simd(value: Simd<T, N>) -> Self {
         assert!(T::valid(value), "all values must be either 0 or -1",);
         // Safety: the validity has been checked
-        unsafe { Self::from_int_unchecked(value) }
+        unsafe { Self::from_simd_unchecked(value) }
     }
 
     /// Converts the mask to a vector of integers, where 0 represents `false` and -1
diff --git a/crates/core_simd/src/masks/bitmask.rs b/crates/core_simd/src/masks/bitmask.rs
@@ -117,7 +117,7 @@ where
 
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
-    pub(crate) unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
+    pub(crate) unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {
         unsafe { Self(core::intrinsics::simd::simd_bitmask(value), PhantomData) }
     }
 
diff --git a/crates/core_simd/src/masks/full_masks.rs b/crates/core_simd/src/masks/full_masks.rs
@@ -126,7 +126,7 @@ where
 
     #[inline]
     #[must_use = "method returns a new mask and does not mutate the original value"]
-    pub(crate) unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {
+    pub(crate) unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {
         Self(value)
     }
 
@@ -180,7 +180,7 @@ where
         };
 
         // SAFETY: `mask` only contains `T::TRUE` or `T::FALSE`
-        unsafe { Self::from_int_unchecked(mask.resize::<N>(T::FALSE)) }
+        unsafe { Self::from_simd_unchecked(mask.resize::<N>(T::FALSE)) }
     }
 
     #[inline]
diff --git a/crates/core_simd/src/simd/cmp/eq.rs b/crates/core_simd/src/simd/cmp/eq.rs
@@ -30,14 +30,14 @@ macro_rules! impl_number {
             fn simd_eq(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_eq(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_eq(self, other)) }
             }
 
             #[inline]
             fn simd_ne(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_ne(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ne(self, other)) }
             }
         }
         )*
@@ -59,14 +59,14 @@ macro_rules! impl_mask {
             fn simd_eq(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_eq(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_eq(self.to_simd(), other.to_simd())) }
             }
 
             #[inline]
             fn simd_ne(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_ne(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_ne(self.to_simd(), other.to_simd())) }
             }
         }
         )*
diff --git a/crates/core_simd/src/simd/cmp/ord.rs b/crates/core_simd/src/simd/cmp/ord.rs
@@ -56,28 +56,28 @@ macro_rules! impl_integer {
             fn simd_lt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
             }
 
             #[inline]
             fn simd_le(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_le(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_le(self, other)) }
             }
 
             #[inline]
             fn simd_gt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
             }
 
             #[inline]
             fn simd_ge(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
             }
         }
 
@@ -122,28 +122,28 @@ macro_rules! impl_float {
             fn simd_lt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
             }
 
             #[inline]
             fn simd_le(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_le(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_le(self, other)) }
             }
 
             #[inline]
             fn simd_gt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
             }
 
             #[inline]
             fn simd_ge(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
+                unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
             }
         }
         )*
@@ -163,28 +163,28 @@ macro_rules! impl_mask {
             fn simd_lt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_lt(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_lt(self.to_simd(), other.to_simd())) }
             }
 
             #[inline]
             fn simd_le(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_le(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_le(self.to_simd(), other.to_simd())) }
             }
 
             #[inline]
             fn simd_gt(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_gt(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_gt(self.to_simd(), other.to_simd())) }
             }
 
             #[inline]
             fn simd_ge(self, other: Self) -> Self::Mask {
                 // Safety: `self` is a vector, and the result of the comparison
                 // is always a valid mask.
-                unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_ge(self.to_simd(), other.to_simd())) }
+                unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_ge(self.to_simd(), other.to_simd())) }
             }
         }
 
diff --git a/crates/core_simd/src/swizzle.rs b/crates/core_simd/src/swizzle.rs
@@ -165,7 +165,7 @@ pub trait Swizzle<const N: usize> {
         LaneCount<M>: SupportedLaneCount,
     {
         // SAFETY: all elements of this mask come from another mask
-        unsafe { Mask::from_int_unchecked(Self::swizzle(mask.to_simd())) }
+        unsafe { Mask::from_simd_unchecked(Self::swizzle(mask.to_simd())) }
     }
 
     /// Creates a new mask from the elements of `first` and `second`.
@@ -181,7 +181,9 @@ pub trait Swizzle<const N: usize> {
         LaneCount<M>: SupportedLaneCount,
     {
         // SAFETY: all elements of this mask come from another mask
-        unsafe { Mask::from_int_unchecked(Self::concat_swizzle(first.to_simd(), second.to_simd())) }
+        unsafe {
+            Mask::from_simd_unchecked(Self::concat_swizzle(first.to_simd(), second.to_simd()))
+        }
     }
 }
 
@@ -524,7 +526,7 @@ where
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
     pub fn reverse(self) -> Self {
         // Safety: swizzles are safe for masks
-        unsafe { Self::from_int_unchecked(self.to_simd().reverse()) }
+        unsafe { Self::from_simd_unchecked(self.to_simd().reverse()) }
     }
 
     /// Rotates the mask such that the first `OFFSET` elements of the slice move to the end
@@ -534,7 +536,7 @@ where
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
     pub fn rotate_elements_left<const OFFSET: usize>(self) -> Self {
         // Safety: swizzles are safe for masks
-        unsafe { Self::from_int_unchecked(self.to_simd().rotate_elements_left::<OFFSET>()) }
+        unsafe { Self::from_simd_unchecked(self.to_simd().rotate_elements_left::<OFFSET>()) }
     }
 
     /// Rotates the mask such that the first `self.len() - OFFSET` elements of the mask move to
@@ -544,7 +546,7 @@ where
     #[must_use = "method returns a new vector and does not mutate the original inputs"]
     pub fn rotate_elements_right<const OFFSET: usize>(self) -> Self {
         // Safety: swizzles are safe for masks
-        unsafe { Self::from_int_unchecked(self.to_simd().rotate_elements_right::<OFFSET>()) }
+        unsafe { Self::from_simd_unchecked(self.to_simd().rotate_elements_right::<OFFSET>()) }
     }
 
     /// Shifts the mask elements to the left by `OFFSET`, filling in with
@@ -554,7 +556,7 @@ where
     pub fn shift_elements_left<const OFFSET: usize>(self, padding: bool) -> Self {
         // Safety: swizzles are safe for masks
         unsafe {
-            Self::from_int_unchecked(self.to_simd().shift_elements_left::<OFFSET>(if padding {
+            Self::from_simd_unchecked(self.to_simd().shift_elements_left::<OFFSET>(if padding {
                 T::TRUE
             } else {
                 T::FALSE
@@ -569,7 +571,7 @@ where
     pub fn shift_elements_right<const OFFSET: usize>(self, padding: bool) -> Self {
         // Safety: swizzles are safe for masks
         unsafe {
-            Self::from_int_unchecked(self.to_simd().shift_elements_right::<OFFSET>(if padding {
+            Self::from_simd_unchecked(self.to_simd().shift_elements_right::<OFFSET>(if padding {
                 T::TRUE
             } else {
                 T::FALSE
@@ -600,7 +602,7 @@ where
     pub fn interleave(self, other: Self) -> (Self, Self) {
         let (lo, hi) = self.to_simd().interleave(other.to_simd());
         // Safety: swizzles are safe for masks
-        unsafe { (Self::from_int_unchecked(lo), Self::from_int_unchecked(hi)) }
+        unsafe { (Self::from_simd_unchecked(lo), Self::from_simd_unchecked(hi)) }
     }
 
     /// Deinterleave two masks.
@@ -631,8 +633,8 @@ where
         // Safety: swizzles are safe for masks
         unsafe {
             (
-                Self::from_int_unchecked(even),
-                Self::from_int_unchecked(odd),
+                Self::from_simd_unchecked(even),
+                Self::from_simd_unchecked(odd),
             )
         }
     }
@@ -659,7 +661,7 @@ where
     {
         // Safety: swizzles are safe for masks
         unsafe {
-            Mask::<T, M>::from_int_unchecked(self.to_simd().resize::<M>(if value {
+            Mask::<T, M>::from_simd_unchecked(self.to_simd().resize::<M>(if value {
                 T::TRUE
             } else {
                 T::FALSE
@@ -684,6 +686,6 @@ where
         LaneCount<LEN>: SupportedLaneCount,
     {
         // Safety: swizzles are safe for masks
-        unsafe { Mask::<T, LEN>::from_int_unchecked(self.to_simd().extract::<START, LEN>()) }
+        unsafe { Mask::<T, LEN>::from_simd_unchecked(self.to_simd().extract::<START, LEN>()) }
     }
 }
diff --git a/crates/core_simd/src/vector.rs b/crates/core_simd/src/vector.rs
@@ -926,7 +926,7 @@ where
         let mask = unsafe {
             let tfvec: Simd<<T as SimdElement>::Mask, N> =
                 core::intrinsics::simd::simd_eq(*self, *other);
-            Mask::from_int_unchecked(tfvec)
+            Mask::from_simd_unchecked(tfvec)
         };
 
         // Two vectors are equal if all elements are equal when compared elementwise
@@ -940,7 +940,7 @@ where
         let mask = unsafe {
             let tfvec: Simd<<T as SimdElement>::Mask, N> =
                 core::intrinsics::simd::simd_ne(*self, *other);
-            Mask::from_int_unchecked(tfvec)
+            Mask::from_simd_unchecked(tfvec)
         };
 
         // Two vectors are non-equal if any elements are non-equal when compared elementwise

Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ where`
`157`	`157`	`let bytes: [u8; N] = mem::transmute_copy(&array);`
`158`	`158`	`let bools: Simd<i8, N> =`
`159`	`159`	`core::intrinsics::simd::simd_ne(Simd::from_array(bytes), Simd::splat(0u8));`
`160`		`- Mask::from_int_unchecked(core::intrinsics::simd::simd_cast(bools))`
	`160`	`+ Mask::from_simd_unchecked(core::intrinsics::simd::simd_cast(bools))`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`@@ -188,11 +188,11 @@ where`
`188`	`188`	`/// All elements must be either 0 or -1.`
`189`	`189`	`#[inline]`
`190`	`190`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`191`		`- pub unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {`
	`191`	`+ pub unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {`
`192`	`192`	`// Safety: the caller must confirm this invariant`
`193`	`193`	`unsafe {`
`194`	`194`	`core::intrinsics::assume(<T as Sealed>::valid(value));`
`195`		`- Self(mask_impl::Mask::from_int_unchecked(value))`
	`195`	`+ Self(mask_impl::Mask::from_simd_unchecked(value))`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`@@ -207,7 +207,7 @@ where`
`207`	`207`	`pub fn from_simd(value: Simd<T, N>) -> Self {`
`208`	`208`	`assert!(T::valid(value), "all values must be either 0 or -1",);`
`209`	`209`	`// Safety: the validity has been checked`
`210`		`- unsafe { Self::from_int_unchecked(value) }`
	`210`	`+ unsafe { Self::from_simd_unchecked(value) }`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	/// Converts the mask to a vector of integers, where 0 represents `false` and -1
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ where`
`117`	`117`
`118`	`118`	`#[inline]`
`119`	`119`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`120`		`- pub(crate) unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {`
	`120`	`+ pub(crate) unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {`
`121`	`121`	`unsafe { Self(core::intrinsics::simd::simd_bitmask(value), PhantomData) }`
`122`	`122`	`}`
`123`	`123`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ where`
`126`	`126`
`127`	`127`	`#[inline]`
`128`	`128`	`#[must_use = "method returns a new mask and does not mutate the original value"]`
`129`		`- pub(crate) unsafe fn from_int_unchecked(value: Simd<T, N>) -> Self {`
	`129`	`+ pub(crate) unsafe fn from_simd_unchecked(value: Simd<T, N>) -> Self {`
`130`	`130`	`Self(value)`
`131`	`131`	`}`
`132`	`132`
`@@ -180,7 +180,7 @@ where`
`180`	`180`	`};`
`181`	`181`
`182`	`182`	// SAFETY: `mask` only contains `T::TRUE` or `T::FALSE`
`183`		`- unsafe { Self::from_int_unchecked(mask.resize::<N>(T::FALSE)) }`
	`183`	`+ unsafe { Self::from_simd_unchecked(mask.resize::<N>(T::FALSE)) }`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -30,14 +30,14 @@ macro_rules! impl_number {`
`30`	`30`	`fn simd_eq(self, other: Self) -> Self::Mask {`
`31`	`31`	// Safety: `self` is a vector, and the result of the comparison
`32`	`32`	`// is always a valid mask.`
`33`		`- unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_eq(self, other)) }`
	`33`	`+ unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_eq(self, other)) }`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`#[inline]`
`37`	`37`	`fn simd_ne(self, other: Self) -> Self::Mask {`
`38`	`38`	// Safety: `self` is a vector, and the result of the comparison
`39`	`39`	`// is always a valid mask.`
`40`		`- unsafe { Mask::from_int_unchecked(core::intrinsics::simd::simd_ne(self, other)) }`
	`40`	`+ unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ne(self, other)) }`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`	`)*`
`@@ -59,14 +59,14 @@ macro_rules! impl_mask {`
`59`	`59`	`fn simd_eq(self, other: Self) -> Self::Mask {`
`60`	`60`	// Safety: `self` is a vector, and the result of the comparison
`61`	`61`	`// is always a valid mask.`
`62`		`- unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_eq(self.to_simd(), other.to_simd())) }`
	`62`	`+ unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_eq(self.to_simd(), other.to_simd())) }`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`#[inline]`
`66`	`66`	`fn simd_ne(self, other: Self) -> Self::Mask {`
`67`	`67`	// Safety: `self` is a vector, and the result of the comparison
`68`	`68`	`// is always a valid mask.`
`69`		`- unsafe { Self::from_int_unchecked(core::intrinsics::simd::simd_ne(self.to_simd(), other.to_simd())) }`
	`69`	`+ unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_ne(self.to_simd(), other.to_simd())) }`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`)*`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ pub trait Swizzle<const N: usize> {`
`165`	`165`	`LaneCount<M>: SupportedLaneCount,`
`166`	`166`	`{`
`167`	`167`	`// SAFETY: all elements of this mask come from another mask`
`168`		`- unsafe { Mask::from_int_unchecked(Self::swizzle(mask.to_simd())) }`
	`168`	`+ unsafe { Mask::from_simd_unchecked(Self::swizzle(mask.to_simd())) }`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	/// Creates a new mask from the elements of `first` and `second`.
`@@ -181,7 +181,9 @@ pub trait Swizzle<const N: usize> {`
`181`	`181`	`LaneCount<M>: SupportedLaneCount,`
`182`	`182`	`{`
`183`	`183`	`// SAFETY: all elements of this mask come from another mask`
`184`		`- unsafe { Mask::from_int_unchecked(Self::concat_swizzle(first.to_simd(), second.to_simd())) }`
	`184`	`+ unsafe {`
	`185`	`+ Mask::from_simd_unchecked(Self::concat_swizzle(first.to_simd(), second.to_simd()))`
	`186`	`+ }`
`185`	`187`	`}`
`186`	`188`	`}`
`187`	`189`
`@@ -524,7 +526,7 @@ where`
`524`	`526`	`#[must_use = "method returns a new vector and does not mutate the original inputs"]`
`525`	`527`	`pub fn reverse(self) -> Self {`
`526`	`528`	`// Safety: swizzles are safe for masks`
`527`		`- unsafe { Self::from_int_unchecked(self.to_simd().reverse()) }`
	`529`	`+ unsafe { Self::from_simd_unchecked(self.to_simd().reverse()) }`
`528`	`530`	`}`
`529`	`531`
`530`	`532`	/// Rotates the mask such that the first `OFFSET` elements of the slice move to the end
`@@ -534,7 +536,7 @@ where`
`534`	`536`	`#[must_use = "method returns a new vector and does not mutate the original inputs"]`
`535`	`537`	`pub fn rotate_elements_left<const OFFSET: usize>(self) -> Self {`
`536`	`538`	`// Safety: swizzles are safe for masks`
`537`		`- unsafe { Self::from_int_unchecked(self.to_simd().rotate_elements_left::<OFFSET>()) }`
	`539`	`+ unsafe { Self::from_simd_unchecked(self.to_simd().rotate_elements_left::<OFFSET>()) }`
`538`	`540`	`}`
`539`	`541`
`540`	`542`	/// Rotates the mask such that the first `self.len() - OFFSET` elements of the mask move to
`@@ -544,7 +546,7 @@ where`
`544`	`546`	`#[must_use = "method returns a new vector and does not mutate the original inputs"]`
`545`	`547`	`pub fn rotate_elements_right<const OFFSET: usize>(self) -> Self {`
`546`	`548`	`// Safety: swizzles are safe for masks`
`547`		`- unsafe { Self::from_int_unchecked(self.to_simd().rotate_elements_right::<OFFSET>()) }`
	`549`	`+ unsafe { Self::from_simd_unchecked(self.to_simd().rotate_elements_right::<OFFSET>()) }`
`548`	`550`	`}`
`549`	`551`
`550`	`552`	/// Shifts the mask elements to the left by `OFFSET`, filling in with
`@@ -554,7 +556,7 @@ where`
`554`	`556`	`pub fn shift_elements_left<const OFFSET: usize>(self, padding: bool) -> Self {`
`555`	`557`	`// Safety: swizzles are safe for masks`
`556`	`558`	`unsafe {`
`557`		`- Self::from_int_unchecked(self.to_simd().shift_elements_left::<OFFSET>(if padding {`
	`559`	`+ Self::from_simd_unchecked(self.to_simd().shift_elements_left::<OFFSET>(if padding {`
`558`	`560`	`T::TRUE`
`559`	`561`	`} else {`
`560`	`562`	`T::FALSE`
`@@ -569,7 +571,7 @@ where`
`569`	`571`	`pub fn shift_elements_right<const OFFSET: usize>(self, padding: bool) -> Self {`
`570`	`572`	`// Safety: swizzles are safe for masks`
`571`	`573`	`unsafe {`
`572`		`- Self::from_int_unchecked(self.to_simd().shift_elements_right::<OFFSET>(if padding {`
	`574`	`+ Self::from_simd_unchecked(self.to_simd().shift_elements_right::<OFFSET>(if padding {`
`573`	`575`	`T::TRUE`
`574`	`576`	`} else {`
`575`	`577`	`T::FALSE`
`@@ -600,7 +602,7 @@ where`
`600`	`602`	`pub fn interleave(self, other: Self) -> (Self, Self) {`
`601`	`603`	`let (lo, hi) = self.to_simd().interleave(other.to_simd());`
`602`	`604`	`// Safety: swizzles are safe for masks`
`603`		`- unsafe { (Self::from_int_unchecked(lo), Self::from_int_unchecked(hi)) }`
	`605`	`+ unsafe { (Self::from_simd_unchecked(lo), Self::from_simd_unchecked(hi)) }`
`604`	`606`	`}`
`605`	`607`
`606`	`608`	`/// Deinterleave two masks.`
`@@ -631,8 +633,8 @@ where`
`631`	`633`	`// Safety: swizzles are safe for masks`
`632`	`634`	`unsafe {`
`633`	`635`	`(`
`634`		`- Self::from_int_unchecked(even),`
`635`		`- Self::from_int_unchecked(odd),`
	`636`	`+ Self::from_simd_unchecked(even),`
	`637`	`+ Self::from_simd_unchecked(odd),`
`636`	`638`	`)`
`637`	`639`	`}`
`638`	`640`	`}`
`@@ -659,7 +661,7 @@ where`
`659`	`661`	`{`
`660`	`662`	`// Safety: swizzles are safe for masks`
`661`	`663`	`unsafe {`
`662`		`- Mask::<T, M>::from_int_unchecked(self.to_simd().resize::<M>(if value {`
	`664`	`+ Mask::<T, M>::from_simd_unchecked(self.to_simd().resize::<M>(if value {`
`663`	`665`	`T::TRUE`
`664`	`666`	`} else {`
`665`	`667`	`T::FALSE`
`@@ -684,6 +686,6 @@ where`
`684`	`686`	`LaneCount<LEN>: SupportedLaneCount,`
`685`	`687`	`{`
`686`	`688`	`// Safety: swizzles are safe for masks`
`687`		`- unsafe { Mask::<T, LEN>::from_int_unchecked(self.to_simd().extract::<START, LEN>()) }`
	`689`	`+ unsafe { Mask::<T, LEN>::from_simd_unchecked(self.to_simd().extract::<START, LEN>()) }`
`688`	`690`	`}`
`689`	`691`	`}`