fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
3.6 KiB154 linesraw
1#![deny(clippy::explicit_iter_loop)]
2#![allow(
3    clippy::linkedlist,
4    clippy::similar_names,
5    clippy::needless_borrow,
6    clippy::deref_addrof,
7    clippy::unnecessary_mut_passed,
8    dead_code
9)]
10
11use core::slice;
12use std::collections::*;
13
14fn main() {
15    let mut vec = vec![1, 2, 3, 4];
16
17    for _ in &vec {}
18    for _ in &mut vec {}
19
20    let rvec = &vec;
21    for _ in rvec {}
22
23    let rmvec = &mut vec;
24    for _ in rmvec.iter() {}
25    for _ in rmvec.iter_mut() {}
26
27    for _ in &vec {} // these are fine
28    for _ in &mut vec {} // these are fine
29
30    for _ in &[1, 2, 3] {}
31
32    for _ in (&mut [1, 2, 3]).iter() {}
33
34    for _ in &[0; 32] {}
35    for _ in &[0; 33] {}
36
37    let ll: LinkedList<()> = LinkedList::new();
38    for _ in &ll {}
39    let rll = &ll;
40    for _ in rll {}
41
42    let vd: VecDeque<()> = VecDeque::new();
43    for _ in &vd {}
44    let rvd = &vd;
45    for _ in rvd {}
46
47    let bh: BinaryHeap<()> = BinaryHeap::new();
48    for _ in &bh {}
49
50    let hm: HashMap<(), ()> = HashMap::new();
51    for _ in &hm {}
52
53    let bt: BTreeMap<(), ()> = BTreeMap::new();
54    for _ in &bt {}
55
56    let hs: HashSet<()> = HashSet::new();
57    for _ in &hs {}
58
59    let bs: BTreeSet<()> = BTreeSet::new();
60    for _ in &bs {}
61
62    struct NoIntoIter();
63    impl NoIntoIter {
64        fn iter(&self) -> slice::Iter<u8> {
65            unimplemented!()
66        }
67
68        fn iter_mut(&mut self) -> slice::IterMut<u8> {
69            unimplemented!()
70        }
71    }
72    let mut x = NoIntoIter();
73    for _ in x.iter() {} // no error
74    for _ in x.iter_mut() {} // no error
75
76    struct IntoIterDiffTy;
77    impl IntoIterator for &'_ IntoIterDiffTy {
78        type Item = &'static ();
79        type IntoIter = core::slice::Iter<'static, ()>;
80        fn into_iter(self) -> Self::IntoIter {
81            unimplemented!()
82        }
83    }
84    impl IntoIterDiffTy {
85        fn iter(&self) -> core::slice::Iter<'static, i32> {
86            unimplemented!()
87        }
88    }
89    let x = IntoIterDiffTy;
90    for _ in x.iter() {}
91
92    struct IntoIterDiffSig;
93    impl IntoIterator for &'_ IntoIterDiffSig {
94        type Item = &'static ();
95        type IntoIter = core::slice::Iter<'static, ()>;
96        fn into_iter(self) -> Self::IntoIter {
97            unimplemented!()
98        }
99    }
100    impl IntoIterDiffSig {
101        fn iter(&self, _: u32) -> core::slice::Iter<'static, ()> {
102            unimplemented!()
103        }
104    }
105    let x = IntoIterDiffSig;
106    for _ in x.iter(0) {}
107
108    struct IntoIterDiffLt<'a>(&'a ());
109    impl<'a> IntoIterator for &'a IntoIterDiffLt<'_> {
110        type Item = &'a ();
111        type IntoIter = core::slice::Iter<'a, ()>;
112        fn into_iter(self) -> Self::IntoIter {
113            unimplemented!()
114        }
115    }
116    impl<'a> IntoIterDiffLt<'a> {
117        fn iter(&self) -> core::slice::Iter<'a, ()> {
118            unimplemented!()
119        }
120    }
121    let x = IntoIterDiffLt(&());
122    for _ in x.iter() {}
123
124    struct CustomType;
125    impl<'a> IntoIterator for &'a CustomType {
126        type Item = &'a u32;
127        type IntoIter = core::slice::Iter<'a, u32>;
128        fn into_iter(self) -> Self::IntoIter {
129            unimplemented!()
130        }
131    }
132    impl<'a> IntoIterator for &'a mut CustomType {
133        type Item = &'a mut u32;
134        type IntoIter = core::slice::IterMut<'a, u32>;
135        fn into_iter(self) -> Self::IntoIter {
136            unimplemented!()
137        }
138    }
139    impl CustomType {
140        fn iter(&self) -> <&'_ Self as IntoIterator>::IntoIter {
141            panic!()
142        }
143
144        fn iter_mut(&mut self) -> core::slice::IterMut<'_, u32> {
145            panic!()
146        }
147    }
148    let mut x = CustomType;
149    for _ in &x {}
150    for _ in &mut x {}
151
152    let r = &x;
153    for _ in r {}
154}