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

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