remove FromIterator impl

Author: lcnr

library/core/src/array/mod.rs

@@ -11,7 +11,6 @@ use crate::cmp::Ordering;
 use crate::convert::{Infallible, TryFrom};
 use crate::fmt;
 use crate::hash::{self, Hash};
-use crate::iter::FromIterator;
 use crate::marker::Unsize;
 use crate::mem::MaybeUninit;
 use crate::slice::{Iter, IterMut};
@@ -176,7 +175,10 @@ impl<T: fmt::Debug, const N: usize> fmt::Debug for [T; N] {
     }
 }
 
-/// Return Error of the FromIterator impl for array
+/// The error returned by the `FromIterator` implementation of
+/// arrays once these are implemented.
+///
+/// Until then `FillError::new().fill(iter)` can be used instead.
 #[unstable(feature = "array_from_iter_impl", issue = "none")]
 pub struct FillError<T, const N: usize> {
     array: [MaybeUninit<T>; N],
@@ -194,27 +196,26 @@ impl<T, const N: usize> fmt::Display for FillError<T, N> {
 }
 
 #[unstable(feature = "array_from_iter_impl", issue = "none")]
-impl<T: fmt::Debug, const N: usize> fmt::Debug for FillError<T, N> {
+impl<T, const N: usize> fmt::Debug for FillError<T, N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FillError")
-            .field("array", &self.as_slice())
-            .field("len", &self.len())
-            .finish()
+        fmt::Display::fmt(self, f)
     }
 }
 
 #[unstable(feature = "array_from_iter_impl", issue = "none")]
 impl<T, const N: usize> Drop for FillError<T, N> {
     fn drop(&mut self) {
         // SAFETY: This is safe: `as_mut_slice` returns exactly the sub-slice
-        // of elements that have been initialized and need to be droped
+        // of elements that have been initialized and need to be dropped.
         unsafe { crate::ptr::drop_in_place(self.as_mut_slice()) }
     }
 }
 
 #[unstable(feature = "array_from_iter_impl", issue = "none")]
 impl<T, const N: usize> FillError<T, N> {
-    fn new() -> Self {
+    /// Creates a new empty `FillError` which can be used
+    /// to build `[T; N]` from an iterator.
+    pub fn new() -> Self {
         Self { array: MaybeUninit::uninit_array(), len: 0 }
     }
 
@@ -242,8 +243,8 @@ impl<T, const N: usize> FillError<T, N> {
         for i in self.len..N {
             if let Some(value) = iter.next() {
                 self.array[i].write(value);
+                self.len = i + 1;
             } else {
-                self.len = i;
                 return Err(self);
             }
         }
@@ -265,14 +266,6 @@ impl<T, const N: usize> FillError<T, N> {
     }
 }
 
-#[unstable(feature = "array_from_iter_impl", issue = "none")]
-impl<T, const N: usize> FromIterator<T> for Result<[T; N], FillError<T, N>> {
-    #[inline]
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        FillError::<T, N>::new().fill(iter)
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T, const N: usize> IntoIterator for &'a [T; N] {
     type Item = &'a T;
@@ -484,42 +477,11 @@ impl<T, const N: usize> [T; N] {
     /// assert_eq!(y, [6, 9, 3, 3]);
     /// ```
     #[unstable(feature = "array_map", issue = "75243")]
-    pub fn map<F, U>(self, mut f: F) -> [U; N]
+    pub fn map<F, U>(self, f: F) -> [U; N]
     where
         F: FnMut(T) -> U,
     {
-        use crate::mem::MaybeUninit;
-        struct Guard<T, const N: usize> {
-            dst: *mut T,
-            initialized: usize,
-        }
-
-        impl<T, const N: usize> Drop for Guard<T, N> {
-            fn drop(&mut self) {
-                debug_assert!(self.initialized <= N);
-
-                let initialized_part =
-                    crate::ptr::slice_from_raw_parts_mut(self.dst, self.initialized);
-                // SAFETY: this raw slice will contain only initialized objects
-                // that's why, it is allowed to drop it.
-                unsafe {
-                    crate::ptr::drop_in_place(initialized_part);
-                }
-            }
-        }
-        let mut dst = MaybeUninit::uninit_array::<N>();
-        let mut guard: Guard<U, N> =
-            Guard { dst: MaybeUninit::slice_as_mut_ptr(&mut dst), initialized: 0 };
-        for (src, dst) in IntoIter::new(self).zip(&mut dst) {
-            dst.write(f(src));
-            guard.initialized += 1;
-        }
-        // FIXME: Convert to crate::mem::transmute once it works with generics.
-        // unsafe { crate::mem::transmute::<[MaybeUninit<U>; N], [U; N]>(dst) }
-        crate::mem::forget(guard);
-        // SAFETY: At this point we've properly initialized the whole array
-        // and we just need to cast it to the correct type.
-        unsafe { crate::mem::transmute_copy::<_, [U; N]>(&dst) }
+        FillError::new().fill(IntoIter::new(self).map(f)).unwrap()
     }
 
     /// Returns a slice containing the entire array. Equivalent to `&s[..]`.

library/core/tests/array.rs

@@ -1,4 +1,4 @@
-use core::array::{FixedSizeArray, IntoIter};
+use core::array::{FillError, FixedSizeArray, IntoIter};
 use core::convert::TryFrom;
 
 #[test]
@@ -334,37 +334,37 @@ fn array_map_drop_safety() {
 #[test]
 fn array_collects() {
     let v = vec![1, 2, 3, 4, 5];
-    let a: [i32; 5] = v
-        .clone()
-        .into_iter()
-        .collect::<Result<[i32; 5], core::array::FillError<i32, 5>>>()
-        .unwrap();
+    let a: [i32; 5] = FillError::new().fill(v.clone()).unwrap();
 
     assert_eq!(v[..], a[..]);
 }
 
 #[test]
-fn array_collect_drop_on_panic() {
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use std::sync::Arc;
-
-    #[derive(Clone)]
-    struct Foo(Arc<AtomicUsize>);
-
-    // count the number of eleemts that got dropped
-    impl Drop for Foo {
+#[should_panic(expected = "test succeeded")]
+fn array_collect_drop_safety() {
+    use core::sync::atomic::AtomicUsize;
+    use core::sync::atomic::Ordering;
+    static DROPPED: AtomicUsize = AtomicUsize::new(0);
+    struct DropCounter;
+    impl Drop for DropCounter {
         fn drop(&mut self) {
-            self.0.fetch_add(1, Ordering::SeqCst);
+            DROPPED.fetch_add(1, Ordering::SeqCst);
         }
     }
 
-    let i = Arc::new(AtomicUsize::new(0));
-    let foo = Foo(i.clone());
-
-    std::panic::catch_unwind(move || {
-        let _a: [Foo; 5] = from_iter(vec![foo.clone(), foo.clone(), foo.clone(), foo]);
-    })
-    .unwrap_err();
-
-    assert_eq!(i.load(Ordering::SeqCst), 4);
+    let num_to_create = 5;
+    let success = std::panic::catch_unwind(|| {
+        let items = [0; 10];
+        let mut nth = 0;
+        FillError::<DropCounter, 10>::new()
+            .fill(items.iter().map(|_| {
+                assert!(nth < num_to_create);
+                nth += 1;
+                DropCounter
+            }))
+            .unwrap()
+    });
+    assert!(success.is_err());
+    assert_eq!(DROPPED.load(Ordering::SeqCst), num_to_create);
+    panic!("test succeeded")
 }