Copy past len in Clone for simpler asm

Author: barakugav

src/arrayvec.rs

@@ -1193,7 +1193,40 @@ impl<T, const CAP: usize> Clone for ArrayVec<T, CAP>
     where T: Clone
 {
     fn clone(&self) -> Self {
-        self.iter().cloned().collect()
+        let mut array: ArrayVec<T, CAP> = ArrayVec::new();
+        {
+            let mut guard = ScopeExitGuard {
+                value: &mut array.len,
+                data: 0,
+                f: move |&len, self_len| {
+                    **self_len = len as LenUint;
+                }
+            };
+
+            for i in 0..CAP {
+                if i < self.len() {
+                    // we would prefer assume_init_ref, but its available only since 1.55
+                    let val = unsafe { &*self.xs[i].as_ptr() };
+                    unsafe { array.xs[i].as_mut_ptr().write(val.clone()) };
+                    guard.data += 1;
+                } else {
+                    if mem::size_of::<T>() == 0 || std::mem::needs_drop::<T>() || CAP > 32 {
+                        break;
+                    }
+                    unsafe {
+                        std::ptr::copy_nonoverlapping(self.xs[i].as_ptr(), array.xs[i].as_mut_ptr(), 1)
+                    };
+                }
+            }
+        }
+
+        // This assignment seems redundant as guard.data is already equal to len and will set the
+        // array len on drop, but setting it here explicitly helps the compiler understand it
+        // can just copy the len instead of accumulating it in the guard. This is especially
+        // useful for T::clone() that can not panic.
+        array.len = self.len;
+
+        array
     }
 
     fn clone_from(&mut self, rhs: &Self) {