Auto merge of #147353 - the8472:nondrop-array-iter, r=<try>

only call polymorphic array iter drop machinery when the type requires it

Author: rust-bors[bot]

library/core/src/array/iter.rs

@@ -2,9 +2,9 @@
 
 use crate::intrinsics::transmute_unchecked;
 use crate::iter::{FusedIterator, TrustedLen, TrustedRandomAccessNoCoerce};
-use crate::mem::MaybeUninit;
+use crate::mem::{ManuallyDrop, MaybeUninit};
 use crate::num::NonZero;
-use crate::ops::{IndexRange, Range, Try};
+use crate::ops::{Deref as _, DerefMut as _, IndexRange, Range, Try};
 use crate::{fmt, ptr};
 
 mod iter_inner;
@@ -18,17 +18,17 @@ type InnerUnsized<T> = iter_inner::PolymorphicIter<[MaybeUninit<T>]>;
 #[rustc_diagnostic_item = "ArrayIntoIter"]
 #[derive(Clone)]
 pub struct IntoIter<T, const N: usize> {
-    inner: InnerSized<T, N>,
+    inner: ManuallyDrop<InnerSized<T, N>>,
 }
 
 impl<T, const N: usize> IntoIter<T, N> {
     #[inline]
     fn unsize(&self) -> &InnerUnsized<T> {
-        &self.inner
+        self.inner.deref()
     }
     #[inline]
     fn unsize_mut(&mut self) -> &mut InnerUnsized<T> {
-        &mut self.inner
+        self.inner.deref_mut()
     }
 }
 
@@ -69,7 +69,7 @@ impl<T, const N: usize> IntoIterator for [T; N] {
         // SAFETY: The original array was entirely initialized and the the alive
         // range we're passing here represents that fact.
         let inner = unsafe { InnerSized::new_unchecked(IndexRange::zero_to(N), data) };
-        IntoIter { inner }
+        IntoIter { inner: ManuallyDrop::new(inner) }
     }
 }
 
@@ -146,7 +146,7 @@ impl<T, const N: usize> IntoIter<T, N> {
         let alive = unsafe { IndexRange::new_unchecked(initialized.start, initialized.end) };
         // SAFETY: one of our safety condition is that these items are initialized.
         let inner = unsafe { InnerSized::new_unchecked(alive, buffer) };
-        IntoIter { inner }
+        IntoIter { inner: ManuallyDrop::new(inner) }
     }
 
     /// Creates an iterator over `T` which returns no elements.
@@ -205,7 +205,7 @@ impl<T, const N: usize> IntoIter<T, N> {
     #[inline]
     pub const fn empty() -> Self {
         let inner = InnerSized::empty();
-        IntoIter { inner }
+        IntoIter { inner: ManuallyDrop::new(inner) }
     }
 
     /// Returns an immutable slice of all elements that have not been yielded
@@ -323,8 +323,15 @@ impl<T, const N: usize> DoubleEndedIterator for IntoIter<T, N> {
 impl<T, const N: usize> Drop for IntoIter<T, N> {
     #[inline]
     fn drop(&mut self) {
-        // `inner` now handles this, but it'd technically be a breaking change
-        // to remove this `impl`, even though it's useless.
+        let drop: Option<unsafe fn(&mut _)> =
+            const { if crate::mem::needs_drop::<T>() { Some(ManuallyDrop::drop) } else { None } };
+
+        if let Some(drop) = drop {
+            // SAFETY: This is the only place where we drop this field.
+            unsafe {
+                drop(&mut self.inner);
+            }
+        }
     }
 }