tests/ui/unnecessary_lazy_eval.fixed

   1 // run-rustfix
   2 #![warn(clippy::unnecessary_lazy_evaluation)]
   3 #![allow(clippy::redundant_closure)]
   4 #![allow(clippy::bind_instead_of_map)]
   5
   6 struct Deep(Option<u32>);
   7
   8 #[derive(Copy, Clone)]
   9 struct SomeStruct {
  10     some_field: u32,
  11 }
  12
  13 impl SomeStruct {
  14     fn return_some_field(&self) -> u32 {
  15         self.some_field
  16     }
  17 }
  18
  19 fn some_call<T: Default>() -> T {
  20     T::default()
  21 }
  22
  23 fn main() {
  24     let astronomers_pi = 10;
  25     let ext_str = SomeStruct { some_field: 10 };
  26
  27     // Should lint - Option
  28     let mut opt = Some(42);
  29     let ext_opt = Some(42);
  30     let _ = opt.unwrap_or(2);
  31     let _ = opt.unwrap_or(astronomers_pi);
  32     let _ = opt.unwrap_or(ext_str.some_field);
  33     let _ = opt.and(ext_opt);
  34     let _ = opt.or(ext_opt);
  35     let _ = opt.or(None);
  36     let _ = opt.get_or_insert(2);
  37     let _ = opt.ok_or(2);
  38
  39     // Cases when unwrap is not called on a simple variable
  40     let _ = Some(10).unwrap_or(2);
  41     let _ = Some(10).and(ext_opt);
  42     let _: Option<u32> = None.or(ext_opt);
  43     let _ = None.get_or_insert(2);
  44     let _: Result<u32, u32> = None.ok_or(2);
  45     let _: Option<u32> = None.or(None);
  46
  47     let mut deep = Deep(Some(42));
  48     let _ = deep.0.unwrap_or(2);
  49     let _ = deep.0.and(ext_opt);
  50     let _ = deep.0.or(None);
  51     let _ = deep.0.get_or_insert(2);
  52     let _ = deep.0.ok_or(2);
  53
  54     // Should not lint - Option
  55     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
  56     let _ = opt.or_else(some_call);
  57     let _ = opt.or_else(|| some_call());
  58     let _: Result<u32, u32> = opt.ok_or_else(|| some_call());
  59     let _: Result<u32, u32> = opt.ok_or_else(some_call);
  60     let _ = deep.0.get_or_insert_with(|| some_call());
  61     let _ = deep.0.or_else(some_call);
  62     let _ = deep.0.or_else(|| some_call());
  63
  64     // These are handled by bind_instead_of_map
  65     let _: Option<u32> = None.or_else(|| Some(3));
  66     let _ = deep.0.or_else(|| Some(3));
  67     let _ = opt.or_else(|| Some(3));
  68
  69     // Should lint - Result
  70     let res: Result<u32, u32> = Err(5);
  71     let res2: Result<u32, SomeStruct> = Err(SomeStruct { some_field: 5 });
  72
  73     let _ = res2.unwrap_or(2);
  74     let _ = res2.unwrap_or(astronomers_pi);
  75     let _ = res2.unwrap_or(ext_str.some_field);
  76
  77     // Should not lint - Result
  78     let _ = res.unwrap_or_else(|err| err);
  79     let _ = res2.unwrap_or_else(|err| err.some_field);
  80     let _ = res2.unwrap_or_else(|err| err.return_some_field());
  81     let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
  82
  83     let _: Result<u32, u32> = res.and_then(|x| Ok(x));
  84     let _: Result<u32, u32> = res.and_then(|x| Err(x));
  85
  86     let _: Result<u32, u32> = res.or_else(|err| Ok(err));
  87     let _: Result<u32, u32> = res.or_else(|err| Err(err));
  88
  89     // These are handled by bind_instead_of_map
  90     let _: Result<u32, u32> = res.and_then(|_| Ok(2));
  91     let _: Result<u32, u32> = res.and_then(|_| Ok(astronomers_pi));
  92     let _: Result<u32, u32> = res.and_then(|_| Ok(ext_str.some_field));
  93
  94     let _: Result<u32, u32> = res.and_then(|_| Err(2));
  95     let _: Result<u32, u32> = res.and_then(|_| Err(astronomers_pi));
  96     let _: Result<u32, u32> = res.and_then(|_| Err(ext_str.some_field));
  97
  98     let _: Result<u32, u32> = res.or_else(|_| Ok(2));
  99     let _: Result<u32, u32> = res.or_else(|_| Ok(astronomers_pi));
 100     let _: Result<u32, u32> = res.or_else(|_| Ok(ext_str.some_field));
 101
 102     let _: Result<u32, u32> = res.or_else(|_| Err(2));
 103     let _: Result<u32, u32> = res.or_else(|_| Err(astronomers_pi));
 104     let _: Result<u32, u32> = res.or_else(|_| Err(ext_str.some_field));
 105 }