tests/ui/needless_collect_indirect.rs

   1 #![allow(clippy::uninlined_format_args)]
   2
   3 use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
   4
   5 fn main() {
   6     let sample = [1; 5];
   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<_>>();
  10     indirect_len.len();
  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();
  17     indirect_negative
  18         .into_iter()
  19         .map(|x| (*x, *x + 1))
  20         .collect::<HashMap<_, _>>();
  21
  22     // #6202
  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);
  27
  28     // Fix #5991
  29     let vec_a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  30     let vec_b = vec_a.iter().collect::<Vec<_>>();
  31     if vec_b.len() > 3 {}
  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<_>>();
  34
  35     // Fix #6297
  36     let sample = [1; 5];
  37     let multiple_indirect = sample.iter().collect::<Vec<_>>();
  38     let sample2 = vec![2, 3];
  39     if multiple_indirect.is_empty() {
  40         // do something
  41     } else {
  42         let found = sample2
  43             .iter()
  44             .filter(|i| multiple_indirect.iter().any(|s| **s % **i == 0))
  45             .collect::<Vec<_>>();
  46     }
  47 }
  48
  49 mod issue7110 {
  50     // #7110 - lint for type annotation cases
  51     use super::*;
  52
  53     fn lint_vec(string: &str) -> usize {
  54         let buffer: Vec<&str> = string.split('/').collect();
  55         buffer.len()
  56     }
  57     fn lint_vec_deque() -> usize {
  58         let sample = [1; 5];
  59         let indirect_len: VecDeque<_> = sample.iter().collect();
  60         indirect_len.len()
  61     }
  62     fn lint_linked_list() -> usize {
  63         let sample = [1; 5];
  64         let indirect_len: LinkedList<_> = sample.iter().collect();
  65         indirect_len.len()
  66     }
  67     fn lint_binary_heap() -> usize {
  68         let sample = [1; 5];
  69         let indirect_len: BinaryHeap<_> = sample.iter().collect();
  70         indirect_len.len()
  71     }
  72     fn dont_lint(string: &str) -> usize {
  73         let buffer: Vec<&str> = string.split('/').collect();
  74         for buff in &buffer {
  75             println!("{}", buff);
  76         }
  77         buffer.len()
  78     }
  79 }
  80
  81 mod issue7975 {
  82     use super::*;
  83
  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()
  90     }
  91
  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()
  99     }
 100
 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()
 109     }
 110 }
 111
 112 fn allow_test() {
 113     #[allow(clippy::needless_collect)]
 114     let v = [1].iter().collect::<Vec<_>>();
 115     v.into_iter().collect::<HashSet<_>>();
 116 }
 117
 118 mod issue_8553 {
 119     fn test_for() {
 120         let vec = vec![1, 2];
 121         let w: Vec<usize> = vec.iter().map(|i| i * i).collect();
 122
 123         for i in 0..2 {
 124             // Do not lint, because this method call is in the loop
 125             w.contains(&i);
 126         }
 127
 128         for i in 0..2 {
 129             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 130             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 131             // Do lint
 132             y.contains(&i);
 133             for j in 0..2 {
 134                 // Do not lint, because this method call is in the loop
 135                 z.contains(&j);
 136             }
 137         }
 138
 139         // Do not lint, because this variable is used.
 140         w.contains(&0);
 141     }
 142
 143     fn test_while() {
 144         let vec = vec![1, 2];
 145         let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
 146         let mut n = 0;
 147         while n > 1 {
 148             // Do not lint, because this method call is in the loop
 149             x.contains(&n);
 150             n += 1;
 151         }
 152
 153         while n > 2 {
 154             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 155             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 156             // Do lint
 157             y.contains(&n);
 158             n += 1;
 159             while n > 4 {
 160                 // Do not lint, because this method call is in the loop
 161                 z.contains(&n);
 162                 n += 1;
 163             }
 164         }
 165     }
 166
 167     fn test_loop() {
 168         let vec = vec![1, 2];
 169         let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
 170         let mut n = 0;
 171         loop {
 172             if n < 1 {
 173                 // Do not lint, because this method call is in the loop
 174                 x.contains(&n);
 175                 n += 1;
 176             } else {
 177                 break;
 178             }
 179         }
 180
 181         loop {
 182             if n < 2 {
 183                 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 184                 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 185                 // Do lint
 186                 y.contains(&n);
 187                 n += 1;
 188                 loop {
 189                     if n < 4 {
 190                         // Do not lint, because this method call is in the loop
 191                         z.contains(&n);
 192                         n += 1;
 193                     } else {
 194                         break;
 195                     }
 196                 }
 197             } else {
 198                 break;
 199             }
 200         }
 201     }
 202
 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);
 207         let mut n = 0;
 208         while let Some(value) = optional {
 209             if n < 1 {
 210                 // Do not lint, because this method call is in the loop
 211                 x.contains(&n);
 212                 n += 1;
 213             } else {
 214                 break;
 215             }
 216         }
 217
 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();
 221             if n < 2 {
 222                 // Do lint
 223                 y.contains(&n);
 224                 n += 1;
 225             } else {
 226                 break;
 227             }
 228
 229             while let Some(value) = optional {
 230                 if n < 4 {
 231                     // Do not lint, because this method call is in the loop
 232                     z.contains(&n);
 233                     n += 1;
 234                 } else {
 235                     break;
 236                 }
 237             }
 238         }
 239     }
 240
 241     fn test_if_cond() {
 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<_>>();
 245         // Do lint
 246         for _ in 0..w.len() {
 247             todo!();
 248         }
 249     }
 250
 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() {
 257             todo!();
 258         }
 259
 260         w.len();
 261     }
 262
 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<_>>();
 267         // Do lint
 268         while 1 == w.len() {
 269             todo!();
 270         }
 271     }
 272
 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.
 278         while 1 == w.len() {
 279             todo!();
 280         }
 281
 282         w.len();
 283     }
 284
 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<_>>();
 289         // Do lint
 290         while let Some(i) = Some(w.len()) {
 291             todo!();
 292         }
 293     }
 294
 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()) {
 301             todo!();
 302         }
 303         w.len();
 304     }
 305 }