Revert "use slice rotate methods"

 It's slower than not combining remove/insert.

This reverts commit 9c6d76e.

Author: MoSal

src/vec/mod.rs

@@ -991,13 +991,56 @@ impl<T, LenT: LenType, S: VecStorage<T> + ?Sized> VecInner<T, LenT, S> {
         assert!(remove_index < length);
         assert!(insert_index < length);
 
+        // SAFETY: `remove_index < length` assertion guarantees the pointer is within bounds.
+        let to_remove = unsafe { ptr::read(self.as_ptr().add(remove_index)) };
+
         match remove_index.cmp(&insert_index) {
             Ordering::Equal => (),
-            Ordering::Less => self[remove_index..=insert_index].rotate_left(1),
-            Ordering::Greater => self[insert_index..=remove_index].rotate_right(1),
+            Ordering::Less => {
+                // SAFETY: `remove_index < length` assertion guarantees the pointer is within
+                // bounds.
+                let remove_at = unsafe { self.as_mut_ptr().add(remove_index) };
+
+                // SAFETY:
+                // Copies from
+                //  (remove_index + 1)..(insert_index + 1)
+                // to
+                //  remove_index..insert_index
+                //
+                // remove_index < insert_index (this match)
+                // remove_index + 1 < insert_index + 1 (can't saturate because <= length)
+                // remove_index + 1 <= insert_index < length
+                // insert_index + 1 <= length
+                //
+                // If `remove_index == 0`, and `insert_index + 1 ==  length`, then we copy from
+                // 1..length to 0..(length-1).
+                unsafe { ptr::copy(remove_at.add(1), remove_at, insert_index - remove_index) };
+            }
+            Ordering::Greater => {
+                // SAFETY: `insert_index < length` assertion guarantees the pointer is within
+                // bounds.
+                let insert_at = unsafe { self.as_mut_ptr().add(insert_index) };
+
+                // SAFETY:
+                // Copies from
+                //  insert_index..remove_index
+                // to
+                //  (insert_index + 1)..(remove_index + 1)
+                //
+                // insert_index < remove_index (this match)
+                // insert_index + 1 < remove_index + 1 (can't saturate because <= length)
+                // insert_index + 1 <= remove_index < length
+                // remove_index + 1 <= length
+                //
+                // If `insert_index == 0`, and `remove_index + 1 ==  length`, then we copy from
+                // 0..(length-1) to 1..(length).
+                unsafe { ptr::copy(insert_at, insert_at.add(1), remove_index - insert_index) };
+            }
         }
 
-        mem::replace(&mut self[insert_index], element)
+        // SAFETY: `insert_index < length` assertion guarantees the pointer is within bounds.
+        unsafe { ptr::write(self.as_mut_ptr().add(insert_index), element) };
+        to_remove
     }
 
     /// Returns true if the vec is full