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

   1 #![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec)]
   2 #![warn(clippy::search_is_some)]
   3
   4 fn main() {
   5     let v = vec![3, 2, 1, 0, -1, -2, -3];
   6     let y = &&42;
   7
   8     // Check `find().is_some()`, single-line case.
   9     let _ = v.iter().find(|&x| *x < 0).is_some();
  10     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
  11     let _ = (0..1).find(|x| *x == 0).is_some();
  12     let _ = v.iter().find(|x| **x == 0).is_some();
  13     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
  14     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
  15     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
  16     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
  17     let _ = (1..3)
  18         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
  19         .is_some();
  20
  21     // Check `position().is_some()`, single-line case.
  22     let _ = v.iter().position(|&x| x < 0).is_some();
  23
  24     // Check `rposition().is_some()`, single-line case.
  25     let _ = v.iter().rposition(|&x| x < 0).is_some();
  26
  27     let s1 = String::from("hello world");
  28     let s2 = String::from("world");
  29     // caller of `find()` is a `&`static str`
  30     let _ = "hello world".find("world").is_some();
  31     let _ = "hello world".find(&s2).is_some();
  32     let _ = "hello world".find(&s2[2..]).is_some();
  33     // caller of `find()` is a `String`
  34     let _ = s1.find("world").is_some();
  35     let _ = s1.find(&s2).is_some();
  36     let _ = s1.find(&s2[2..]).is_some();
  37     // caller of `find()` is slice of `String`
  38     let _ = s1[2..].find("world").is_some();
  39     let _ = s1[2..].find(&s2).is_some();
  40     let _ = s1[2..].find(&s2[2..]).is_some();
  41 }
  42
  43 #[allow(clippy::clone_on_copy, clippy::map_clone)]
  44 mod issue7392 {
  45     struct Player {
  46         hand: Vec<usize>,
  47     }
  48     fn filter() {
  49         let p = Player {
  50             hand: vec![1, 2, 3, 4, 5],
  51         };
  52         let filter_hand = vec![5];
  53         let _ = p
  54             .hand
  55             .iter()
  56             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_some())
  57             .map(|c| c.clone())
  58             .collect::<Vec<_>>();
  59     }
  60
  61     struct PlayerTuple {
  62         hand: Vec<(usize, char)>,
  63     }
  64     fn filter_tuple() {
  65         let p = PlayerTuple {
  66             hand: vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')],
  67         };
  68         let filter_hand = vec![5];
  69         let _ = p
  70             .hand
  71             .iter()
  72             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_some())
  73             .map(|c| c.clone())
  74             .collect::<Vec<_>>();
  75     }
  76
  77     fn field_projection() {
  78         struct Foo {
  79             foo: i32,
  80             bar: u32,
  81         }
  82         let vfoo = vec![Foo { foo: 1, bar: 2 }];
  83         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
  84
  85         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
  86         let _ = vfoo
  87             .iter()
  88             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
  89             .is_some();
  90     }
  91
  92     fn index_projection() {
  93         let vfoo = vec![[0, 1, 2, 3]];
  94         let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
  95     }
  96
  97     #[allow(clippy::match_like_matches_macro)]
  98     fn slice_projection() {
  99         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
 100         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
 101     }
 102
 103     fn please(x: &u32) -> bool {
 104         *x == 9
 105     }
 106
 107     fn deref_enough(x: u32) -> bool {
 108         x == 78
 109     }
 110
 111     fn arg_no_deref(x: &&u32) -> bool {
 112         **x == 78
 113     }
 114
 115     fn more_projections() {
 116         let x = 19;
 117         let ppx: &u32 = &x;
 118         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
 119         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
 120
 121         let v = vec![3, 2, 1, 0];
 122         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
 123         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_some();
 124
 125         #[allow(clippy::redundant_closure)]
 126         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
 127         #[allow(clippy::redundant_closure)]
 128         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_some();
 129     }
 130
 131     fn field_index_projection() {
 132         struct FooDouble {
 133             bar: Vec<Vec<i32>>,
 134         }
 135         struct Foo {
 136             bar: Vec<i32>,
 137         }
 138         struct FooOuter {
 139             inner: Foo,
 140             inner_double: FooDouble,
 141         }
 142         let vfoo = vec![FooOuter {
 143             inner: Foo { bar: vec![0, 1, 2, 3] },
 144             inner_double: FooDouble {
 145                 bar: vec![vec![0, 1, 2, 3]],
 146             },
 147         }];
 148         let _ = vfoo
 149             .iter()
 150             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
 151             .is_some();
 152     }
 153
 154     fn index_field_projection() {
 155         struct Foo {
 156             bar: i32,
 157         }
 158         struct FooOuter {
 159             inner: Vec<Foo>,
 160         }
 161         let vfoo = vec![FooOuter {
 162             inner: vec![Foo { bar: 0 }],
 163         }];
 164         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
 165     }
 166
 167     fn double_deref_index_projection() {
 168         let vfoo = vec![&&[0, 1, 2, 3]];
 169         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
 170     }
 171
 172     fn method_call_by_ref() {
 173         struct Foo {
 174             bar: u32,
 175         }
 176         impl Foo {
 177             pub fn by_ref(&self, x: &u32) -> bool {
 178                 *x == self.bar
 179             }
 180         }
 181         let vfoo = vec![Foo { bar: 1 }];
 182         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
 183     }
 184
 185     fn ref_bindings() {
 186         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
 187         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
 188     }
 189
 190     fn test_string_1(s: &str) -> bool {
 191         s.is_empty()
 192     }
 193
 194     fn test_u32_1(s: &u32) -> bool {
 195         s.is_power_of_two()
 196     }
 197
 198     fn test_u32_2(s: u32) -> bool {
 199         s.is_power_of_two()
 200     }
 201
 202     fn projection_in_args_test() {
 203         // Index projections
 204         let lst = &[String::from("Hello"), String::from("world")];
 205         let v: Vec<&[String]> = vec![lst];
 206         let _ = v.iter().find(|s| s[0].is_empty()).is_some();
 207         let _ = v.iter().find(|s| test_string_1(&s[0])).is_some();
 208
 209         // Field projections
 210         struct FieldProjection<'a> {
 211             field: &'a u32,
 212         }
 213         let field = 123456789;
 214         let instance = FieldProjection { field: &field };
 215         let v = vec![instance];
 216         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_some();
 217         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_some();
 218         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
 219     }
 220 }
 221
 222 mod issue9120 {
 223     fn make_arg_no_deref_impl() -> impl Fn(&&u32) -> bool {
 224         move |x: &&u32| **x == 78
 225     }
 226
 227     fn make_arg_no_deref_dyn() -> Box<dyn Fn(&&u32) -> bool> {
 228         Box::new(move |x: &&u32| **x == 78)
 229     }
 230
 231     fn wrapper<T: Fn(&&u32) -> bool>(v: Vec<u32>, func: T) -> bool {
 232         #[allow(clippy::redundant_closure)]
 233         v.iter().find(|x: &&u32| func(x)).is_some()
 234     }
 235
 236     fn do_tests() {
 237         let v = vec![3, 2, 1, 0];
 238         let arg_no_deref_impl = make_arg_no_deref_impl();
 239         let arg_no_deref_dyn = make_arg_no_deref_dyn();
 240
 241         #[allow(clippy::redundant_closure)]
 242         let _ = v.iter().find(|x: &&u32| arg_no_deref_impl(x)).is_some();
 243
 244         #[allow(clippy::redundant_closure)]
 245         let _ = v.iter().find(|x: &&u32| arg_no_deref_dyn(x)).is_some();
 246
 247         #[allow(clippy::redundant_closure)]
 248         let _ = v.iter().find(|x: &&u32| (*arg_no_deref_dyn)(x)).is_some();
 249     }
 250 }