Micro-optimize push() and insert().

This helps with some micro-benchmarks in Firefox where we end up pushing
thousands of elements to a SmallVec.

See https://treeherder.mozilla.org/perfherder/comparesubtest?originalProject=try&newProject=try&newRevision=78b672e152c65fbacd3f0bccc4bd069b177addd6&originalSignature=4765498&newSignature=4765498&framework=1&application=firefox&originalRevision=6f0164143af00325c9f15e7c6387d8f9c7993daf&page=1&showOnlyConfident=1

Author: emilio

src/lib.rs

@@ -1120,10 +1120,8 @@ impl<A: Array> SmallVec<A> {
         unsafe {
             let (mut ptr, mut len, cap) = self.triple_mut();
             if *len == cap {
-                self.reserve(1);
-                let (heap_ptr, heap_len) = self.data.heap_mut();
-                ptr = heap_ptr;
-                len = heap_len;
+                self.reserve_one_unchecked();
+                (ptr, len) = self.data.heap_mut();
             }
             ptr::write(ptr.as_ptr().add(*len), value);
             *len += 1;
@@ -1225,13 +1223,23 @@ impl<A: Array> SmallVec<A> {
         infallible(self.try_reserve(additional))
     }
 
+    /// Internal method used to grow in push() and insert(), where we know already we have to grow.
+    #[cold]
+    fn reserve_one_unchecked(&mut self) {
+        debug_assert_eq!(self.len(), self.capacity());
+        let new_cap = self.len()
+            .checked_add(1)
+            .and_then(usize::checked_next_power_of_two)
+            .expect("capacity overflow");
+        infallible(self.try_grow(new_cap))
+    }
+
     /// Reserve capacity for `additional` more elements to be inserted.
     ///
     /// May reserve more space to avoid frequent reallocations.
     pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
-        // prefer triple_mut() even if triple() would work
-        // so that the optimizer removes duplicated calls to it
-        // from callers like insert()
+        // prefer triple_mut() even if triple() would work so that the optimizer removes duplicated
+        // calls to it from callers.
         let (_, &mut len, cap) = self.triple_mut();
         if cap - len >= additional {
             return Ok(());
@@ -1357,10 +1365,12 @@ impl<A: Array> SmallVec<A> {
     ///
     /// Panics if `index > len`.
     pub fn insert(&mut self, index: usize, element: A::Item) {
-        self.reserve(1);
-
         unsafe {
-            let (ptr, len_ptr, _) = self.triple_mut();
+            let (mut ptr, mut len_ptr, cap) = self.triple_mut();
+            if *len_ptr == cap {
+                self.reserve_one_unchecked();
+                (ptr, len_ptr) = self.data.heap_mut();
+            }
             let mut ptr = ptr.as_ptr();
             let len = *len_ptr;
             ptr = ptr.add(index);