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

   1 // run-rustfix
   2 #![allow(dead_code)]
   3 #![warn(clippy::manual_find_map)]
   4 #![allow(clippy::redundant_closure)] // FIXME suggestion may have redundant closure
   5
   6 fn main() {
   7     // is_some(), unwrap()
   8     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
   9
  10     // ref pattern, expect()
  11     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
  12
  13     // is_ok(), unwrap_or()
  14     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
  15
  16     let _ = (1..5)
  17         .find(|&x| to_ref(to_opt(x)).is_some())
  18         .map(|y| to_ref(to_opt(y)).unwrap());
  19     let _ = (1..5)
  20         .find(|x| to_ref(to_opt(*x)).is_some())
  21         .map(|y| to_ref(to_opt(y)).unwrap());
  22
  23     let _ = (1..5)
  24         .find(|&x| to_ref(to_res(x)).is_ok())
  25         .map(|y| to_ref(to_res(y)).unwrap());
  26     let _ = (1..5)
  27         .find(|x| to_ref(to_res(*x)).is_ok())
  28         .map(|y| to_ref(to_res(y)).unwrap());
  29 }
  30
  31 #[rustfmt::skip]
  32 fn simple_equal() {
  33     iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
  34     iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
  35     iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
  36     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
  37     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
  38     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
  39     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
  40
  41     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
  42     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
  43     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
  44     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
  45     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
  46     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
  47     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
  48 }
  49
  50 fn no_lint() {
  51     // no shared code
  52     let _ = (0..).filter(|n| *n > 1).map(|n| n + 1);
  53
  54     // very close but different since filter() provides a reference
  55     let _ = (0..).find(|n| to_opt(n).is_some()).map(|a| to_opt(a).unwrap());
  56
  57     // similar but different
  58     let _ = (0..).find(|n| to_opt(n).is_some()).map(|n| to_res(n).unwrap());
  59     let _ = (0..)
  60         .find(|n| to_opt(n).map(|n| n + 1).is_some())
  61         .map(|a| to_opt(a).unwrap());
  62 }
  63
  64 fn iter<T>() -> impl Iterator<Item = T> {
  65     std::iter::empty()
  66 }
  67
  68 fn to_opt<T>(_: T) -> Option<T> {
  69     unimplemented!()
  70 }
  71
  72 fn to_res<T>(_: T) -> Result<T, ()> {
  73     unimplemented!()
  74 }
  75
  76 fn to_ref<'a, T>(_: T) -> &'a T {
  77     unimplemented!()
  78 }
  79
  80 struct Issue8920<'a> {
  81     option_field: Option<String>,
  82     result_field: Result<String, ()>,
  83     ref_field: Option<&'a usize>,
  84 }
  85
  86 fn issue_8920() {
  87     let mut vec = vec![Issue8920 {
  88         option_field: Some(String::from("str")),
  89         result_field: Ok(String::from("str")),
  90         ref_field: Some(&1),
  91     }];
  92
  93     let _ = vec
  94         .iter()
  95         .find(|f| f.option_field.is_some())
  96         .map(|f| f.option_field.clone().unwrap());
  97
  98     let _ = vec
  99         .iter()
 100         .find(|f| f.ref_field.is_some())
 101         .map(|f| f.ref_field.cloned().unwrap());
 102
 103     let _ = vec
 104         .iter()
 105         .find(|f| f.ref_field.is_some())
 106         .map(|f| f.ref_field.copied().unwrap());
 107
 108     let _ = vec
 109         .iter()
 110         .find(|f| f.result_field.is_ok())
 111         .map(|f| f.result_field.clone().unwrap());
 112
 113     let _ = vec
 114         .iter()
 115         .find(|f| f.result_field.is_ok())
 116         .map(|f| f.result_field.as_ref().unwrap());
 117
 118     let _ = vec
 119         .iter()
 120         .find(|f| f.result_field.is_ok())
 121         .map(|f| f.result_field.as_deref().unwrap());
 122
 123     let _ = vec
 124         .iter_mut()
 125         .find(|f| f.result_field.is_ok())
 126         .map(|f| f.result_field.as_mut().unwrap());
 127
 128     let _ = vec
 129         .iter_mut()
 130         .find(|f| f.result_field.is_ok())
 131         .map(|f| f.result_field.as_deref_mut().unwrap());
 132
 133     let _ = vec
 134         .iter()
 135         .find(|f| f.result_field.is_ok())
 136         .map(|f| f.result_field.to_owned().unwrap());
 137 }