src/tools/clippy/tests/ui/needless_collect_indirect.rs

   1 use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
   2
   3 fn main() {
   4     let sample = [1; 5];
   5     let indirect_iter = sample.iter().collect::<Vec<_>>();
   6     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
   7     let indirect_len = sample.iter().collect::<VecDeque<_>>();
   8     indirect_len.len();
   9     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
  10     indirect_empty.is_empty();
  11     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
  12     indirect_contains.contains(&&5);
  13     let indirect_negative = sample.iter().collect::<Vec<_>>();
  14     indirect_negative.len();
  15     indirect_negative
  16         .into_iter()
  17         .map(|x| (*x, *x + 1))
  18         .collect::<HashMap<_, _>>();
  19
  20     // #6202
  21     let a = "a".to_string();
  22     let sample = vec![a.clone(), "b".to_string(), "c".to_string()];
  23     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
  24     non_copy_contains.contains(&a);
  25
  26     // Fix #5991
  27     let vec_a = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  28     let vec_b = vec_a.iter().collect::<Vec<_>>();
  29     if vec_b.len() > 3 {}
  30     let other_vec = vec![1, 3, 12, 4, 16, 2];
  31     let we_got_the_same_numbers = other_vec.iter().filter(|item| vec_b.contains(item)).collect::<Vec<_>>();
  32
  33     // Fix #6297
  34     let sample = [1; 5];
  35     let multiple_indirect = sample.iter().collect::<Vec<_>>();
  36     let sample2 = vec![2, 3];
  37     if multiple_indirect.is_empty() {
  38         // do something
  39     } else {
  40         let found = sample2
  41             .iter()
  42             .filter(|i| multiple_indirect.iter().any(|s| **s % **i == 0))
  43             .collect::<Vec<_>>();
  44     }
  45 }
  46
  47 mod issue7110 {
  48     // #7110 - lint for type annotation cases
  49     use super::*;
  50
  51     fn lint_vec(string: &str) -> usize {
  52         let buffer: Vec<&str> = string.split('/').collect();
  53         buffer.len()
  54     }
  55     fn lint_vec_deque() -> usize {
  56         let sample = [1; 5];
  57         let indirect_len: VecDeque<_> = sample.iter().collect();
  58         indirect_len.len()
  59     }
  60     fn lint_linked_list() -> usize {
  61         let sample = [1; 5];
  62         let indirect_len: LinkedList<_> = sample.iter().collect();
  63         indirect_len.len()
  64     }
  65     fn lint_binary_heap() -> usize {
  66         let sample = [1; 5];
  67         let indirect_len: BinaryHeap<_> = sample.iter().collect();
  68         indirect_len.len()
  69     }
  70     fn dont_lint(string: &str) -> usize {
  71         let buffer: Vec<&str> = string.split('/').collect();
  72         for buff in &buffer {
  73             println!("{}", buff);
  74         }
  75         buffer.len()
  76     }
  77 }
  78
  79 mod issue7975 {
  80     use super::*;
  81
  82     fn direct_mapping_with_used_mutable_reference() -> Vec<()> {
  83         let test_vec: Vec<()> = vec![];
  84         let mut vec_2: Vec<()> = vec![];
  85         let mut_ref = &mut vec_2;
  86         let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
  87         collected_vec.into_iter().map(|_| mut_ref.push(())).collect()
  88     }
  89
  90     fn indirectly_mapping_with_used_mutable_reference() -> Vec<()> {
  91         let test_vec: Vec<()> = vec![];
  92         let mut vec_2: Vec<()> = vec![];
  93         let mut_ref = &mut vec_2;
  94         let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
  95         let iter = collected_vec.into_iter();
  96         iter.map(|_| mut_ref.push(())).collect()
  97     }
  98
  99     fn indirect_collect_after_indirect_mapping_with_used_mutable_reference() -> Vec<()> {
 100         let test_vec: Vec<()> = vec![];
 101         let mut vec_2: Vec<()> = vec![];
 102         let mut_ref = &mut vec_2;
 103         let collected_vec: Vec<_> = test_vec.into_iter().map(|_| mut_ref.push(())).collect();
 104         let iter = collected_vec.into_iter();
 105         let mapped_iter = iter.map(|_| mut_ref.push(()));
 106         mapped_iter.collect()
 107     }
 108 }
 109
 110 fn allow_test() {
 111     #[allow(clippy::needless_collect)]
 112     let v = [1].iter().collect::<Vec<_>>();
 113     v.into_iter().collect::<HashSet<_>>();
 114 }
 115
 116 mod issue_8553 {
 117     fn test_for() {
 118         let vec = vec![1, 2];
 119         let w: Vec<usize> = vec.iter().map(|i| i * i).collect();
 120
 121         for i in 0..2 {
 122             // Do not lint, because this method call is in the loop
 123             w.contains(&i);
 124         }
 125
 126         for i in 0..2 {
 127             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 128             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 129             // Do lint
 130             y.contains(&i);
 131             for j in 0..2 {
 132                 // Do not lint, because this method call is in the loop
 133                 z.contains(&j);
 134             }
 135         }
 136
 137         // Do not lint, because this variable is used.
 138         w.contains(&0);
 139     }
 140
 141     fn test_while() {
 142         let vec = vec![1, 2];
 143         let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
 144         let mut n = 0;
 145         while n > 1 {
 146             // Do not lint, because this method call is in the loop
 147             x.contains(&n);
 148             n += 1;
 149         }
 150
 151         while n > 2 {
 152             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 153             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 154             // Do lint
 155             y.contains(&n);
 156             n += 1;
 157             while n > 4 {
 158                 // Do not lint, because this method call is in the loop
 159                 z.contains(&n);
 160                 n += 1;
 161             }
 162         }
 163     }
 164
 165     fn test_loop() {
 166         let vec = vec![1, 2];
 167         let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
 168         let mut n = 0;
 169         loop {
 170             if n < 1 {
 171                 // Do not lint, because this method call is in the loop
 172                 x.contains(&n);
 173                 n += 1;
 174             } else {
 175                 break;
 176             }
 177         }
 178
 179         loop {
 180             if n < 2 {
 181                 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 182                 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 183                 // Do lint
 184                 y.contains(&n);
 185                 n += 1;
 186                 loop {
 187                     if n < 4 {
 188                         // Do not lint, because this method call is in the loop
 189                         z.contains(&n);
 190                         n += 1;
 191                     } else {
 192                         break;
 193                     }
 194                 }
 195             } else {
 196                 break;
 197             }
 198         }
 199     }
 200
 201     fn test_while_let() {
 202         let vec = vec![1, 2];
 203         let x: Vec<usize> = vec.iter().map(|i| i * i).collect();
 204         let optional = Some(0);
 205         let mut n = 0;
 206         while let Some(value) = optional {
 207             if n < 1 {
 208                 // Do not lint, because this method call is in the loop
 209                 x.contains(&n);
 210                 n += 1;
 211             } else {
 212                 break;
 213             }
 214         }
 215
 216         while let Some(value) = optional {
 217             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
 218             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
 219             if n < 2 {
 220                 // Do lint
 221                 y.contains(&n);
 222                 n += 1;
 223             } else {
 224                 break;
 225             }
 226
 227             while let Some(value) = optional {
 228                 if n < 4 {
 229                     // Do not lint, because this method call is in the loop
 230                     z.contains(&n);
 231                     n += 1;
 232                 } else {
 233                     break;
 234                 }
 235             }
 236         }
 237     }
 238
 239     fn test_if_cond() {
 240         let vec = vec![1, 2];
 241         let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 242         let w = v.iter().collect::<Vec<_>>();
 243         // Do lint
 244         for _ in 0..w.len() {
 245             todo!();
 246         }
 247     }
 248
 249     fn test_if_cond_false_case() {
 250         let vec = vec![1, 2];
 251         let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 252         let w = v.iter().collect::<Vec<_>>();
 253         // Do not lint, because w is used.
 254         for _ in 0..w.len() {
 255             todo!();
 256         }
 257
 258         w.len();
 259     }
 260
 261     fn test_while_cond() {
 262         let mut vec = vec![1, 2];
 263         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 264         let mut w = v.iter().collect::<Vec<_>>();
 265         // Do lint
 266         while 1 == w.len() {
 267             todo!();
 268         }
 269     }
 270
 271     fn test_while_cond_false_case() {
 272         let mut vec = vec![1, 2];
 273         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 274         let mut w = v.iter().collect::<Vec<_>>();
 275         // Do not lint, because w is used.
 276         while 1 == w.len() {
 277             todo!();
 278         }
 279
 280         w.len();
 281     }
 282
 283     fn test_while_let_cond() {
 284         let mut vec = vec![1, 2];
 285         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 286         let mut w = v.iter().collect::<Vec<_>>();
 287         // Do lint
 288         while let Some(i) = Some(w.len()) {
 289             todo!();
 290         }
 291     }
 292
 293     fn test_while_let_cond_false_case() {
 294         let mut vec = vec![1, 2];
 295         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
 296         let mut w = v.iter().collect::<Vec<_>>();
 297         // Do not lint, because w is used.
 298         while let Some(i) = Some(w.len()) {
 299             todo!();
 300         }
 301         w.len();
 302     }
 303 }