Use the IntoIterator array impl in several places across library/*

I surely missed quite a few spots, but I think I got most of them. And
it's not like changing this is particularly important.

Author: LukasKalbertodt

library/alloc/src/collections/btree/map/tests.rs

@@ -1289,7 +1289,7 @@ fn test_borrow() {
 fn test_entry() {
     let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
 
-    let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
+    let mut map: BTreeMap<_, _> = xs.into_iter().collect();
 
     // Existing key (insert)
     match map.entry(1) {

library/alloc/src/collections/btree/set.rs

@@ -473,7 +473,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
     /// assert_eq!(set.contains(&1), true);
     /// assert_eq!(set.contains(&4), false);
     /// ```
@@ -497,7 +497,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
     /// assert_eq!(set.get(&2), Some(&2));
     /// assert_eq!(set.get(&4), None);
     /// ```
@@ -518,7 +518,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let a: BTreeSet<_> = [1, 2, 3].into_iter().collect();
     /// let mut b = BTreeSet::new();
     ///
     /// assert_eq!(a.is_disjoint(&b), true);
@@ -543,7 +543,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let sup: BTreeSet<_> = [1, 2, 3].into_iter().collect();
     /// let mut set = BTreeSet::new();
     ///
     /// assert_eq!(set.is_subset(&sup), true);
@@ -619,7 +619,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
+    /// let sub: BTreeSet<_> = [1, 2].into_iter().collect();
     /// let mut set = BTreeSet::new();
     ///
     /// assert_eq!(set.is_superset(&sub), false);
@@ -831,7 +831,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let mut set: BTreeSet<_> = [1, 2, 3].into_iter().collect();
     /// assert_eq!(set.take(&2), Some(2));
     /// assert_eq!(set.take(&2), None);
     /// ```
@@ -985,7 +985,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
+    /// let set: BTreeSet<usize> = [1, 2, 3].into_iter().collect();
     /// let mut set_iter = set.iter();
     /// assert_eq!(set_iter.next(), Some(&1));
     /// assert_eq!(set_iter.next(), Some(&2));
@@ -998,7 +998,7 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
+    /// let set: BTreeSet<usize> = [3, 1, 2].into_iter().collect();
     /// let mut set_iter = set.iter();
     /// assert_eq!(set_iter.next(), Some(&1));
     /// assert_eq!(set_iter.next(), Some(&2));
@@ -1069,7 +1069,7 @@ impl<T> IntoIterator for BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
+    /// let set: BTreeSet<usize> = [1, 2, 3, 4].into_iter().collect();
     ///
     /// let v: Vec<_> = set.into_iter().collect();
     /// assert_eq!(v, [1, 2, 3, 4]);

library/alloc/src/collections/btree/set/tests.rs

@@ -113,8 +113,8 @@ fn test_intersection() {
 
 #[test]
 fn test_intersection_size_hint() {
-    let x: BTreeSet<i32> = [3, 4].iter().copied().collect();
-    let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
+    let x: BTreeSet<i32> = [3, 4].into_iter().collect();
+    let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
     let mut iter = x.intersection(&y);
     assert_eq!(iter.size_hint(), (1, Some(1)));
     assert_eq!(iter.next(), Some(&3));
@@ -165,7 +165,7 @@ fn test_difference() {
 
 #[test]
 fn test_difference_size_hint() {
-    let s246: BTreeSet<i32> = [2, 4, 6].iter().copied().collect();
+    let s246: BTreeSet<i32> = [2, 4, 6].into_iter().collect();
     let s23456: BTreeSet<i32> = (2..=6).collect();
     let mut iter = s246.difference(&s23456);
     assert_eq!(iter.size_hint(), (0, Some(3)));
@@ -241,8 +241,8 @@ fn test_symmetric_difference() {
 
 #[test]
 fn test_symmetric_difference_size_hint() {
-    let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
-    let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
+    let x: BTreeSet<i32> = [2, 4].into_iter().collect();
+    let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
     let mut iter = x.symmetric_difference(&y);
     assert_eq!(iter.size_hint(), (0, Some(5)));
     assert_eq!(iter.next(), Some(&1));
@@ -269,8 +269,8 @@ fn test_union() {
 
 #[test]
 fn test_union_size_hint() {
-    let x: BTreeSet<i32> = [2, 4].iter().copied().collect();
-    let y: BTreeSet<i32> = [1, 2, 3].iter().copied().collect();
+    let x: BTreeSet<i32> = [2, 4].into_iter().collect();
+    let y: BTreeSet<i32> = [1, 2, 3].into_iter().collect();
     let mut iter = x.union(&y);
     assert_eq!(iter.size_hint(), (3, Some(5)));
     assert_eq!(iter.next(), Some(&1));
@@ -338,8 +338,8 @@ fn test_retain() {
 
 #[test]
 fn test_drain_filter() {
-    let mut x: BTreeSet<_> = [1].iter().copied().collect();
-    let mut y: BTreeSet<_> = [1].iter().copied().collect();
+    let mut x: BTreeSet<_> = [1].into_iter().collect();
+    let mut y: BTreeSet<_> = [1].into_iter().collect();
 
     x.drain_filter(|_| true);
     y.drain_filter(|_| false);
@@ -423,7 +423,7 @@ fn test_zip() {
 fn test_from_iter() {
     let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
 
-    let set: BTreeSet<_> = xs.iter().cloned().collect();
+    let set: BTreeSet<_> = xs.into_iter().collect();
 
     for x in &xs {
         assert!(set.contains(x));

library/alloc/src/vec/mod.rs

@@ -887,7 +887,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// ```
     /// let mut vec = Vec::with_capacity(10);
-    /// vec.extend([1, 2, 3].iter().cloned());
+    /// vec.extend([1, 2, 3]);
     /// assert_eq!(vec.capacity(), 10);
     /// vec.shrink_to_fit();
     /// assert!(vec.capacity() >= 3);
@@ -915,7 +915,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     /// #![feature(shrink_to)]
     /// let mut vec = Vec::with_capacity(10);
-    /// vec.extend([1, 2, 3].iter().cloned());
+    /// vec.extend([1, 2, 3]);
     /// assert_eq!(vec.capacity(), 10);
     /// vec.shrink_to(4);
     /// assert!(vec.capacity() >= 4);
@@ -948,7 +948,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// ```
     /// let mut vec = Vec::with_capacity(10);
-    /// vec.extend([1, 2, 3].iter().cloned());
+    /// vec.extend([1, 2, 3]);
     ///
     /// assert_eq!(vec.capacity(), 10);
     /// let slice = vec.into_boxed_slice();
@@ -2533,7 +2533,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     /// let mut v = vec![1, 2, 3];
     /// let new = [7, 8];
-    /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
+    /// let u: Vec<_> = v.splice(..2, new.into_iter()).collect();
     /// assert_eq!(v, &[7, 8, 3]);
     /// assert_eq!(u, &[1, 2]);
     /// ```

library/alloc/tests/binary_heap.rs

@@ -264,7 +264,7 @@ fn test_empty_peek_mut() {
 fn test_from_iter() {
     let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
 
-    let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
+    let mut q: BinaryHeap<_> = xs.iter().rev().copied().collect();
 
     for &x in &xs {
         assert_eq!(q.pop().unwrap(), x);
@@ -273,7 +273,7 @@ fn test_from_iter() {
 
 #[test]
 fn test_drain() {
-    let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+    let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].into_iter().collect();
 
     assert_eq!(q.drain().take(5).count(), 5);
 
@@ -282,7 +282,7 @@ fn test_drain() {
 
 #[test]
 fn test_drain_sorted() {
-    let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+    let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].into_iter().collect();
 
     assert_eq!(q.drain_sorted().take(5).collect::<Vec<_>>(), vec![9, 8, 7, 6, 5]);
 

library/alloc/tests/linked_list.rs

@@ -304,7 +304,7 @@ fn test_show() {
     let list: LinkedList<_> = (0..10).collect();
     assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
-    let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
+    let list: LinkedList<_> = vec!["just", "one", "test", "more"].into_iter().collect();
     assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]");
 }
 

library/alloc/tests/string.rs

@@ -154,8 +154,7 @@ fn test_from_utf16() {
         (String::from("\u{20000}"), vec![0xD840, 0xDC00]),
     ];
 
-    for p in &pairs {
-        let (s, u) = (*p).clone();
+    for (s, u) in pairs {
         let s_as_utf16 = s.encode_utf16().collect::<Vec<u16>>();
         let u_as_string = String::from_utf16(&u).unwrap();
 

library/alloc/tests/vec.rs

@@ -458,7 +458,7 @@ fn test_partition() {
 fn test_zip_unzip() {
     let z1 = vec![(1, 4), (2, 5), (3, 6)];
 
-    let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
+    let (left, right): (Vec<_>, Vec<_>) = z1.into_iter().unzip();
 
     assert_eq!((1, 4), (left[0], right[0]));
     assert_eq!((2, 5), (left[1], right[1]));
@@ -793,7 +793,7 @@ fn test_drain_leak() {
 fn test_splice() {
     let mut v = vec![1, 2, 3, 4, 5];
     let a = [10, 11, 12];
-    v.splice(2..4, a.iter().cloned());
+    v.splice(2..4, a.into_iter());
     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
     v.splice(1..3, Some(20));
     assert_eq!(v, &[1, 20, 11, 12, 5]);
@@ -803,7 +803,7 @@ fn test_splice() {
 fn test_splice_inclusive_range() {
     let mut v = vec![1, 2, 3, 4, 5];
     let a = [10, 11, 12];
-    let t1: Vec<_> = v.splice(2..=3, a.iter().cloned()).collect();
+    let t1: Vec<_> = v.splice(2..=3, a.into_iter()).collect();
     assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
     assert_eq!(t1, &[3, 4]);
     let t2: Vec<_> = v.splice(1..=2, Some(20)).collect();
@@ -816,22 +816,22 @@ fn test_splice_inclusive_range() {
 fn test_splice_out_of_bounds() {
     let mut v = vec![1, 2, 3, 4, 5];
     let a = [10, 11, 12];
-    v.splice(5..6, a.iter().cloned());
+    v.splice(5..6, a.into_iter());
 }
 
 #[test]
 #[should_panic]
 fn test_splice_inclusive_out_of_bounds() {
     let mut v = vec![1, 2, 3, 4, 5];
     let a = [10, 11, 12];
-    v.splice(5..=5, a.iter().cloned());
+    v.splice(5..=5, a.into_iter());
 }
 
 #[test]
 fn test_splice_items_zero_sized() {
     let mut vec = vec![(), (), ()];
     let vec2 = vec![];
-    let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
+    let t: Vec<_> = vec.splice(1..2, vec2.into_iter()).collect();
     assert_eq!(vec, &[(), ()]);
     assert_eq!(t, &[()]);
 }
@@ -848,7 +848,7 @@ fn test_splice_unbounded() {
 fn test_splice_forget() {
     let mut v = vec![1, 2, 3, 4, 5];
     let a = [10, 11, 12];
-    std::mem::forget(v.splice(2..4, a.iter().cloned()));
+    std::mem::forget(v.splice(2..4, a.into_iter()));
     assert_eq!(v, &[1, 2]);
 }
 

library/alloc/tests/vec_deque.rs

@@ -497,7 +497,7 @@ fn test_drain() {
 #[test]
 fn test_from_iter() {
     let v = vec![1, 2, 3, 4, 5, 6, 7];
-    let deq: VecDeque<_> = v.iter().cloned().collect();
+    let deq: VecDeque<_> = v.iter().copied().collect();
     let u: Vec<_> = deq.iter().cloned().collect();
     assert_eq!(u, v);
 
@@ -648,7 +648,7 @@ fn test_show() {
     let ringbuf: VecDeque<_> = (0..10).collect();
     assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
-    let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
+    let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].into_iter().collect();
     assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]");
 }
 
@@ -1462,7 +1462,7 @@ fn test_rotate_left_random() {
     let n = 12;
     let mut v: VecDeque<_> = (0..n).collect();
     let mut total_shift = 0;
-    for shift in shifts.iter().cloned() {
+    for shift in shifts {
         v.rotate_left(shift);
         total_shift += shift;
         for i in 0..n {
@@ -1480,7 +1480,7 @@ fn test_rotate_right_random() {
     let n = 12;
     let mut v: VecDeque<_> = (0..n).collect();
     let mut total_shift = 0;
-    for shift in shifts.iter().cloned() {
+    for shift in shifts {
         v.rotate_right(shift);
         total_shift += shift;
         for i in 0..n {
@@ -1514,7 +1514,7 @@ fn test_try_fold_unit() {
 
 #[test]
 fn test_try_fold_unit_none() {
-    let v: std::collections::VecDeque<()> = [(); 10].iter().cloned().collect();
+    let v: std::collections::VecDeque<()> = [(); 10].into_iter().collect();
     let mut iter = v.into_iter();
     assert!(iter.try_fold((), |_, _| None).is_none());
     assert_eq!(iter.len(), 9);

library/core/src/char/decode.rs

@@ -38,7 +38,7 @@ pub struct DecodeUtf16Error {
 /// ];
 ///
 /// assert_eq!(
-///     decode_utf16(v.iter().cloned())
+///     decode_utf16(v)
 ///         .map(|r| r.map_err(|e| e.unpaired_surrogate()))
 ///         .collect::<Vec<_>>(),
 ///     vec![
@@ -62,7 +62,7 @@ pub struct DecodeUtf16Error {
 /// ];
 ///
 /// assert_eq!(
-///     decode_utf16(v.iter().cloned())
+///     decode_utf16(v)
 ///        .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
 ///        .collect::<String>(),
 ///     "𝄞mus�ic�"