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 }