Explicitly forget the zero remaining elements in vec::IntoIter::fold().

This seems to help LLVM notice that dropping the elements in the
destructor is not necessary.

Author: kpreid

library/alloc/src/vec/into_iter.rs

@@ -329,6 +329,12 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
                 accum = f(accum, tmp);
             }
         }
+
+        // There are in fact no remaining elements to forget, but by doing this we can avoid
+        // potentially generating a needless loop to drop the elements that cannot exist at
+        // this point.
+        self.forget_remaining_elements();
+
         accum
     }
 

tests/codegen-llvm/vec-into-iter-drops.rs

@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=3
+// Test that we can avoid generating an element dropping loop when `vec::IntoIter` is consumed.
+#![crate_type = "lib"]
+
+use std::vec;
+
+struct Bomb;
+impl Drop for Bomb {
+    #[inline]
+    fn drop(&mut self) {
+        panic!("dropped")
+    }
+}
+
+/// This test case from https://users.rust-lang.org/t/unnecessary-drop-in-place-emitted-for-a-fully-consumed-intoiter/135119
+/// It should not emit any `drop::<Bomb>()` because every element is forgotten.
+// CHECK-LABEL: @vec_into_iter_drop_option
+#[no_mangle]
+pub fn vec_into_iter_drop_option(v: vec::Vec<(usize, Option<Bomb>)>) -> usize {
+    // CHECK-NOT: panic
+    // CHECK-NOT: Bomb$u20$as$u20$core..ops..drop..Drop
+    let mut last = 0;
+    v.into_iter().for_each(|(x, bomb)| {
+        last = x;
+        std::mem::forget(bomb);
+    });
+    last
+}