Use internal iteration in Vec::extend_desugared()

Because LLVM is unable to optimize well external iteration with some iterator kinds (e.g. `chain()`).

To do that I had to hoist the `size_hint()` call to the beginning of the loop (since I no longer have access to the iterator inside the loop), which might slightly pessimize certain iterators that are able to give more accurate size bounds during iteration (e.g. `flatten()`). However, the effect should not be big, and also, common iterators like these also suffer from the external iteration optimizibility problem (e.g. `flatten()`).

Author: ChayimFriedman2

library/alloc/src/vec/mod.rs

@@ -3780,19 +3780,20 @@ impl<T, A: Allocator> Vec<T, A> {
     // they have no further optimizations to apply
     #[cfg(not(no_global_oom_handling))]
     #[track_caller]
-    fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
+    fn extend_desugared<I: Iterator<Item = T>>(&mut self, iterator: I) {
         // This is the case for a general iterator.
         //
         // This function should be the moral equivalent of:
         //
         //      for item in iterator {
         //          self.push(item);
         //      }
-        while let Some(element) = iterator.next() {
+        let (lower, _) = iterator.size_hint();
+        let initial_len = self.len();
+        iterator.for_each(move |element| {
             let len = self.len();
             if len == self.capacity() {
-                let (lower, _) = iterator.size_hint();
-                self.reserve(lower.saturating_add(1));
+                self.reserve(lower.saturating_sub(len - initial_len).saturating_add(1));
             }
             unsafe {
                 ptr::write(self.as_mut_ptr().add(len), element);
@@ -3801,7 +3802,7 @@ impl<T, A: Allocator> Vec<T, A> {
                 // NB can't overflow since we would have had to alloc the address space
                 self.set_len(len + 1);
             }
-        }
+        });
     }
 
     // specific extend for `TrustedLen` iterators, called both by the specializations