mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #13299 - alex-semenyuk:unwrap_or_else_suggestion, r=Alexendoo

Browse Source 
Fix suggestion unnecessary_lazy_eval

As mentioned at #13293 improve suggestion via span_suggestion_verbose

changelog: none
This commit is contained in:
bors 2024-08-24 12:29:08 +00:00
commit 301f2c46cd
3 changed files with 402 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clippy_lints/src/methods/unnecessary_lazy_eval.rs
View File

@ -64,9 +64,9 @@ pub(super) fn check<'tcx>(
// but prefer to avoid changing the signature of the function itself. // but prefer to avoid changing the signature of the function itself.
if let hir::ExprKind::MethodCall(.., span) = expr.kind { if let hir::ExprKind::MethodCall(.., span) = expr.kind {
span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| { span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
diag.span_suggestion( diag.span_suggestion_verbose(
span, span,
format!("use `{simplify_using}(..)` instead"), format!("use `{simplify_using}` instead"),
format!("{simplify_using}({})", snippet(cx, body_expr.span, "..")), format!("{simplify_using}({})", snippet(cx, body_expr.span, "..")),
applicability, applicability,
); );

566
tests/ui/unnecessary_lazy_eval.stderr
View File

@ -2,316 +2,432 @@ error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:83:13 --> tests/ui/unnecessary_lazy_eval.rs:83:13
| |
LL | let _ = opt.unwrap_or_else(|| 2); LL | let _ = opt.unwrap_or_else(|| 2);
| ^^^^-------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^
| |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)`
| |
= note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings` = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]` = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
help: use `unwrap_or` instead
|
LL | let _ = opt.unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:84:13 --> tests/ui/unnecessary_lazy_eval.rs:84:13
| |
LL | let _ = opt.unwrap_or_else(|| astronomers_pi); LL | let _ = opt.unwrap_or_else(|| astronomers_pi);
| ^^^^--------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)` help: use `unwrap_or` instead
|
LL | let _ = opt.unwrap_or(astronomers_pi);
| ~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:85:13 --> tests/ui/unnecessary_lazy_eval.rs:85:13
| |
LL | let _ = opt.unwrap_or_else(|| ext_str.some_field); LL | let _ = opt.unwrap_or_else(|| ext_str.some_field);
| ^^^^------------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)` help: use `unwrap_or` instead
|
LL | let _ = opt.unwrap_or(ext_str.some_field);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:87:13 --> tests/ui/unnecessary_lazy_eval.rs:87:13
| |
LL | let _ = opt.and_then(|_| ext_opt); LL | let _ = opt.and_then(|_| ext_opt);
| ^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(ext_opt)` help: use `and` instead
|
LL | let _ = opt.and(ext_opt);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:88:13 --> tests/ui/unnecessary_lazy_eval.rs:88:13
| |
LL | let _ = opt.or_else(|| ext_opt); LL | let _ = opt.or_else(|| ext_opt);
| ^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(ext_opt)` help: use `or` instead
|
LL | let _ = opt.or(ext_opt);
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:89:13 --> tests/ui/unnecessary_lazy_eval.rs:89:13
| |
LL | let _ = opt.or_else(|| None); LL | let _ = opt.or_else(|| None);
| ^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(None)` help: use `or` instead
|
LL | let _ = opt.or(None);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:90:13 --> tests/ui/unnecessary_lazy_eval.rs:90:13
| |
LL | let _ = opt.get_or_insert_with(|| 2); LL | let _ = opt.get_or_insert_with(|| 2);
| ^^^^------------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `get_or_insert(..)` instead: `get_or_insert(2)` help: use `get_or_insert` instead
|
LL | let _ = opt.get_or_insert(2);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:91:13 --> tests/ui/unnecessary_lazy_eval.rs:91:13
| |
LL | let _ = opt.ok_or_else(|| 2); LL | let _ = opt.ok_or_else(|| 2);
| ^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `ok_or(..)` instead: `ok_or(2)` help: use `ok_or` instead
|
LL | let _ = opt.ok_or(2);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:92:13 --> tests/ui/unnecessary_lazy_eval.rs:92:13
| |
LL | let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2))); LL | let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
| ^^^^^^^^^^^^^^^^^------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))` help: use `unwrap_or` instead
|
LL | let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:93:13 --> tests/ui/unnecessary_lazy_eval.rs:93:13
| |
LL | let _ = cond.then(|| astronomers_pi); LL | let _ = cond.then(|| astronomers_pi);
| ^^^^^----------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(astronomers_pi)` help: use `then_some` instead
|
LL | let _ = cond.then_some(astronomers_pi);
| ~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:94:13 --> tests/ui/unnecessary_lazy_eval.rs:94:13
| |
LL | let _ = true.then(|| -> _ {}); LL | let _ = true.then(|| -> _ {});
| ^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some({})` help: use `then_some` instead
|
LL | let _ = true.then_some({});
| ~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:95:13 --> tests/ui/unnecessary_lazy_eval.rs:95:13
| |
LL | let _ = true.then(|| {}); LL | let _ = true.then(|| {});
| ^^^^^----------- | ^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some({})` help: use `then_some` instead
|
LL | let _ = true.then_some({});
| ~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:99:13 --> tests/ui/unnecessary_lazy_eval.rs:99:13
| |
LL | let _ = Some(1).unwrap_or_else(|| *r); LL | let _ = Some(1).unwrap_or_else(|| *r);
| ^^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(*r)` help: use `unwrap_or` instead
|
LL | let _ = Some(1).unwrap_or(*r);
| ~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:101:13 --> tests/ui/unnecessary_lazy_eval.rs:101:13
| |
LL | let _ = Some(1).unwrap_or_else(|| *b); LL | let _ = Some(1).unwrap_or_else(|| *b);
| ^^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(*b)` help: use `unwrap_or` instead
|
LL | let _ = Some(1).unwrap_or(*b);
| ~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:103:13 --> tests/ui/unnecessary_lazy_eval.rs:103:13
| |
LL | let _ = Some(1).as_ref().unwrap_or_else(|| &r); LL | let _ = Some(1).as_ref().unwrap_or_else(|| &r);
| ^^^^^^^^^^^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(&r)` help: use `unwrap_or` instead
|
LL | let _ = Some(1).as_ref().unwrap_or(&r);
| ~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:104:13 --> tests/ui/unnecessary_lazy_eval.rs:104:13
| |
LL | let _ = Some(1).as_ref().unwrap_or_else(|| &b); LL | let _ = Some(1).as_ref().unwrap_or_else(|| &b);
| ^^^^^^^^^^^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(&b)` help: use `unwrap_or` instead
|
LL | let _ = Some(1).as_ref().unwrap_or(&b);
| ~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:107:13 --> tests/ui/unnecessary_lazy_eval.rs:107:13
| |
LL | let _ = Some(10).unwrap_or_else(|| 2); LL | let _ = Some(10).unwrap_or_else(|| 2);
| ^^^^^^^^^-------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)` help: use `unwrap_or` instead
|
LL | let _ = Some(10).unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:108:13 --> tests/ui/unnecessary_lazy_eval.rs:108:13
| |
LL | let _ = Some(10).and_then(|_| ext_opt); LL | let _ = Some(10).and_then(|_| ext_opt);
| ^^^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(ext_opt)` help: use `and` instead
|
LL | let _ = Some(10).and(ext_opt);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:109:28 --> tests/ui/unnecessary_lazy_eval.rs:109:28
| |
LL | let _: Option<usize> = None.or_else(|| ext_opt); LL | let _: Option<usize> = None.or_else(|| ext_opt);
| ^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(ext_opt)` help: use `or` instead
|
LL | let _: Option<usize> = None.or(ext_opt);
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:110:13 --> tests/ui/unnecessary_lazy_eval.rs:110:13
| |
LL | let _ = None.get_or_insert_with(|| 2); LL | let _ = None.get_or_insert_with(|| 2);
| ^^^^^------------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `get_or_insert(..)` instead: `get_or_insert(2)` help: use `get_or_insert` instead
|
LL | let _ = None.get_or_insert(2);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:111:35 --> tests/ui/unnecessary_lazy_eval.rs:111:35
| |
LL | let _: Result<usize, usize> = None.ok_or_else(|| 2); LL | let _: Result<usize, usize> = None.ok_or_else(|| 2);
| ^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `ok_or(..)` instead: `ok_or(2)` help: use `ok_or` instead
|
LL | let _: Result<usize, usize> = None.ok_or(2);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:112:28 --> tests/ui/unnecessary_lazy_eval.rs:112:28
| |
LL | let _: Option<usize> = None.or_else(|| None); LL | let _: Option<usize> = None.or_else(|| None);
| ^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(None)` help: use `or` instead
|
LL | let _: Option<usize> = None.or(None);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:115:13 --> tests/ui/unnecessary_lazy_eval.rs:115:13
| |
LL | let _ = deep.0.unwrap_or_else(|| 2); LL | let _ = deep.0.unwrap_or_else(|| 2);
| ^^^^^^^-------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)` help: use `unwrap_or` instead
|
LL | let _ = deep.0.unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:116:13 --> tests/ui/unnecessary_lazy_eval.rs:116:13
| |
LL | let _ = deep.0.and_then(|_| ext_opt); LL | let _ = deep.0.and_then(|_| ext_opt);
| ^^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(ext_opt)` help: use `and` instead
|
LL | let _ = deep.0.and(ext_opt);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:117:13 --> tests/ui/unnecessary_lazy_eval.rs:117:13
| |
LL | let _ = deep.0.or_else(|| None); LL | let _ = deep.0.or_else(|| None);
| ^^^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(None)` help: use `or` instead
|
LL | let _ = deep.0.or(None);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:118:13 --> tests/ui/unnecessary_lazy_eval.rs:118:13
| |
LL | let _ = deep.0.get_or_insert_with(|| 2); LL | let _ = deep.0.get_or_insert_with(|| 2);
| ^^^^^^^------------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `get_or_insert(..)` instead: `get_or_insert(2)` help: use `get_or_insert` instead
|
LL | let _ = deep.0.get_or_insert(2);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:119:13 --> tests/ui/unnecessary_lazy_eval.rs:119:13
| |
LL | let _ = deep.0.ok_or_else(|| 2); LL | let _ = deep.0.ok_or_else(|| 2);
| ^^^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `ok_or(..)` instead: `ok_or(2)` help: use `ok_or` instead
|
LL | let _ = deep.0.ok_or(2);
| ~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:150:28 --> tests/ui/unnecessary_lazy_eval.rs:150:28
| |
LL | let _: Option<usize> = None.or_else(|| Some(3)); LL | let _: Option<usize> = None.or_else(|| Some(3));
| ^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Some(3))` help: use `or` instead
|
LL | let _: Option<usize> = None.or(Some(3));
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:151:13 --> tests/ui/unnecessary_lazy_eval.rs:151:13
| |
LL | let _ = deep.0.or_else(|| Some(3)); LL | let _ = deep.0.or_else(|| Some(3));
| ^^^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Some(3))` help: use `or` instead
|
LL | let _ = deep.0.or(Some(3));
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Option::None` error: unnecessary closure used to substitute value for `Option::None`
--> tests/ui/unnecessary_lazy_eval.rs:152:13 --> tests/ui/unnecessary_lazy_eval.rs:152:13
| |
LL | let _ = opt.or_else(|| Some(3)); LL | let _ = opt.or_else(|| Some(3));
| ^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Some(3))` help: use `or` instead
|
LL | let _ = opt.or(Some(3));
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:158:13 --> tests/ui/unnecessary_lazy_eval.rs:158:13
| |
LL | let _ = res2.unwrap_or_else(|_| 2); LL | let _ = res2.unwrap_or_else(|_| 2);
| ^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)` help: use `unwrap_or` instead
|
LL | let _ = res2.unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:159:13 --> tests/ui/unnecessary_lazy_eval.rs:159:13
| |
LL | let _ = res2.unwrap_or_else(|_| astronomers_pi); LL | let _ = res2.unwrap_or_else(|_| astronomers_pi);
| ^^^^^---------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)` help: use `unwrap_or` instead
|
LL | let _ = res2.unwrap_or(astronomers_pi);
| ~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:160:13 --> tests/ui/unnecessary_lazy_eval.rs:160:13
| |
LL | let _ = res2.unwrap_or_else(|_| ext_str.some_field); LL | let _ = res2.unwrap_or_else(|_| ext_str.some_field);
| ^^^^^-------------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)` help: use `unwrap_or` instead
|
LL | let _ = res2.unwrap_or(ext_str.some_field);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:182:35 --> tests/ui/unnecessary_lazy_eval.rs:182:35
| |
LL | let _: Result<usize, usize> = res.and_then(|_| Err(2)); LL | let _: Result<usize, usize> = res.and_then(|_| Err(2));
| ^^^^-------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(Err(2))` help: use `and` instead
|
LL | let _: Result<usize, usize> = res.and(Err(2));
| ~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:183:35 --> tests/ui/unnecessary_lazy_eval.rs:183:35
| |
LL | let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi)); LL | let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
| ^^^^--------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(Err(astronomers_pi))` help: use `and` instead
|
LL | let _: Result<usize, usize> = res.and(Err(astronomers_pi));
| ~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:184:35 --> tests/ui/unnecessary_lazy_eval.rs:184:35
| |
LL | let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field)); LL | let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
| ^^^^------------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `and(..)` instead: `and(Err(ext_str.some_field))` help: use `and` instead
|
LL | let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:186:35 --> tests/ui/unnecessary_lazy_eval.rs:186:35
| |
LL | let _: Result<usize, usize> = res.or_else(|_| Ok(2)); LL | let _: Result<usize, usize> = res.or_else(|_| Ok(2));
| ^^^^------------------ | ^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Ok(2))` help: use `or` instead
|
LL | let _: Result<usize, usize> = res.or(Ok(2));
| ~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:187:35 --> tests/ui/unnecessary_lazy_eval.rs:187:35
| |
LL | let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi)); LL | let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
| ^^^^------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Ok(astronomers_pi))` help: use `or` instead
|
LL | let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
| ~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:188:35 --> tests/ui/unnecessary_lazy_eval.rs:188:35
| |
LL | let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field)); LL | let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
| ^^^^----------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `or(..)` instead: `or(Ok(ext_str.some_field))` help: use `or` instead
|
LL | let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval.rs:189:35 --> tests/ui/unnecessary_lazy_eval.rs:189:35
@ -324,193 +440,265 @@ LL | | // some lines
... | ... |
LL | | // some lines LL | | // some lines
LL | | or_else(|_| Ok(ext_str.some_field)); LL | | or_else(|_| Ok(ext_str.some_field));
| |_____----------------------------------^ | |_______________________________________^
| | |
| help: use `or(..)` instead: `or(Ok(ext_str.some_field))` help: use `or` instead
|
LL | or(Ok(ext_str.some_field));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:219:14 --> tests/ui/unnecessary_lazy_eval.rs:219:14
| |
LL | let _x = false.then(|| i32::MAX + 1); LL | let _x = false.then(|| i32::MAX + 1);
| ^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MAX + 1)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MAX + 1);
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:221:14 --> tests/ui/unnecessary_lazy_eval.rs:221:14
| |
LL | let _x = false.then(|| i32::MAX * 2); LL | let _x = false.then(|| i32::MAX * 2);
| ^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MAX * 2)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MAX * 2);
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:223:14 --> tests/ui/unnecessary_lazy_eval.rs:223:14
| |
LL | let _x = false.then(|| i32::MAX - 1); LL | let _x = false.then(|| i32::MAX - 1);
| ^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MAX - 1)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MAX - 1);
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:225:14 --> tests/ui/unnecessary_lazy_eval.rs:225:14
| |
LL | let _x = false.then(|| i32::MIN - 1); LL | let _x = false.then(|| i32::MIN - 1);
| ^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MIN - 1)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MIN - 1);
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:227:14 --> tests/ui/unnecessary_lazy_eval.rs:227:14
| |
LL | let _x = false.then(|| (1 + 2 * 3 - 2 / 3 + 9) << 2); LL | let _x = false.then(|| (1 + 2 * 3 - 2 / 3 + 9) << 2);
| ^^^^^^------------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some((1 + 2 * 3 - 2 / 3 + 9) << 2)` help: use `then_some` instead
|
LL | let _x = false.then_some((1 + 2 * 3 - 2 / 3 + 9) << 2);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:229:14 --> tests/ui/unnecessary_lazy_eval.rs:229:14
| |
LL | let _x = false.then(|| 255u8 << 7); LL | let _x = false.then(|| 255u8 << 7);
| ^^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(255u8 << 7)` help: use `then_some` instead
|
LL | let _x = false.then_some(255u8 << 7);
| ~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:231:14 --> tests/ui/unnecessary_lazy_eval.rs:231:14
| |
LL | let _x = false.then(|| 255u8 << 8); LL | let _x = false.then(|| 255u8 << 8);
| ^^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(255u8 << 8)` help: use `then_some` instead
|
LL | let _x = false.then_some(255u8 << 8);
| ~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:233:14 --> tests/ui/unnecessary_lazy_eval.rs:233:14
| |
LL | let _x = false.then(|| 255u8 >> 8); LL | let _x = false.then(|| 255u8 >> 8);
| ^^^^^^------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(255u8 >> 8)` help: use `then_some` instead
|
LL | let _x = false.then_some(255u8 >> 8);
| ~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:236:14 --> tests/ui/unnecessary_lazy_eval.rs:236:14
| |
LL | let _x = false.then(|| i32::MAX + -1); LL | let _x = false.then(|| i32::MAX + -1);
| ^^^^^^---------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MAX + -1)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MAX + -1);
| ~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:238:14 --> tests/ui/unnecessary_lazy_eval.rs:238:14
| |
LL | let _x = false.then(|| -i32::MAX); LL | let _x = false.then(|| -i32::MAX);
| ^^^^^^------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(-i32::MAX)` help: use `then_some` instead
|
LL | let _x = false.then_some(-i32::MAX);
| ~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:240:14 --> tests/ui/unnecessary_lazy_eval.rs:240:14
| |
LL | let _x = false.then(|| -i32::MIN); LL | let _x = false.then(|| -i32::MIN);
| ^^^^^^------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(-i32::MIN)` help: use `then_some` instead
|
LL | let _x = false.then_some(-i32::MIN);
| ~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:243:14 --> tests/ui/unnecessary_lazy_eval.rs:243:14
| |
LL | let _x = false.then(|| 255 >> -7); LL | let _x = false.then(|| 255 >> -7);
| ^^^^^^------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(255 >> -7)` help: use `then_some` instead
|
LL | let _x = false.then_some(255 >> -7);
| ~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:245:14 --> tests/ui/unnecessary_lazy_eval.rs:245:14
| |
LL | let _x = false.then(|| 255 << -1); LL | let _x = false.then(|| 255 << -1);
| ^^^^^^------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(255 << -1)` help: use `then_some` instead
|
LL | let _x = false.then_some(255 << -1);
| ~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:247:14 --> tests/ui/unnecessary_lazy_eval.rs:247:14
| |
LL | let _x = false.then(|| 1 / 0); LL | let _x = false.then(|| 1 / 0);
| ^^^^^^-------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(1 / 0)` help: use `then_some` instead
|
LL | let _x = false.then_some(1 / 0);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:249:14 --> tests/ui/unnecessary_lazy_eval.rs:249:14
| |
LL | let _x = false.then(|| x << -1); LL | let _x = false.then(|| x << -1);
| ^^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(x << -1)` help: use `then_some` instead
|
LL | let _x = false.then_some(x << -1);
| ~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:251:14 --> tests/ui/unnecessary_lazy_eval.rs:251:14
| |
LL | let _x = false.then(|| x << 2); LL | let _x = false.then(|| x << 2);
| ^^^^^^--------------- | ^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(x << 2)` help: use `then_some` instead
|
LL | let _x = false.then_some(x << 2);
| ~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:261:14 --> tests/ui/unnecessary_lazy_eval.rs:261:14
| |
LL | let _x = false.then(|| x / 0); LL | let _x = false.then(|| x / 0);
| ^^^^^^-------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(x / 0)` help: use `then_some` instead
|
LL | let _x = false.then_some(x / 0);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:263:14 --> tests/ui/unnecessary_lazy_eval.rs:263:14
| |
LL | let _x = false.then(|| x % 0); LL | let _x = false.then(|| x % 0);
| ^^^^^^-------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(x % 0)` help: use `then_some` instead
|
LL | let _x = false.then_some(x % 0);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:266:14 --> tests/ui/unnecessary_lazy_eval.rs:266:14
| |
LL | let _x = false.then(|| 1 / -1); LL | let _x = false.then(|| 1 / -1);
| ^^^^^^--------------- | ^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(1 / -1)` help: use `then_some` instead
|
LL | let _x = false.then_some(1 / -1);
| ~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:268:14 --> tests/ui/unnecessary_lazy_eval.rs:268:14
| |
LL | let _x = false.then(|| i32::MIN / -1); LL | let _x = false.then(|| i32::MIN / -1);
| ^^^^^^---------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MIN / -1)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MIN / -1);
| ~~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:271:14 --> tests/ui/unnecessary_lazy_eval.rs:271:14
| |
LL | let _x = false.then(|| i32::MIN / 0); LL | let _x = false.then(|| i32::MIN / 0);
| ^^^^^^--------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(i32::MIN / 0)` help: use `then_some` instead
|
LL | let _x = false.then_some(i32::MIN / 0);
| ~~~~~~~~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:273:14 --> tests/ui/unnecessary_lazy_eval.rs:273:14
| |
LL | let _x = false.then(|| 4 / 2); LL | let _x = false.then(|| 4 / 2);
| ^^^^^^-------------- | ^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(4 / 2)` help: use `then_some` instead
|
LL | let _x = false.then_some(4 / 2);
| ~~~~~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval.rs:281:14 --> tests/ui/unnecessary_lazy_eval.rs:281:14
| |
LL | let _x = false.then(|| f1 + f2); LL | let _x = false.then(|| f1 + f2);
| ^^^^^^---------------- | ^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some(f1 + f2)` help: use `then_some` instead
|
LL | let _x = false.then_some(f1 + f2);
| ~~~~~~~~~~~~~~~~~~
error: aborting due to 63 previous errors error: aborting due to 63 previous errors

35
tests/ui/unnecessary_lazy_eval_unfixable.stderr
View File

@ -2,36 +2,47 @@ error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval_unfixable.rs:13:13 --> tests/ui/unnecessary_lazy_eval_unfixable.rs:13:13
| |
LL | let _ = Ok(1).unwrap_or_else(|()| 2); LL | let _ = Ok(1).unwrap_or_else(|()| 2);
| ^^^^^^---------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)`
| |
= note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings` = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]` = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
help: use `unwrap_or` instead
|
LL | let _ = Ok(1).unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval_unfixable.rs:19:13 --> tests/ui/unnecessary_lazy_eval_unfixable.rs:19:13
| |
LL | let _ = Ok(1).unwrap_or_else(|e::E| 2); LL | let _ = Ok(1).unwrap_or_else(|e::E| 2);
| ^^^^^^------------------------ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)` help: use `unwrap_or` instead
|
LL | let _ = Ok(1).unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used to substitute value for `Result::Err` error: unnecessary closure used to substitute value for `Result::Err`
--> tests/ui/unnecessary_lazy_eval_unfixable.rs:21:13 --> tests/ui/unnecessary_lazy_eval_unfixable.rs:21:13
| |
LL | let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2); LL | let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
| ^^^^^^------------------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `unwrap_or(..)` instead: `unwrap_or(2)` help: use `unwrap_or` instead
|
LL | let _ = Ok(1).unwrap_or(2);
| ~~~~~~~~~~~~
error: unnecessary closure used with `bool::then` error: unnecessary closure used with `bool::then`
--> tests/ui/unnecessary_lazy_eval_unfixable.rs:31:13 --> tests/ui/unnecessary_lazy_eval_unfixable.rs:31:13
| |
LL | let _ = true.then(|| -> &[u8] { &[] }); LL | let _ = true.then(|| -> &[u8] { &[] });
| ^^^^^------------------------- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| help: use `then_some(..)` instead: `then_some({ &[] })` help: use `then_some` instead
|
LL | let _ = true.then_some({ &[] });
| ~~~~~~~~~~~~~~~~~~
error: aborting due to 4 previous errors error: aborting due to 4 previous errors