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

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