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

   1 // run-rustfix
   2 #![warn(clippy::unnecessary_lazy_evaluations)]
   3 #![allow(clippy::redundant_closure)]
   4 #![allow(clippy::bind_instead_of_map)]
   5 #![allow(clippy::map_identity)]
   6
   7 struct Deep(Option<usize>);
   8
   9 #[derive(Copy, Clone)]
  10 struct SomeStruct {
  11     some_field: usize,
  12 }
  13
  14 impl SomeStruct {
  15     fn return_some_field(&self) -> usize {
  16         self.some_field
  17     }
  18 }
  19
  20 fn some_call<T: Default>() -> T {
  21     T::default()
  22 }
  23
  24 fn main() {
  25     let astronomers_pi = 10;
  26     let ext_arr: [usize; 1] = [2];
  27     let ext_str = SomeStruct { some_field: 10 };
  28
  29     let mut opt = Some(42);
  30     let ext_opt = Some(42);
  31     let nested_opt = Some(Some(42));
  32     let nested_tuple_opt = Some(Some((42, 43)));
  33
  34     // Should lint - Option
  35     let _ = opt.unwrap_or_else(|| 2);
  36     let _ = opt.unwrap_or_else(|| astronomers_pi);
  37     let _ = opt.unwrap_or_else(|| ext_str.some_field);
  38     let _ = opt.unwrap_or_else(|| ext_arr[0]);
  39     let _ = opt.and_then(|_| ext_opt);
  40     let _ = opt.or_else(|| ext_opt);
  41     let _ = opt.or_else(|| None);
  42     let _ = opt.get_or_insert_with(|| 2);
  43     let _ = opt.ok_or_else(|| 2);
  44     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
  45
  46     // Cases when unwrap is not called on a simple variable
  47     let _ = Some(10).unwrap_or_else(|| 2);
  48     let _ = Some(10).and_then(|_| ext_opt);
  49     let _: Option<usize> = None.or_else(|| ext_opt);
  50     let _ = None.get_or_insert_with(|| 2);
  51     let _: Result<usize, usize> = None.ok_or_else(|| 2);
  52     let _: Option<usize> = None.or_else(|| None);
  53
  54     let mut deep = Deep(Some(42));
  55     let _ = deep.0.unwrap_or_else(|| 2);
  56     let _ = deep.0.and_then(|_| ext_opt);
  57     let _ = deep.0.or_else(|| None);
  58     let _ = deep.0.get_or_insert_with(|| 2);
  59     let _ = deep.0.ok_or_else(|| 2);
  60
  61     // Should not lint - Option
  62     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
  63     let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
  64     let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
  65     let _ = opt.or_else(some_call);
  66     let _ = opt.or_else(|| some_call());
  67     let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
  68     let _: Result<usize, usize> = opt.ok_or_else(some_call);
  69     let _ = deep.0.get_or_insert_with(|| some_call());
  70     let _ = deep.0.or_else(some_call);
  71     let _ = deep.0.or_else(|| some_call());
  72     let _ = opt.ok_or_else(|| ext_arr[0]);
  73
  74     // should not lint, bind_instead_of_map takes priority
  75     let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
  76     let _ = Some(10).and_then(|idx| Some(idx));
  77
  78     // should lint, bind_instead_of_map doesn't apply
  79     let _: Option<usize> = None.or_else(|| Some(3));
  80     let _ = deep.0.or_else(|| Some(3));
  81     let _ = opt.or_else(|| Some(3));
  82
  83     // Should lint - Result
  84     let res: Result<usize, usize> = Err(5);
  85     let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
  86
  87     let _ = res2.unwrap_or_else(|_| 2);
  88     let _ = res2.unwrap_or_else(|_| astronomers_pi);
  89     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
  90
  91     // Should not lint - Result
  92     let _ = res.unwrap_or_else(|err| err);
  93     let _ = res.unwrap_or_else(|err| ext_arr[err]);
  94     let _ = res2.unwrap_or_else(|err| err.some_field);
  95     let _ = res2.unwrap_or_else(|err| err.return_some_field());
  96     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
  97
  98     // should not lint, bind_instead_of_map takes priority
  99     let _: Result<usize, usize> = res.and_then(|x| Ok(x));
 100     let _: Result<usize, usize> = res.or_else(|err| Err(err));
 101
 102     let _: Result<usize, usize> = res.and_then(|_| Ok(2));
 103     let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
 104     let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 105
 106     let _: Result<usize, usize> = res.or_else(|_| Err(2));
 107     let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
 108     let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
 109
 110     // should lint, bind_instead_of_map doesn't apply
 111     let _: Result<usize, usize> = res.and_then(|_| Err(2));
 112     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
 113     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
 114
 115     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
 116     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
 117     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
 118
 119     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
 120     let _: Result<usize, usize> = res.and_then(|x| Err(x));
 121     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
 122 }