Implement fill_via_chunks without using zerocopy or unsafe.

Reduce the use of `zerocopy` as a step towards eliminating the
dependency.

Author: briansmith

rand_core/src/impls.rs

@@ -19,7 +19,6 @@
 
 use crate::RngCore;
 use core::cmp::min;
-use zerocopy::{Immutable, IntoBytes};
 
 /// Implement `next_u64` via `next_u32`, little-endian order.
 pub fn next_u64_via_u32<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
@@ -53,17 +52,22 @@ pub fn fill_bytes_via_next<R: RngCore + ?Sized>(rng: &mut R, dest: &mut [u8]) {
     }
 }
 
-trait Observable: IntoBytes + Immutable + Copy {
-    fn to_le(self) -> Self;
+trait Observable: Copy {
+    type Bytes: Sized + IntoIterator<Item = u8>;
+    fn to_le_bytes(self) -> Self::Bytes;
 }
 impl Observable for u32 {
-    fn to_le(self) -> Self {
-        self.to_le()
+    type Bytes = [u8; 4];
+
+    fn to_le_bytes(self) -> Self::Bytes {
+        Self::to_le_bytes(self)
     }
 }
 impl Observable for u64 {
-    fn to_le(self) -> Self {
-        self.to_le()
+    type Bytes = [u8; 8];
+
+    fn to_le_bytes(self) -> Self::Bytes {
+        Self::to_le_bytes(self)
     }
 }
 
@@ -77,16 +81,10 @@ fn fill_via_chunks<T: Observable>(src: &mut [T], dest: &mut [u8]) -> (usize, usi
     let byte_len = min(core::mem::size_of_val(src), dest.len());
     let num_chunks = (byte_len + size - 1) / size;
 
-    // Byte-swap for portability of results. This must happen before copying
-    // since the size of dest is not guaranteed to be a multiple of T or to be
-    // sufficiently aligned.
-    if cfg!(target_endian = "big") {
-        for x in &mut src[..num_chunks] {
-            *x = x.to_le();
-        }
-    }
-
-    dest[..byte_len].copy_from_slice(&<[T]>::as_bytes(&src[..num_chunks])[..byte_len]);
+    // Always using little endian for portability of results.
+    dest.into_iter()
+        .zip(src.iter().map(|t| t.to_le_bytes()).flatten())
+        .for_each(|(dest, src)| *dest = src);
 
     (num_chunks, byte_len)
 }