Add IntoIterator impl for arrays by value (for [T; N])

compiler/rustc_lint/src/lib.rs

@@ -47,7 +47,6 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
 
-mod array_into_iter;
 pub mod builtin;
 mod context;
 mod early;
@@ -76,7 +75,6 @@ use rustc_session::lint::builtin::{
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::Span;
 
-use array_into_iter::ArrayIntoIter;
 use builtin::*;
 use internal::*;
 use methods::*;
@@ -166,7 +164,6 @@ macro_rules! late_lint_passes {
                 // FIXME: Turn the computation of types which implement Debug into a query
                 // and change this to a module lint pass
                 MissingDebugImplementations: MissingDebugImplementations::default(),
-                ArrayIntoIter: ArrayIntoIter,
                 ClashingExternDeclarations: ClashingExternDeclarations::new(),
                 DropTraitConstraints: DropTraitConstraints,
                 TemporaryCStringAsPtr: TemporaryCStringAsPtr,

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();