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