tests/ui/search_is_some.rs

   1 // aux-build:option_helpers.rs
   2 #![warn(clippy::search_is_some)]
   3 #![allow(dead_code)]
   4 extern crate option_helpers;
   5 use option_helpers::IteratorFalsePositives;
   6
   7 #[rustfmt::skip]
   8 fn main() {
   9     let v = vec![3, 2, 1, 0, -1, -2, -3];
  10     let y = &&42;
  11
  12
  13     // Check `find().is_some()`, multi-line case.
  14     let _ = v.iter().find(|&x| {
  15                               *x < 0
  16                           }
  17                    ).is_some();
  18
  19     // Check `position().is_some()`, multi-line case.
  20     let _ = v.iter().position(|&x| {
  21                                   x < 0
  22                               }
  23                    ).is_some();
  24
  25     // Check `rposition().is_some()`, multi-line case.
  26     let _ = v.iter().rposition(|&x| {
  27                                    x < 0
  28                                }
  29                    ).is_some();
  30
  31     // Check that we don't lint if the caller is not an `Iterator` or string
  32     let falsepos = IteratorFalsePositives { foo: 0 };
  33     let _ = falsepos.find().is_some();
  34     let _ = falsepos.position().is_some();
  35     let _ = falsepos.rposition().is_some();
  36     // check that we don't lint if `find()` is called with
  37     // `Pattern` that is not a string
  38     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_some();
  39
  40     // Check `find().is_some()`, single-line case.
  41     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
  42     let _ = (0..1).find(|x| *x == 0).is_some();
  43     let _ = v.iter().find(|x| **x == 0).is_some();
  44 }
  45
  46 #[rustfmt::skip]
  47 fn is_none() {
  48     let v = vec![3, 2, 1, 0, -1, -2, -3];
  49     let y = &&42;
  50
  51
  52     // Check `find().is_none()`, multi-line case.
  53     let _ = v.iter().find(|&x| {
  54                               *x < 0
  55                           }
  56                    ).is_none();
  57
  58     // Check `position().is_none()`, multi-line case.
  59     let _ = v.iter().position(|&x| {
  60                                   x < 0
  61                               }
  62                    ).is_none();
  63
  64     // Check `rposition().is_none()`, multi-line case.
  65     let _ = v.iter().rposition(|&x| {
  66                                    x < 0
  67                                }
  68                    ).is_none();
  69
  70     // Check that we don't lint if the caller is not an `Iterator` or string
  71     let falsepos = IteratorFalsePositives { foo: 0 };
  72     let _ = falsepos.find().is_none();
  73     let _ = falsepos.position().is_none();
  74     let _ = falsepos.rposition().is_none();
  75     // check that we don't lint if `find()` is called with
  76     // `Pattern` that is not a string
  77     let _ = "hello world".find(|c: char| c == 'o' || c == 'l').is_none();
  78
  79     // Check `find().is_none()`, single-line case.
  80     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
  81     let _ = (0..1).find(|x| *x == 0).is_none();
  82     let _ = v.iter().find(|x| **x == 0).is_none();
  83 }
  84
  85 #[allow(clippy::clone_on_copy, clippy::map_clone)]
  86 mod issue7392 {
  87     struct Player {
  88         hand: Vec<usize>,
  89     }
  90     fn filter() {
  91         let p = Player {
  92             hand: vec![1, 2, 3, 4, 5],
  93         };
  94         let filter_hand = vec![5];
  95         let _ = p
  96             .hand
  97             .iter()
  98             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
  99             .map(|c| c.clone())
 100             .collect::<Vec<_>>();
 101     }
 102
 103     struct PlayerTuple {
 104         hand: Vec<(usize, char)>,
 105     }
 106     fn filter_tuple() {
 107         let p = PlayerTuple {
 108             hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
 109         };
 110         let filter_hand = vec![5];
 111         let _ = p
 112             .hand
 113             .iter()
 114             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
 115             .map(|c| c.clone())
 116             .collect::<Vec<_>>();
 117     }
 118 }