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

   1 // run-rustfix
   2 // aux-build: proc_macro_with_span.rs
   3 #![warn(clippy::unnecessary_lazy_evaluations)]
   4 #![allow(clippy::redundant_closure)]
   5 #![allow(clippy::bind_instead_of_map)]
   6 #![allow(clippy::map_identity)]
   7
   8 extern crate proc_macro_with_span;
   9 use proc_macro_with_span::with_span;
  10
  11 struct Deep(Option<usize>);
  12
  13 #[derive(Copy, Clone)]
  14 struct SomeStruct {
  15     some_field: usize,
  16 }
  17
  18 impl SomeStruct {
  19     fn return_some_field(&self) -> usize {
  20         self.some_field
  21     }
  22 }
  23
  24 fn some_call<T: Default>() -> T {
  25     T::default()
  26 }
  27
  28 struct Issue9427(i32);
  29
  30 impl Drop for Issue9427 {
  31     fn drop(&mut self) {
  32         println!("{}", self.0);
  33     }
  34 }
  35
  36 fn main() {
  37     let astronomers_pi = 10;
  38     let ext_arr: [usize; 1] = [2];
  39     let ext_str = SomeStruct { some_field: 10 };
  40
  41     let mut opt = Some(42);
  42     let ext_opt = Some(42);
  43     let nested_opt = Some(Some(42));
  44     let nested_tuple_opt = Some(Some((42, 43)));
  45     let cond = true;
  46
  47     // Should lint - Option
  48     let _ = opt.unwrap_or(2);
  49     let _ = opt.unwrap_or(astronomers_pi);
  50     let _ = opt.unwrap_or(ext_str.some_field);
  51     let _ = opt.unwrap_or_else(|| ext_arr[0]);
  52     let _ = opt.and(ext_opt);
  53     let _ = opt.or(ext_opt);
  54     let _ = opt.or(None);
  55     let _ = opt.get_or_insert(2);
  56     let _ = opt.ok_or(2);
  57     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
  58     let _ = cond.then_some(astronomers_pi);
  59
  60     // Cases when unwrap is not called on a simple variable
  61     let _ = Some(10).unwrap_or(2);
  62     let _ = Some(10).and(ext_opt);
  63     let _: Option<usize> = None.or(ext_opt);
  64     let _ = None.get_or_insert(2);
  65     let _: Result<usize, usize> = None.ok_or(2);
  66     let _: Option<usize> = None.or(None);
  67
  68     let mut deep = Deep(Some(42));
  69     let _ = deep.0.unwrap_or(2);
  70     let _ = deep.0.and(ext_opt);
  71     let _ = deep.0.or(None);
  72     let _ = deep.0.get_or_insert(2);
  73     let _ = deep.0.ok_or(2);
  74
  75     // Should not lint - Option
  76     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
  77     let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
  78     let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
  79     let _ = opt.or_else(some_call);
  80     let _ = opt.or_else(|| some_call());
  81     let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
  82     let _: Result<usize, usize> = opt.ok_or_else(some_call);
  83     let _ = deep.0.get_or_insert_with(|| some_call());
  84     let _ = deep.0.or_else(some_call);
  85     let _ = deep.0.or_else(|| some_call());
  86     let _ = opt.ok_or_else(|| ext_arr[0]);
  87
  88     // Should not lint - bool
  89     let _ = (0 == 1).then(|| Issue9427(0)); // Issue9427 has a significant drop
  90
  91     // should not lint, bind_instead_of_map takes priority
  92     let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
  93     let _ = Some(10).and_then(|idx| Some(idx));
  94
  95     // should lint, bind_instead_of_map doesn't apply
  96     let _: Option<usize> = None.or(Some(3));
  97     let _ = deep.0.or(Some(3));
  98     let _ = opt.or(Some(3));
  99
 100     // Should lint - Result
 101     let res: Result<usize, usize> = Err(5);
 102     let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
 103
 104     let _ = res2.unwrap_or(2);
 105     let _ = res2.unwrap_or(astronomers_pi);
 106     let _ = res2.unwrap_or(ext_str.some_field);
 107
 108     // Should not lint - Result
 109     let _ = res.unwrap_or_else(|err| err);
 110     let _ = res.unwrap_or_else(|err| ext_arr[err]);
 111     let _ = res2.unwrap_or_else(|err| err.some_field);
 112     let _ = res2.unwrap_or_else(|err| err.return_some_field());
 113     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
 114
 115     // should not lint, bind_instead_of_map takes priority
 116     let _: Result<usize, usize> = res.and_then(|x| Ok(x));
 117     let _: Result<usize, usize> = res.or_else(|err| Err(err));
 118
 119     let _: Result<usize, usize> = res.and_then(|_| Ok(2));
 120     let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
 121     let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
 122
 123     let _: Result<usize, usize> = res.or_else(|_| Err(2));
 124     let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
 125     let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
 126
 127     // should lint, bind_instead_of_map doesn't apply
 128     let _: Result<usize, usize> = res.and(Err(2));
 129     let _: Result<usize, usize> = res.and(Err(astronomers_pi));
 130     let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
 131
 132     let _: Result<usize, usize> = res.or(Ok(2));
 133     let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
 134     let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
 135     let _: Result<usize, usize> = res.
 136         // some lines
 137         // some lines
 138         // some lines
 139         // some lines
 140         // some lines
 141         // some lines
 142         or(Ok(ext_str.some_field));
 143
 144     // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
 145     let _: Result<usize, usize> = res.and_then(|x| Err(x));
 146     let _: Result<usize, usize> = res.or_else(|err| Ok(err));
 147 }
 148
 149 #[allow(unused)]
 150 fn issue9485() {
 151     // should not lint, is in proc macro
 152     with_span!(span Some(42).unwrap_or_else(|| 2););
 153 }