1 #![allow(clippy::uninlined_format_args)]
3 use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
7 let indirect_iter = sample.iter().collect::<Vec<_>>();
8 indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
9 let indirect_len = sample.iter().collect::<VecDeque<_>>();
11 let indirect_empty = sample.iter().collect::<VecDeque<_>>();
12 indirect_empty.is_empty();
13 let indirect_contains = sample.iter().collect::<VecDeque<_>>();
14 indirect_contains.contains(&&5);
15 let indirect_negative = sample.iter().collect::<Vec<_>>();
16 indirect_negative.len();
19 .map(|x| (*x, *x + 1))
20 .collect::<HashMap<_, _>>();
23 let a = "a".to_string();
24 let sample = vec![a.clone(), "b".to_string(), "c".to_string()];
25 let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
26 non_copy_contains.contains(&a);
29 let vec_a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
30 let vec_b = vec_a.iter().collect::<Vec<_>>();
32 let other_vec = vec![1, 3, 12, 4, 16, 2];
33 let we_got_the_same_numbers = other_vec.iter().filter(|item| vec_b.contains(item)).collect::<Vec<_>>();
37 let multiple_indirect = sample.iter().collect::<Vec<_>>();
38 let sample2 = vec![2, 3];
39 if multiple_indirect.is_empty() {
44 .filter(|i| multiple_indirect.iter().any(|s| **s % **i == 0))
50 // #7110 - lint for type annotation cases
53 fn lint_vec(string: &str) -> usize {
54 let buffer: Vec<&str> = string.split('/').collect();
57 fn lint_vec_deque() -> usize {
59 let indirect_len: VecDeque<_> = sample.iter().collect();
62 fn lint_linked_list() -> usize {
64 let indirect_len: LinkedList<_> = sample.iter().collect();
67 fn lint_binary_heap() -> usize {
69 let indirect_len: BinaryHeap<_> = sample.iter().collect();
72 fn dont_lint(string: &str) -> usize {
73 let buffer: Vec<&str> = string.split('/').collect();
84 fn direct_mapping_with_used_mutable_reference() -> Vec<()> {
85 let test_vec: Vec<()> = vec![];
86 let mut vec_2: Vec<()> = vec![];
87 let mut_ref = &mut vec_2;
88 let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
89 collected_vec.into_iter().map(|_| mut_ref.push(())).collect()
92 fn indirectly_mapping_with_used_mutable_reference() -> Vec<()> {
93 let test_vec: Vec<()> = vec![];
94 let mut vec_2: Vec<()> = vec![];
95 let mut_ref = &mut vec_2;
96 let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
97 let iter = collected_vec.into_iter();
98 iter.map(|_| mut_ref.push(())).collect()
101 fn indirect_collect_after_indirect_mapping_with_used_mutable_reference() -> Vec<()> {
102 let test_vec: Vec<()> = vec![];
103 let mut vec_2: Vec<()> = vec![];
104 let mut_ref = &mut vec_2;
105 let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
106 let iter = collected_vec.into_iter();
107 let mapped_iter = iter.map(|_| mut_ref.push(()));
108 mapped_iter.collect()
113 #[allow(clippy::needless_collect)]
114 let v = [1].iter().collect::<Vec<_>>();
115 v.into_iter().collect::<HashSet<_>>();
120 let vec = vec![1, 2];
121 let w: Vec<usize> = vec.iter().map(|i| i * i).collect();
124 // Do not lint, because this method call is in the loop
129 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
130 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
134 // Do not lint, because this method call is in the loop
139 // Do not lint, because this variable is used.
144 let vec = vec![1, 2];
145 let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
148 // Do not lint, because this method call is in the loop
154 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
155 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
160 // Do not lint, because this method call is in the loop
168 let vec = vec![1, 2];
169 let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
173 // Do not lint, because this method call is in the loop
183 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
184 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
190 // Do not lint, because this method call is in the loop
203 fn test_while_let() {
204 let vec = vec![1, 2];
205 let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
206 let optional = Some(0);
208 while let Some(value) = optional {
210 // Do not lint, because this method call is in the loop
218 while let Some(value) = optional {
219 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
220 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
229 while let Some(value) = optional {
231 // Do not lint, because this method call is in the loop
242 let vec = vec![1, 2];
243 let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
244 let w = v.iter().collect::<Vec<_>>();
246 for _ in 0..w.len() {
251 fn test_if_cond_false_case() {
252 let vec = vec![1, 2];
253 let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
254 let w = v.iter().collect::<Vec<_>>();
255 // Do not lint, because w is used.
256 for _ in 0..w.len() {
263 fn test_while_cond() {
264 let mut vec = vec![1, 2];
265 let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
266 let mut w = v.iter().collect::<Vec<_>>();
273 fn test_while_cond_false_case() {
274 let mut vec = vec![1, 2];
275 let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
276 let mut w = v.iter().collect::<Vec<_>>();
277 // Do not lint, because w is used.
285 fn test_while_let_cond() {
286 let mut vec = vec![1, 2];
287 let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
288 let mut w = v.iter().collect::<Vec<_>>();
290 while let Some(i) = Some(w.len()) {
295 fn test_while_let_cond_false_case() {
296 let mut vec = vec![1, 2];
297 let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
298 let mut w = v.iter().collect::<Vec<_>>();
299 // Do not lint, because w is used.
300 while let Some(i) = Some(w.len()) {