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
123
124
125
126
127
128
129
130
131
132
|
// 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)));
let cond = true;
// 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)));
let _ = cond.then_some(astronomers_pi);
// 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));
let _: Result<usize, usize> = res.
// some lines
// some lines
// some lines
// some lines
// some lines
// some lines
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));
}
|
