From dc0db358abe19481e475e10c32149b53370f1a1c Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Thu, 30 May 2024 05:57:31 +0200
Subject: Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 src/tools/clippy/tests/ui/explicit_iter_loop.fixed | 154 +++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 src/tools/clippy/tests/ui/explicit_iter_loop.fixed

(limited to 'src/tools/clippy/tests/ui/explicit_iter_loop.fixed')

diff --git a/src/tools/clippy/tests/ui/explicit_iter_loop.fixed b/src/tools/clippy/tests/ui/explicit_iter_loop.fixed
new file mode 100644
index 000000000..746ef813c
--- /dev/null
+++ b/src/tools/clippy/tests/ui/explicit_iter_loop.fixed
@@ -0,0 +1,154 @@
+//@run-rustfix
+#![deny(clippy::explicit_iter_loop)]
+#![allow(
+    clippy::linkedlist,
+    clippy::similar_names,
+    clippy::needless_borrow,
+    clippy::deref_addrof,
+    dead_code
+)]
+
+use core::slice;
+use std::collections::*;
+
+fn main() {
+    let mut vec = vec![1, 2, 3, 4];
+
+    for _ in &vec {}
+    for _ in &mut vec {}
+
+    let rvec = &vec;
+    for _ in rvec {}
+
+    let rmvec = &mut vec;
+    for _ in &*rmvec {}
+    for _ in &mut *rmvec {}
+
+    for _ in &vec {} // these are fine
+    for _ in &mut vec {} // these are fine
+
+    for _ in &[1, 2, 3] {}
+
+    for _ in &*(&mut [1, 2, 3]) {}
+
+    for _ in &[0; 32] {}
+    for _ in &[0; 33] {}
+
+    let ll: LinkedList<()> = LinkedList::new();
+    for _ in &ll {}
+    let rll = &ll;
+    for _ in rll {}
+
+    let vd: VecDeque<()> = VecDeque::new();
+    for _ in &vd {}
+    let rvd = &vd;
+    for _ in rvd {}
+
+    let bh: BinaryHeap<()> = BinaryHeap::new();
+    for _ in &bh {}
+
+    let hm: HashMap<(), ()> = HashMap::new();
+    for _ in &hm {}
+
+    let bt: BTreeMap<(), ()> = BTreeMap::new();
+    for _ in &bt {}
+
+    let hs: HashSet<()> = HashSet::new();
+    for _ in &hs {}
+
+    let bs: BTreeSet<()> = BTreeSet::new();
+    for _ in &bs {}
+
+    struct NoIntoIter();
+    impl NoIntoIter {
+        fn iter(&self) -> slice::Iter<u8> {
+            unimplemented!()
+        }
+
+        fn iter_mut(&mut self) -> slice::IterMut<u8> {
+            unimplemented!()
+        }
+    }
+    let mut x = NoIntoIter();
+    for _ in x.iter() {} // no error
+    for _ in x.iter_mut() {} // no error
+
+    struct IntoIterDiffTy;
+    impl IntoIterator for &'_ IntoIterDiffTy {
+        type Item = &'static ();
+        type IntoIter = core::slice::Iter<'static, ()>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+    impl IntoIterDiffTy {
+        fn iter(&self) -> core::slice::Iter<'static, i32> {
+            unimplemented!()
+        }
+    }
+    let x = IntoIterDiffTy;
+    for _ in x.iter() {}
+
+    struct IntoIterDiffSig;
+    impl IntoIterator for &'_ IntoIterDiffSig {
+        type Item = &'static ();
+        type IntoIter = core::slice::Iter<'static, ()>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+    impl IntoIterDiffSig {
+        fn iter(&self, _: u32) -> core::slice::Iter<'static, ()> {
+            unimplemented!()
+        }
+    }
+    let x = IntoIterDiffSig;
+    for _ in x.iter(0) {}
+
+    struct IntoIterDiffLt<'a>(&'a ());
+    impl<'a> IntoIterator for &'a IntoIterDiffLt<'_> {
+        type Item = &'a ();
+        type IntoIter = core::slice::Iter<'a, ()>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+    impl<'a> IntoIterDiffLt<'a> {
+        fn iter(&self) -> core::slice::Iter<'a, ()> {
+            unimplemented!()
+        }
+    }
+    let x = IntoIterDiffLt(&());
+    for _ in x.iter() {}
+
+    struct CustomType;
+    impl<'a> IntoIterator for &'a CustomType {
+        type Item = &'a u32;
+        type IntoIter = core::slice::Iter<'a, u32>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+    impl<'a> IntoIterator for &'a mut CustomType {
+        type Item = &'a mut u32;
+        type IntoIter = core::slice::IterMut<'a, u32>;
+        fn into_iter(self) -> Self::IntoIter {
+            unimplemented!()
+        }
+    }
+    impl CustomType {
+        fn iter(&self) -> <&'_ Self as IntoIterator>::IntoIter {
+            panic!()
+        }
+
+        fn iter_mut(&mut self) -> core::slice::IterMut<'_, u32> {
+            panic!()
+        }
+    }
+    let mut x = CustomType;
+    for _ in &x {}
+    for _ in &mut x {}
+
+    let r = &x;
+    for _ in r {}
+}
-- 
cgit v1.2.3