fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
12.8 KiB316 linesraw
1error: unnecessary closure used to substitute value for `Option::None`
2  --> $DIR/unnecessary_lazy_eval.rs:68:13
3   |
4LL |     let _ = opt.unwrap_or_else(|| 2);
5   |             ^^^^--------------------
6   |                 |
7   |                 help: use `unwrap_or(..)` instead: `unwrap_or(2)`
8   |
9   = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
10   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
11
12error: unnecessary closure used to substitute value for `Option::None`
13  --> $DIR/unnecessary_lazy_eval.rs:69:13
14   |
15LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
16   |             ^^^^---------------------------------
17   |                 |
18   |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
19
20error: unnecessary closure used to substitute value for `Option::None`
21  --> $DIR/unnecessary_lazy_eval.rs:70:13
22   |
23LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
24   |             ^^^^-------------------------------------
25   |                 |
26   |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
27
28error: unnecessary closure used to substitute value for `Option::None`
29  --> $DIR/unnecessary_lazy_eval.rs:72:13
30   |
31LL |     let _ = opt.and_then(|_| ext_opt);
32   |             ^^^^---------------------
33   |                 |
34   |                 help: use `and(..)` instead: `and(ext_opt)`
35
36error: unnecessary closure used to substitute value for `Option::None`
37  --> $DIR/unnecessary_lazy_eval.rs:73:13
38   |
39LL |     let _ = opt.or_else(|| ext_opt);
40   |             ^^^^-------------------
41   |                 |
42   |                 help: use `or(..)` instead: `or(ext_opt)`
43
44error: unnecessary closure used to substitute value for `Option::None`
45  --> $DIR/unnecessary_lazy_eval.rs:74:13
46   |
47LL |     let _ = opt.or_else(|| None);
48   |             ^^^^----------------
49   |                 |
50   |                 help: use `or(..)` instead: `or(None)`
51
52error: unnecessary closure used to substitute value for `Option::None`
53  --> $DIR/unnecessary_lazy_eval.rs:75:13
54   |
55LL |     let _ = opt.get_or_insert_with(|| 2);
56   |             ^^^^------------------------
57   |                 |
58   |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
59
60error: unnecessary closure used to substitute value for `Option::None`
61  --> $DIR/unnecessary_lazy_eval.rs:76:13
62   |
63LL |     let _ = opt.ok_or_else(|| 2);
64   |             ^^^^----------------
65   |                 |
66   |                 help: use `ok_or(..)` instead: `ok_or(2)`
67
68error: unnecessary closure used to substitute value for `Option::None`
69  --> $DIR/unnecessary_lazy_eval.rs:77:13
70   |
71LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
72   |             ^^^^^^^^^^^^^^^^^-------------------------------
73   |                              |
74   |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
75
76error: unnecessary closure used with `bool::then`
77  --> $DIR/unnecessary_lazy_eval.rs:78:13
78   |
79LL |     let _ = cond.then(|| astronomers_pi);
80   |             ^^^^^-----------------------
81   |                  |
82   |                  help: use `then_some(..)` instead: `then_some(astronomers_pi)`
83
84error: unnecessary closure used to substitute value for `Option::None`
85  --> $DIR/unnecessary_lazy_eval.rs:82:13
86   |
87LL |     let _ = Some(1).unwrap_or_else(|| *r);
88   |             ^^^^^^^^---------------------
89   |                     |
90   |                     help: use `unwrap_or(..)` instead: `unwrap_or(*r)`
91
92error: unnecessary closure used to substitute value for `Option::None`
93  --> $DIR/unnecessary_lazy_eval.rs:84:13
94   |
95LL |     let _ = Some(1).unwrap_or_else(|| *b);
96   |             ^^^^^^^^---------------------
97   |                     |
98   |                     help: use `unwrap_or(..)` instead: `unwrap_or(*b)`
99
100error: unnecessary closure used to substitute value for `Option::None`
101  --> $DIR/unnecessary_lazy_eval.rs:86:13
102   |
103LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
104   |             ^^^^^^^^^^^^^^^^^---------------------
105   |                              |
106   |                              help: use `unwrap_or(..)` instead: `unwrap_or(&r)`
107
108error: unnecessary closure used to substitute value for `Option::None`
109  --> $DIR/unnecessary_lazy_eval.rs:87:13
110   |
111LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
112   |             ^^^^^^^^^^^^^^^^^---------------------
113   |                              |
114   |                              help: use `unwrap_or(..)` instead: `unwrap_or(&b)`
115
116error: unnecessary closure used to substitute value for `Option::None`
117  --> $DIR/unnecessary_lazy_eval.rs:90:13
118   |
119LL |     let _ = Some(10).unwrap_or_else(|| 2);
120   |             ^^^^^^^^^--------------------
121   |                      |
122   |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
123
124error: unnecessary closure used to substitute value for `Option::None`
125  --> $DIR/unnecessary_lazy_eval.rs:91:13
126   |
127LL |     let _ = Some(10).and_then(|_| ext_opt);
128   |             ^^^^^^^^^---------------------
129   |                      |
130   |                      help: use `and(..)` instead: `and(ext_opt)`
131
132error: unnecessary closure used to substitute value for `Option::None`
133  --> $DIR/unnecessary_lazy_eval.rs:92:28
134   |
135LL |     let _: Option<usize> = None.or_else(|| ext_opt);
136   |                            ^^^^^-------------------
137   |                                 |
138   |                                 help: use `or(..)` instead: `or(ext_opt)`
139
140error: unnecessary closure used to substitute value for `Option::None`
141  --> $DIR/unnecessary_lazy_eval.rs:93:13
142   |
143LL |     let _ = None.get_or_insert_with(|| 2);
144   |             ^^^^^------------------------
145   |                  |
146   |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
147
148error: unnecessary closure used to substitute value for `Option::None`
149  --> $DIR/unnecessary_lazy_eval.rs:94:35
150   |
151LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
152   |                                   ^^^^^----------------
153   |                                        |
154   |                                        help: use `ok_or(..)` instead: `ok_or(2)`
155
156error: unnecessary closure used to substitute value for `Option::None`
157  --> $DIR/unnecessary_lazy_eval.rs:95:28
158   |
159LL |     let _: Option<usize> = None.or_else(|| None);
160   |                            ^^^^^----------------
161   |                                 |
162   |                                 help: use `or(..)` instead: `or(None)`
163
164error: unnecessary closure used to substitute value for `Option::None`
165  --> $DIR/unnecessary_lazy_eval.rs:98:13
166   |
167LL |     let _ = deep.0.unwrap_or_else(|| 2);
168   |             ^^^^^^^--------------------
169   |                    |
170   |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
171
172error: unnecessary closure used to substitute value for `Option::None`
173  --> $DIR/unnecessary_lazy_eval.rs:99:13
174   |
175LL |     let _ = deep.0.and_then(|_| ext_opt);
176   |             ^^^^^^^---------------------
177   |                    |
178   |                    help: use `and(..)` instead: `and(ext_opt)`
179
180error: unnecessary closure used to substitute value for `Option::None`
181  --> $DIR/unnecessary_lazy_eval.rs:100:13
182   |
183LL |     let _ = deep.0.or_else(|| None);
184   |             ^^^^^^^----------------
185   |                    |
186   |                    help: use `or(..)` instead: `or(None)`
187
188error: unnecessary closure used to substitute value for `Option::None`
189  --> $DIR/unnecessary_lazy_eval.rs:101:13
190   |
191LL |     let _ = deep.0.get_or_insert_with(|| 2);
192   |             ^^^^^^^------------------------
193   |                    |
194   |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
195
196error: unnecessary closure used to substitute value for `Option::None`
197  --> $DIR/unnecessary_lazy_eval.rs:102:13
198   |
199LL |     let _ = deep.0.ok_or_else(|| 2);
200   |             ^^^^^^^----------------
201   |                    |
202   |                    help: use `ok_or(..)` instead: `ok_or(2)`
203
204error: unnecessary closure used to substitute value for `Option::None`
205  --> $DIR/unnecessary_lazy_eval.rs:132:28
206   |
207LL |     let _: Option<usize> = None.or_else(|| Some(3));
208   |                            ^^^^^-------------------
209   |                                 |
210   |                                 help: use `or(..)` instead: `or(Some(3))`
211
212error: unnecessary closure used to substitute value for `Option::None`
213  --> $DIR/unnecessary_lazy_eval.rs:133:13
214   |
215LL |     let _ = deep.0.or_else(|| Some(3));
216   |             ^^^^^^^-------------------
217   |                    |
218   |                    help: use `or(..)` instead: `or(Some(3))`
219
220error: unnecessary closure used to substitute value for `Option::None`
221  --> $DIR/unnecessary_lazy_eval.rs:134:13
222   |
223LL |     let _ = opt.or_else(|| Some(3));
224   |             ^^^^-------------------
225   |                 |
226   |                 help: use `or(..)` instead: `or(Some(3))`
227
228error: unnecessary closure used to substitute value for `Result::Err`
229  --> $DIR/unnecessary_lazy_eval.rs:140:13
230   |
231LL |     let _ = res2.unwrap_or_else(|_| 2);
232   |             ^^^^^---------------------
233   |                  |
234   |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
235
236error: unnecessary closure used to substitute value for `Result::Err`
237  --> $DIR/unnecessary_lazy_eval.rs:141:13
238   |
239LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
240   |             ^^^^^----------------------------------
241   |                  |
242   |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
243
244error: unnecessary closure used to substitute value for `Result::Err`
245  --> $DIR/unnecessary_lazy_eval.rs:142:13
246   |
247LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
248   |             ^^^^^--------------------------------------
249   |                  |
250   |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
251
252error: unnecessary closure used to substitute value for `Result::Err`
253  --> $DIR/unnecessary_lazy_eval.rs:164:35
254   |
255LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
256   |                                   ^^^^--------------------
257   |                                       |
258   |                                       help: use `and(..)` instead: `and(Err(2))`
259
260error: unnecessary closure used to substitute value for `Result::Err`
261  --> $DIR/unnecessary_lazy_eval.rs:165:35
262   |
263LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
264   |                                   ^^^^---------------------------------
265   |                                       |
266   |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
267
268error: unnecessary closure used to substitute value for `Result::Err`
269  --> $DIR/unnecessary_lazy_eval.rs:166:35
270   |
271LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
272   |                                   ^^^^-------------------------------------
273   |                                       |
274   |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
275
276error: unnecessary closure used to substitute value for `Result::Err`
277  --> $DIR/unnecessary_lazy_eval.rs:168:35
278   |
279LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
280   |                                   ^^^^------------------
281   |                                       |
282   |                                       help: use `or(..)` instead: `or(Ok(2))`
283
284error: unnecessary closure used to substitute value for `Result::Err`
285  --> $DIR/unnecessary_lazy_eval.rs:169:35
286   |
287LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
288   |                                   ^^^^-------------------------------
289   |                                       |
290   |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
291
292error: unnecessary closure used to substitute value for `Result::Err`
293  --> $DIR/unnecessary_lazy_eval.rs:170:35
294   |
295LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
296   |                                   ^^^^-----------------------------------
297   |                                       |
298   |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
299
300error: unnecessary closure used to substitute value for `Result::Err`
301  --> $DIR/unnecessary_lazy_eval.rs:171:35
302   |
303LL |       let _: Result<usize, usize> = res.
304   |  ___________________________________^
305LL | |     // some lines
306LL | |     // some lines
307LL | |     // some lines
308...  |
309LL | |     // some lines
310LL | |     or_else(|_| Ok(ext_str.some_field));
311   | |_____----------------------------------^
312   |       |
313   |       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
314
315error: aborting due to 38 previous errors
316