use align_to to reduce unsafety

Author: folkertdev

zlib-rs/src/adler32/generic.rs

@@ -116,34 +116,8 @@ pub(crate) fn adler32_len_64(mut adler: u32, buf: &[u8], mut sum2: u32) -> u32 {
 
 // FIXME use the method on slices once available.
 fn slice_as_chunks<T, const N: usize>(slice: &[T]) -> (&[[T; N]], &[T]) {
-    assert!(N != 0, "chunk size must be non-zero");
-    let len_rounded_down = slice.len() / N * N;
-    // SAFETY: The rounded-down value is always the same or smaller than the
-    // original length, and thus must be in-bounds of the slice.
-    let (multiple_of_n, remainder) = unsafe { slice_split_at_unchecked(slice, len_rounded_down) };
-    // SAFETY: We already panicked for zero, and ensured by construction
-    // that the length of the subslice is a multiple of N.
-    let array_slice = unsafe { slice_as_chunks_unchecked(multiple_of_n) };
-    (array_slice, remainder)
-}
-
-unsafe fn slice_as_chunks_unchecked<T, const N: usize>(slice: &[T]) -> &[[T; N]] {
-    // SAFETY: Caller must guarantee that `N` is nonzero and exactly divides the slice length
-    let new_len = slice.len() / N;
-    // SAFETY: We cast a slice of `new_len * N` elements into
-    // a slice of `new_len` many `N` elements chunks.
-    unsafe { core::slice::from_raw_parts(slice.as_ptr().cast(), new_len) }
-}
-
-pub unsafe fn slice_split_at_unchecked<T>(slice: &[T], mid: usize) -> (&[T], &[T]) {
-    let len = slice.len();
-    let ptr = slice.as_ptr();
-
-    // SAFETY: Caller has to check that `0 <= mid <= self.len()`
-    unsafe {
-        (
-            core::slice::from_raw_parts(ptr, mid),
-            core::slice::from_raw_parts(ptr.add(mid), len - mid),
-        )
-    }
+    // SAFETY: T can be trivially transmuted to T.
+    let (before, middle, after) = unsafe { slice.align_to() };
+    debug_assert!(before.is_empty());
+    (middle, after)
 }