Swap body of array::IntoIter::new and IntoIterator::new.

Author: m-ou-se

library/core/src/array/iter.rs

@@ -34,11 +34,23 @@ pub struct IntoIter<T, const N: usize> {
     alive: Range<usize>,
 }
 
-impl<T, const N: usize> IntoIter<T, N> {
-    /// Creates a new iterator over the given `array`.
-    #[stable(feature = "array_value_iter", since = "1.51.0")]
-    #[rustc_deprecated(since = "1.57.0", reason = "use `IntoIterator::into_iter` instead")]
-    pub fn new(array: [T; N]) -> Self {
+// Note: the `#[rustc_skip_array_during_method_dispatch]` on `trait IntoIterator`
+// hides this implementation from explicit `.into_iter()` calls on editions < 2021,
+// so those calls will still resolve to the slice implementation, by reference.
+#[stable(feature = "array_into_iter_impl", since = "1.53.0")]
+impl<T, const N: usize> IntoIterator for [T; N] {
+    type Item = T;
+    type IntoIter = IntoIter<T, N>;
+
+    /// Creates a consuming iterator, that is, one that moves each value out of
+    /// the array (from start to end). The array cannot be used after calling
+    /// this unless `T` implements `Copy`, so the whole array is copied.
+    ///
+    /// Arrays have special behavior when calling `.into_iter()` prior to the
+    /// 2021 edition -- see the [array] Editions section for more information.
+    ///
+    /// [array]: prim@array
+    fn into_iter(self) -> Self::IntoIter {
         // SAFETY: The transmute here is actually safe. The docs of `MaybeUninit`
         // promise:
         //
@@ -57,11 +69,20 @@ impl<T, const N: usize> IntoIter<T, N> {
         // Until then, we can use `mem::transmute_copy` to create a bitwise copy
         // as a different type, then forget `array` so that it is not dropped.
         unsafe {
-            let iter = Self { data: mem::transmute_copy(&array), alive: 0..N };
-            mem::forget(array);
+            let iter = IntoIter { data: mem::transmute_copy(&self), alive: 0..N };
+            mem::forget(self);
             iter
         }
     }
+}
+
+impl<T, const N: usize> IntoIter<T, N> {
+    /// Creates a new iterator over the given `array`.
+    #[stable(feature = "array_value_iter", since = "1.51.0")]
+    #[rustc_deprecated(since = "1.57.0", reason = "use `IntoIterator::into_iter` instead")]
+    pub fn new(array: [T; N]) -> Self {
+        IntoIterator::into_iter(array)
+    }
 
     /// Returns an immutable slice of all elements that have not been yielded
     /// yet.

library/core/src/array/mod.rs

@@ -243,27 +243,6 @@ impl<T: fmt::Debug, const N: usize> fmt::Debug for [T; N] {
     }
 }
 
-// Note: the `#[rustc_skip_array_during_method_dispatch]` on `trait IntoIterator`
-// hides this implementation from explicit `.into_iter()` calls on editions < 2021,
-// so those calls will still resolve to the slice implementation, by reference.
-#[stable(feature = "array_into_iter_impl", since = "1.53.0")]
-impl<T, const N: usize> IntoIterator for [T; N] {
-    type Item = T;
-    type IntoIter = IntoIter<T, N>;
-
-    /// Creates a consuming iterator, that is, one that moves each value out of
-    /// the array (from start to end). The array cannot be used after calling
-    /// this unless `T` implements `Copy`, so the whole array is copied.
-    ///
-    /// Arrays have special behavior when calling `.into_iter()` prior to the
-    /// 2021 edition -- see the [array] Editions section for more information.
-    ///
-    /// [array]: prim@array
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self)
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T, const N: usize> IntoIterator for &'a [T; N] {
     type Item = &'a T;