tests/ui/search_is_some_fixable_some.rs

   1 // run-rustfix
   2 #![allow(dead_code)]
   3 #![warn(clippy::search_is_some)]
   4
   5 fn main() {
   6     let v = vec![3, 2, 1, 0, -1, -2, -3];
   7     let y = &&42;
   8
   9     // Check `find().is_some()`, single-line case.
  10     let _ = v.iter().find(|&x| *x < 0).is_some();
  11     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
  12     let _ = (0..1).find(|x| *x == 0).is_some();
  13     let _ = v.iter().find(|x| **x == 0).is_some();
  14     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
  15     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
  16     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
  17     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
  18     let _ = (1..3)
  19         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
  20         .is_some();
  21
  22     // Check `position().is_some()`, single-line case.
  23     let _ = v.iter().position(|&x| x < 0).is_some();
  24
  25     // Check `rposition().is_some()`, single-line case.
  26     let _ = v.iter().rposition(|&x| x < 0).is_some();
  27
  28     let s1 = String::from("hello world");
  29     let s2 = String::from("world");
  30     // caller of `find()` is a `&`static str`
  31     let _ = "hello world".find("world").is_some();
  32     let _ = "hello world".find(&s2).is_some();
  33     let _ = "hello world".find(&s2[2..]).is_some();
  34     // caller of `find()` is a `String`
  35     let _ = s1.find("world").is_some();
  36     let _ = s1.find(&s2).is_some();
  37     let _ = s1.find(&s2[2..]).is_some();
  38     // caller of `find()` is slice of `String`
  39     let _ = s1[2..].find("world").is_some();
  40     let _ = s1[2..].find(&s2).is_some();
  41     let _ = s1[2..].find(&s2[2..]).is_some();
  42 }
  43
  44 #[allow(clippy::clone_on_copy, clippy::map_clone)]
  45 mod issue7392 {
  46     struct Player {
  47         hand: Vec<usize>,
  48     }
  49     fn filter() {
  50         let p = Player {
  51             hand: vec![1, 2, 3, 4, 5],
  52         };
  53         let filter_hand = vec![5];
  54         let _ = p
  55             .hand
  56             .iter()
  57             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_some())
  58             .map(|c| c.clone())
  59             .collect::<Vec<_>>();
  60     }
  61
  62     struct PlayerTuple {
  63         hand: Vec<(usize, char)>,
  64     }
  65     fn filter_tuple() {
  66         let p = PlayerTuple {
  67             hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
  68         };
  69         let filter_hand = vec![5];
  70         let _ = p
  71             .hand
  72             .iter()
  73             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_some())
  74             .map(|c| c.clone())
  75             .collect::<Vec<_>>();
  76     }
  77
  78     fn field_projection() {
  79         struct Foo {
  80             foo: i32,
  81             bar: u32,
  82         }
  83         let vfoo = vec![Foo { foo: 1, bar: 2 }];
  84         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
  85
  86         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
  87         let _ = vfoo
  88             .iter()
  89             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
  90             .is_some();
  91     }
  92
  93     fn index_projection() {
  94         let vfoo = vec![[0, 1, 2, 3]];
  95         let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
  96     }
  97
  98     #[allow(clippy::match_like_matches_macro)]
  99     fn slice_projection() {
 100         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
 101         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
 102     }
 103
 104     fn please(x: &u32) -> bool {
 105         *x == 9
 106     }
 107
 108     fn deref_enough(x: u32) -> bool {
 109         x == 78
 110     }
 111
 112     fn arg_no_deref(x: &&u32) -> bool {
 113         **x == 78
 114     }
 115
 116     fn more_projections() {
 117         let x = 19;
 118         let ppx: &u32 = &x;
 119         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
 120         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
 121
 122         let v = vec![3, 2, 1, 0];
 123         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
 124
 125         #[allow(clippy::redundant_closure)]
 126         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
 127     }
 128
 129     fn field_index_projection() {
 130         struct FooDouble {
 131             bar: Vec<Vec<i32>>,
 132         }
 133         struct Foo {
 134             bar: Vec<i32>,
 135         }
 136         struct FooOuter {
 137             inner: Foo,
 138             inner_double: FooDouble,
 139         }
 140         let vfoo = vec![FooOuter {
 141             inner: Foo { bar: vec![0, 1, 2, 3] },
 142             inner_double: FooDouble {
 143                 bar: vec![vec![0, 1, 2, 3]],
 144             },
 145         }];
 146         let _ = vfoo
 147             .iter()
 148             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
 149             .is_some();
 150     }
 151
 152     fn index_field_projection() {
 153         struct Foo {
 154             bar: i32,
 155         }
 156         struct FooOuter {
 157             inner: Vec<Foo>,
 158         }
 159         let vfoo = vec![FooOuter {
 160             inner: vec![Foo { bar: 0 }],
 161         }];
 162         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
 163     }
 164
 165     fn double_deref_index_projection() {
 166         let vfoo = vec![&&[0, 1, 2, 3]];
 167         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
 168     }
 169
 170     fn method_call_by_ref() {
 171         struct Foo {
 172             bar: u32,
 173         }
 174         impl Foo {
 175             pub fn by_ref(&self, x: &u32) -> bool {
 176                 *x == self.bar
 177             }
 178         }
 179         let vfoo = vec![Foo { bar: 1 }];
 180         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
 181     }
 182
 183     fn ref_bindings() {
 184         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
 185         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
 186     }
 187 }