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

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