]>
Commit | Line | Data |
---|---|---|
f20569fa XL |
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 | } |