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

Auto merge of #6197 - ThibsG:ImproveFilterNext, r=ebroto

Browse Source 
Improve suggestions for several lints

This PR is a follow-up of this [Zulip discussion](https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/filter_next.20lint).

It unifies placeholders for `methods` module and improves several suggestions for `filter_next`, `filter_map_next` and `map_unwrap_or` lints.

changelog: none
This commit is contained in:
bors 2020-10-30 21:58:09 +00:00
commit 7387b87bb9
22 changed files with 333 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
clippy_lints/src/methods/mod.rs
View File

@ -32,8 +32,7 @@
is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath, is_copy, is_expn_of, is_type_diagnostic_item, iter_input_pats, last_path_segment, match_def_path, match_qpath,
match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty, match_trait_method, match_type, match_var, method_calls, method_chain_args, paths, remove_blocks, return_ty,
single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint, single_segment_path, snippet, snippet_with_applicability, snippet_with_macro_callsite, span_lint,
span_lint_and_help, span_lint_and_note, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, span_lint_and_help, span_lint_and_sugg, span_lint_and_then, sugg, walk_ptrs_ty_depth, SpanlessEq,
SpanlessEq,
}; };
declare_clippy_lint! { declare_clippy_lint! {
@ -1735,7 +1734,7 @@ fn check_unwrap_or_default(
"try this", "try this",
format!( format!(
"{}.unwrap_or_default()", "{}.unwrap_or_default()",
snippet_with_applicability(cx, self_expr.span, "_", &mut applicability) snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
), ),
applicability, applicability,
); );
@ -2142,7 +2141,7 @@ fn lint_clone_on_ref_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::
return; return;
}; };
let snippet = snippet_with_macro_callsite(cx, arg.span, "_"); let snippet = snippet_with_macro_callsite(cx, arg.span, "..");
span_lint_and_sugg( span_lint_and_sugg(
cx, cx,
@ -2178,9 +2177,9 @@ fn lint_string_extend(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::E
"try this", "try this",
format!( format!(
"{}.push_str({}{})", "{}.push_str({}{})",
snippet_with_applicability(cx, args[0].span, "_", &mut applicability), snippet_with_applicability(cx, args[0].span, "..", &mut applicability),
ref_str, ref_str,
snippet_with_applicability(cx, target.span, "_", &mut applicability) snippet_with_applicability(cx, target.span, "..", &mut applicability)
), ),
applicability, applicability,
); );
@ -2427,7 +2426,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
let mut applicability = Applicability::MachineApplicable; let mut applicability = Applicability::MachineApplicable;
let expr_ty = cx.typeck_results().expr_ty(&get_args[0]); let expr_ty = cx.typeck_results().expr_ty(&get_args[0]);
let get_args_str = if get_args.len() > 1 { let get_args_str = if get_args.len() > 1 {
snippet_with_applicability(cx, get_args[1].span, "_", &mut applicability) snippet_with_applicability(cx, get_args[1].span, "..", &mut applicability)
} else { } else {
return; // not linting on a .get().unwrap() chain or variant return; // not linting on a .get().unwrap() chain or variant
}; };
@ -2487,7 +2486,7 @@ fn lint_get_unwrap<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, get_args:
format!( format!(
"{}{}[{}]", "{}{}[{}]",
borrow_str, borrow_str,
snippet_with_applicability(cx, get_args[0].span, "_", &mut applicability), snippet_with_applicability(cx, get_args[0].span, "..", &mut applicability),
get_args_str get_args_str
), ),
applicability, applicability,
@ -2503,7 +2502,7 @@ fn lint_iter_skip_next(cx: &LateContext<'_>, expr: &hir::Expr<'_>, skip_args: &[
cx, cx,
ITER_SKIP_NEXT, ITER_SKIP_NEXT,
expr.span.trim_start(caller.span).unwrap(), expr.span.trim_start(caller.span).unwrap(),
"called `skip(x).next()` on an iterator", "called `skip(..).next()` on an iterator",
"use `nth` instead", "use `nth` instead",
hint, hint,
Applicability::MachineApplicable, Applicability::MachineApplicable,
@ -2706,11 +2705,11 @@ fn lint_map_unwrap_or_else<'tcx>(
// lint message // lint message
let msg = if is_option { let msg = if is_option {
"called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling \ "called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling \
`map_or_else(g, f)` instead" `map_or_else(<g>, <f>)` instead"
} else { } else {
"called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling \ "called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling \
`.map_or_else(g, f)` instead" `.map_or_else(<g>, <f>)` instead"
}; };
// get snippets for args to map() and unwrap_or_else() // get snippets for args to map() and unwrap_or_else()
let map_snippet = snippet(cx, map_args[1].span, ".."); let map_snippet = snippet(cx, map_args[1].span, "..");
@ -2720,16 +2719,15 @@ fn lint_map_unwrap_or_else<'tcx>(
let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1; let multiline = map_snippet.lines().count() > 1 || unwrap_snippet.lines().count() > 1;
let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt(); let same_span = map_args[1].span.ctxt() == unwrap_args[1].span.ctxt();
if same_span && !multiline { if same_span && !multiline {
span_lint_and_note( let var_snippet = snippet(cx, map_args[0].span, "..");
span_lint_and_sugg(
cx, cx,
MAP_UNWRAP_OR, MAP_UNWRAP_OR,
expr.span, expr.span,
msg, msg,
None, "try this",
&format!( format!("{}.map_or_else({}, {})", var_snippet, unwrap_snippet, map_snippet),
"replace `map({0}).unwrap_or_else({1})` with `map_or_else({1}, {0})`", Applicability::MachineApplicable,
map_snippet, unwrap_snippet,
),
); );
return true; return true;
} else if same_span && multiline { } else if same_span && multiline {
@ -2776,8 +2774,8 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
if is_option { if is_option {
let self_snippet = snippet(cx, map_or_args[0].span, ".."); let self_snippet = snippet(cx, map_or_args[0].span, "..");
let func_snippet = snippet(cx, map_or_args[2].span, ".."); let func_snippet = snippet(cx, map_or_args[2].span, "..");
let msg = "called `map_or(None, f)` on an `Option` value. This can be done more directly by calling \ let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
`and_then(f)` instead"; `and_then(..)` instead";
( (
OPTION_MAP_OR_NONE, OPTION_MAP_OR_NONE,
msg, msg,
@ -2815,18 +2813,20 @@ fn lint_map_or_none<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, map
fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) { fn lint_filter_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
// lint if caller of `.filter().next()` is an Iterator // lint if caller of `.filter().next()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling \ let msg = "called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
`.find(p)` instead."; `.find(..)` instead.";
let filter_snippet = snippet(cx, filter_args[1].span, ".."); let filter_snippet = snippet(cx, filter_args[1].span, "..");
if filter_snippet.lines().count() <= 1 { if filter_snippet.lines().count() <= 1 {
let iter_snippet = snippet(cx, filter_args[0].span, "..");
// add note if not multi-line // add note if not multi-line
span_lint_and_note( span_lint_and_sugg(
cx, cx,
FILTER_NEXT, FILTER_NEXT,
expr.span, expr.span,
msg, msg,
None, "try this",
&format!("replace `filter({0}).next()` with `find({0})`", filter_snippet), format!("{}.find({})", iter_snippet, filter_snippet),
Applicability::MachineApplicable,
); );
} else { } else {
span_lint(cx, FILTER_NEXT, expr.span, msg); span_lint(cx, FILTER_NEXT, expr.span, msg);
@ -2846,9 +2846,9 @@ fn lint_skip_while_next<'tcx>(
cx, cx,
SKIP_WHILE_NEXT, SKIP_WHILE_NEXT,
expr.span, expr.span,
"called `skip_while(p).next()` on an `Iterator`", "called `skip_while(<p>).next()` on an `Iterator`",
None, None,
"this is more succinctly expressed by calling `.find(!p)` instead", "this is more succinctly expressed by calling `.find(!<p>)` instead",
); );
} }
} }
@ -2862,7 +2862,7 @@ fn lint_filter_map<'tcx>(
) { ) {
// lint if caller of `.filter().map()` is an Iterator // lint if caller of `.filter().map()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter(p).map(q)` on an `Iterator`"; let msg = "called `filter(..).map(..)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead"; let hint = "this is more succinctly expressed by calling `.filter_map(..)` instead";
span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint); span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
} }
@ -2871,17 +2871,19 @@ fn lint_filter_map<'tcx>(
/// lint use of `filter_map().next()` for `Iterators` /// lint use of `filter_map().next()` for `Iterators`
fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) { fn lint_filter_map_next<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, filter_args: &'tcx [hir::Expr<'_>]) {
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling \ let msg = "called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling \
`.find_map(p)` instead."; `.find_map(..)` instead.";
let filter_snippet = snippet(cx, filter_args[1].span, ".."); let filter_snippet = snippet(cx, filter_args[1].span, "..");
if filter_snippet.lines().count() <= 1 { if filter_snippet.lines().count() <= 1 {
span_lint_and_note( let iter_snippet = snippet(cx, filter_args[0].span, "..");
span_lint_and_sugg(
cx, cx,
FILTER_MAP_NEXT, FILTER_MAP_NEXT,
expr.span, expr.span,
msg, msg,
None, "try this",
&format!("replace `filter_map({0}).next()` with `find_map({0})`", filter_snippet), format!("{}.find_map({})", iter_snippet, filter_snippet),
Applicability::MachineApplicable,
); );
} else { } else {
span_lint(cx, FILTER_MAP_NEXT, expr.span, msg); span_lint(cx, FILTER_MAP_NEXT, expr.span, msg);
@ -2898,7 +2900,7 @@ fn lint_find_map<'tcx>(
) { ) {
// lint if caller of `.filter().map()` is an Iterator // lint if caller of `.filter().map()` is an Iterator
if match_trait_method(cx, &map_args[0], &paths::ITERATOR) { if match_trait_method(cx, &map_args[0], &paths::ITERATOR) {
let msg = "called `find(p).map(q)` on an `Iterator`"; let msg = "called `find(..).map(..)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.find_map(..)` instead"; let hint = "this is more succinctly expressed by calling `.find_map(..)` instead";
span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint); span_lint_and_help(cx, FIND_MAP, expr.span, msg, None, hint);
} }
@ -2913,7 +2915,7 @@ fn lint_filter_map_map<'tcx>(
) { ) {
// lint if caller of `.filter().map()` is an Iterator // lint if caller of `.filter().map()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter_map(p).map(q)` on an `Iterator`"; let msg = "called `filter_map(..).map(..)` on an `Iterator`";
let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead"; let hint = "this is more succinctly expressed by only calling `.filter_map(..)` instead";
span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint); span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
} }
@ -2928,7 +2930,7 @@ fn lint_filter_flat_map<'tcx>(
) { ) {
// lint if caller of `.filter().flat_map()` is an Iterator // lint if caller of `.filter().flat_map()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter(p).flat_map(q)` on an `Iterator`"; let msg = "called `filter(..).flat_map(..)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.flat_map(..)` \ let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
and filtering by returning `iter::empty()`"; and filtering by returning `iter::empty()`";
span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint); span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
@ -2944,7 +2946,7 @@ fn lint_filter_map_flat_map<'tcx>(
) { ) {
// lint if caller of `.filter_map().flat_map()` is an Iterator // lint if caller of `.filter_map().flat_map()` is an Iterator
if match_trait_method(cx, expr, &paths::ITERATOR) { if match_trait_method(cx, expr, &paths::ITERATOR) {
let msg = "called `filter_map(p).flat_map(q)` on an `Iterator`"; let msg = "called `filter_map(..).flat_map(..)` on an `Iterator`";
let hint = "this is more succinctly expressed by calling `.flat_map(..)` \ let hint = "this is more succinctly expressed by calling `.flat_map(..)` \
and filtering by returning `iter::empty()`"; and filtering by returning `iter::empty()`";
span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint); span_lint_and_help(cx, FILTER_MAP, expr.span, msg, None, hint);
@ -3115,9 +3117,9 @@ fn lint_chars_cmp(
"like this", "like this",
format!("{}{}.{}({})", format!("{}{}.{}({})",
if info.eq { "" } else { "!" }, if info.eq { "" } else { "!" },
snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability), snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
suggest, suggest,
snippet_with_applicability(cx, arg_char[0].span, "_", &mut applicability)), snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
applicability, applicability,
); );
@ -3164,7 +3166,7 @@ fn lint_chars_cmp_with_unwrap<'tcx>(
"like this", "like this",
format!("{}{}.{}('{}')", format!("{}{}.{}('{}')",
if info.eq { "" } else { "!" }, if info.eq { "" } else { "!" },
snippet_with_applicability(cx, args[0][0].span, "_", &mut applicability), snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
suggest, suggest,
c), c),
applicability, applicability,
@ -3239,7 +3241,7 @@ fn lint_single_char_pattern(cx: &LateContext<'_>, _expr: &hir::Expr<'_>, arg: &h
fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) { fn lint_single_char_push_string(cx: &LateContext<'_>, expr: &hir::Expr<'_>, args: &[hir::Expr<'_>]) {
let mut applicability = Applicability::MachineApplicable; let mut applicability = Applicability::MachineApplicable;
if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) { if let Some(extension_string) = get_hint_if_single_char_arg(cx, &args[1], &mut applicability) {
let base_string_snippet = snippet_with_applicability(cx, args[0].span, "_", &mut applicability); let base_string_snippet = snippet_with_applicability(cx, args[0].span, "..", &mut applicability);
let sugg = format!("{}.push({})", base_string_snippet, extension_string); let sugg = format!("{}.push({})", base_string_snippet, extension_string);
span_lint_and_sugg( span_lint_and_sugg(
cx, cx,
@ -3282,7 +3284,7 @@ fn lint_asref(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str, as_re
expr.span, expr.span,
&format!("this call to `{}` does nothing", call_name), &format!("this call to `{}` does nothing", call_name),
"try this", "try this",
snippet_with_applicability(cx, recvr.span, "_", &mut applicability).to_string(), snippet_with_applicability(cx, recvr.span, "..", &mut applicability).to_string(),
applicability, applicability,
); );
} }

8
clippy_lints/src/methods/option_map_unwrap_or.rs
View File

@ -53,15 +53,15 @@ pub(super) fn lint<'tcx>(
// lint message // lint message
// comparing the snippet from source to raw text ("None") below is safe // comparing the snippet from source to raw text ("None") below is safe
// because we already have checked the type. // because we already have checked the type.
let arg = if unwrap_snippet == "None" { "None" } else { "a" }; let arg = if unwrap_snippet == "None" { "None" } else { "<a>" };
let unwrap_snippet_none = unwrap_snippet == "None"; let unwrap_snippet_none = unwrap_snippet == "None";
let suggest = if unwrap_snippet_none { let suggest = if unwrap_snippet_none {
"and_then(f)" "and_then(<f>)"
} else { } else {
"map_or(a, f)" "map_or(<a>, <f>)"
}; };
let msg = &format!( let msg = &format!(
"called `map(f).unwrap_or({})` on an `Option` value. \ "called `map(<f>).unwrap_or({})` on an `Option` value. \
This can be done more directly by calling `{}` instead", This can be done more directly by calling `{}` instead",
arg, suggest arg, suggest
); );

3
tests/ui/filter_map_next.rs
View File

@ -3,9 +3,6 @@
fn main() { fn main() {
let a = ["1", "lol", "3", "NaN", "5"]; let a = ["1", "lol", "3", "NaN", "5"];
let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
assert_eq!(element, Some(1));
#[rustfmt::skip] #[rustfmt::skip]
let _: Option<u32> = vec![1, 2, 3, 4, 5, 6] let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
.into_iter() .into_iter()

17
tests/ui/filter_map_next.stderr
View File

@ -1,14 +1,5 @@
error: called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(p)` instead. error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
--> $DIR/filter_map_next.rs:6:32 --> $DIR/filter_map_next.rs:7:26
|
LL | let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::filter-map-next` implied by `-D warnings`
= note: replace `filter_map(|s| s.parse().ok()).next()` with `find_map(|s| s.parse().ok())`
error: called `filter_map(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(p)` instead.
--> $DIR/filter_map_next.rs:10:26
| |
LL | let _: Option<u32> = vec![1, 2, 3, 4, 5, 6] LL | let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
| __________________________^ | __________________________^
@ -19,6 +10,8 @@ LL | | if x == 2 {
LL | | }) LL | | })
LL | | .next(); LL | | .next();
| |_______________^ | |_______________^
|
= note: `-D clippy::filter-map-next` implied by `-D warnings`
error: aborting due to 2 previous errors error: aborting due to previous error

10
tests/ui/filter_map_next_fixable.fixed Normal file
View File

@ -0,0 +1,10 @@
// run-rustfix
#![warn(clippy::all, clippy::pedantic)]
fn main() {
let a = ["1", "lol", "3", "NaN", "5"];
let element: Option<i32> = a.iter().find_map(|s| s.parse().ok());
assert_eq!(element, Some(1));
}

10
tests/ui/filter_map_next_fixable.rs Normal file
View File

@ -0,0 +1,10 @@
// run-rustfix
#![warn(clippy::all, clippy::pedantic)]
fn main() {
let a = ["1", "lol", "3", "NaN", "5"];
let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
assert_eq!(element, Some(1));
}

10
tests/ui/filter_map_next_fixable.stderr Normal file
View File

@ -0,0 +1,10 @@
error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead.
--> $DIR/filter_map_next_fixable.rs:8:32
|
LL | let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `a.iter().find_map(|s| s.parse().ok())`
|
= note: `-D clippy::filter-map-next` implied by `-D warnings`
error: aborting due to previous error

8
tests/ui/filter_methods.stderr
View File

@ -1,4 +1,4 @@
error: called `filter(p).map(q)` on an `Iterator` error: called `filter(..).map(..)` on an `Iterator`
--> $DIR/filter_methods.rs:5:21 --> $DIR/filter_methods.rs:5:21
| |
LL | let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect(); LL | let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x * 2).collect();
@ -7,7 +7,7 @@ LL | let _: Vec<_> = vec![5; 6].into_iter().filter(|&x| x == 0).map(|x| x *
= note: `-D clippy::filter-map` implied by `-D warnings` = note: `-D clippy::filter-map` implied by `-D warnings`
= help: this is more succinctly expressed by calling `.filter_map(..)` instead = help: this is more succinctly expressed by calling `.filter_map(..)` instead
error: called `filter(p).flat_map(q)` on an `Iterator` error: called `filter(..).flat_map(..)` on an `Iterator`
--> $DIR/filter_methods.rs:7:21 --> $DIR/filter_methods.rs:7:21
| |
LL | let _: Vec<_> = vec![5_i8; 6] LL | let _: Vec<_> = vec![5_i8; 6]
@ -19,7 +19,7 @@ LL | | .flat_map(|x| x.checked_mul(2))
| |
= help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()` = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
error: called `filter_map(p).flat_map(q)` on an `Iterator` error: called `filter_map(..).flat_map(..)` on an `Iterator`
--> $DIR/filter_methods.rs:13:21 --> $DIR/filter_methods.rs:13:21
| |
LL | let _: Vec<_> = vec![5_i8; 6] LL | let _: Vec<_> = vec![5_i8; 6]
@ -31,7 +31,7 @@ LL | | .flat_map(|x| x.checked_mul(2))
| |
= help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()` = help: this is more succinctly expressed by calling `.flat_map(..)` and filtering by returning `iter::empty()`
error: called `filter_map(p).map(q)` on an `Iterator` error: called `filter_map(..).map(..)` on an `Iterator`
--> $DIR/filter_methods.rs:19:21 --> $DIR/filter_methods.rs:19:21
| |
LL | let _: Vec<_> = vec![5_i8; 6] LL | let _: Vec<_> = vec![5_i8; 6]

4
tests/ui/find_map.stderr
View File

@ -1,4 +1,4 @@
error: called `find(p).map(q)` on an `Iterator` error: called `find(..).map(..)` on an `Iterator`
--> $DIR/find_map.rs:20:26 --> $DIR/find_map.rs:20:26
| |
LL | let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap()); LL | let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s| s.parse().unwrap());
@ -7,7 +7,7 @@ LL | let _: Option<i32> = a.iter().find(|s| s.parse::<i32>().is_ok()).map(|s
= note: `-D clippy::find-map` implied by `-D warnings` = note: `-D clippy::find-map` implied by `-D warnings`
= help: this is more succinctly expressed by calling `.find_map(..)` instead = help: this is more succinctly expressed by calling `.find_map(..)` instead
error: called `find(p).map(q)` on an `Iterator` error: called `find(..).map(..)` on an `Iterator`
--> $DIR/find_map.rs:23:29 --> $DIR/find_map.rs:23:29
| |
LL | let _: Option<Flavor> = desserts_of_the_week LL | let _: Option<Flavor> = desserts_of_the_week

8
tests/ui/iter_skip_next.stderr
View File

@ -1,4 +1,4 @@
error: called `skip(x).next()` on an iterator error: called `skip(..).next()` on an iterator
--> $DIR/iter_skip_next.rs:15:28 --> $DIR/iter_skip_next.rs:15:28
| |
LL | let _ = some_vec.iter().skip(42).next(); LL | let _ = some_vec.iter().skip(42).next();
@ -6,19 +6,19 @@ LL | let _ = some_vec.iter().skip(42).next();
| |
= note: `-D clippy::iter-skip-next` implied by `-D warnings` = note: `-D clippy::iter-skip-next` implied by `-D warnings`
error: called `skip(x).next()` on an iterator error: called `skip(..).next()` on an iterator
--> $DIR/iter_skip_next.rs:16:36 --> $DIR/iter_skip_next.rs:16:36
| |
LL | let _ = some_vec.iter().cycle().skip(42).next(); LL | let _ = some_vec.iter().cycle().skip(42).next();
| ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)` | ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
error: called `skip(x).next()` on an iterator error: called `skip(..).next()` on an iterator
--> $DIR/iter_skip_next.rs:17:20 --> $DIR/iter_skip_next.rs:17:20
| |
LL | let _ = (1..10).skip(10).next(); LL | let _ = (1..10).skip(10).next();
| ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)` | ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
error: called `skip(x).next()` on an iterator error: called `skip(..).next()` on an iterator
--> $DIR/iter_skip_next.rs:18:33 --> $DIR/iter_skip_next.rs:18:33
| |
LL | let _ = &some_vec[..].iter().skip(3).next(); LL | let _ = &some_vec[..].iter().skip(3).next();

38
tests/ui/map_unwrap_or.rs
View File

@ -1,4 +1,3 @@
// FIXME: Add "run-rustfix" once it's supported for multipart suggestions
// aux-build:option_helpers.rs // aux-build:option_helpers.rs
#![warn(clippy::map_unwrap_or)] #![warn(clippy::map_unwrap_or)]
@ -47,10 +46,6 @@ fn option_methods() {
let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id); let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
// Check for `option.map(_).unwrap_or_else(_)` use. // Check for `option.map(_).unwrap_or_else(_)` use.
// single line case
let _ = opt.map(|x| x + 1)
// Should lint even though this call is on a separate line.
.unwrap_or_else(|| 0);
// Multi-line cases. // Multi-line cases.
let _ = opt.map(|x| { let _ = opt.map(|x| {
x + 1 x + 1
@ -60,37 +55,24 @@ fn option_methods() {
.unwrap_or_else(|| .unwrap_or_else(||
0 0
); );
// Macro case.
// Should not lint.
let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
// Issue #4144
{
let mut frequencies = HashMap::new();
let word = "foo";
frequencies
.get_mut(word)
.map(|count| {
*count += 1;
})
.unwrap_or_else(|| {
frequencies.insert(word.to_owned(), 1);
});
}
} }
#[rustfmt::skip]
fn result_methods() { fn result_methods() {
let res: Result<i32, ()> = Ok(1); let res: Result<i32, ()> = Ok(1);
// Check for `result.map(_).unwrap_or_else(_)` use. // Check for `result.map(_).unwrap_or_else(_)` use.
// single line case
let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line
// multi line cases // multi line cases
let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); let _ = res.map(|x| {
let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); x + 1
}
).unwrap_or_else(|_e| 0);
let _ = res.map(|x| x + 1)
.unwrap_or_else(|_e| {
0
});
// macro case // macro case
let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|e| 0); // should not lint let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|_e| 0); // should not lint
} }
fn main() { fn main() {

99
tests/ui/map_unwrap_or.stderr
View File

@ -1,5 +1,5 @@
error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
--> $DIR/map_unwrap_or.rs:17:13 --> $DIR/map_unwrap_or.rs:16:13
| |
LL | let _ = opt.map(|x| x + 1) LL | let _ = opt.map(|x| x + 1)
| _____________^ | _____________^
@ -8,13 +8,13 @@ LL | | .unwrap_or(0);
| |_____________________^ | |_____________________^
| |
= note: `-D clippy::map-unwrap-or` implied by `-D warnings` = note: `-D clippy::map-unwrap-or` implied by `-D warnings`
help: use `map_or(a, f)` instead help: use `map_or(<a>, <f>)` instead
| |
LL | let _ = opt.map_or(0, |x| x + 1); LL | let _ = opt.map_or(0, |x| x + 1);
| ^^^^^^ ^^ -- | ^^^^^^ ^^ --
error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
--> $DIR/map_unwrap_or.rs:21:13 --> $DIR/map_unwrap_or.rs:20:13
| |
LL | let _ = opt.map(|x| { LL | let _ = opt.map(|x| {
| _____________^ | _____________^
@ -23,7 +23,7 @@ LL | | }
LL | | ).unwrap_or(0); LL | | ).unwrap_or(0);
| |__________________^ | |__________________^
| |
help: use `map_or(a, f)` instead help: use `map_or(<a>, <f>)` instead
| |
LL | let _ = opt.map_or(0, |x| { LL | let _ = opt.map_or(0, |x| {
LL | x + 1 LL | x + 1
@ -31,8 +31,8 @@ LL | }
LL | ); LL | );
| |
error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
--> $DIR/map_unwrap_or.rs:25:13 --> $DIR/map_unwrap_or.rs:24:13
| |
LL | let _ = opt.map(|x| x + 1) LL | let _ = opt.map(|x| x + 1)
| _____________^ | _____________^
@ -41,26 +41,26 @@ LL | | 0
LL | | }); LL | | });
| |__________^ | |__________^
| |
help: use `map_or(a, f)` instead help: use `map_or(<a>, <f>)` instead
| |
LL | let _ = opt.map_or({ LL | let _ = opt.map_or({
LL | 0 LL | 0
LL | }, |x| x + 1); LL | }, |x| x + 1);
| |
error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
--> $DIR/map_unwrap_or.rs:30:13 --> $DIR/map_unwrap_or.rs:29:13
| |
LL | let _ = opt.map(|x| Some(x + 1)).unwrap_or(None); LL | let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
help: use `and_then(f)` instead help: use `and_then(<f>)` instead
| |
LL | let _ = opt.and_then(|x| Some(x + 1)); LL | let _ = opt.and_then(|x| Some(x + 1));
| ^^^^^^^^ -- | ^^^^^^^^ --
error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
--> $DIR/map_unwrap_or.rs:32:13 --> $DIR/map_unwrap_or.rs:31:13
| |
LL | let _ = opt.map(|x| { LL | let _ = opt.map(|x| {
| _____________^ | _____________^
@ -69,7 +69,7 @@ LL | | }
LL | | ).unwrap_or(None); LL | | ).unwrap_or(None);
| |_____________________^ | |_____________________^
| |
help: use `and_then(f)` instead help: use `and_then(<f>)` instead
| |
LL | let _ = opt.and_then(|x| { LL | let _ = opt.and_then(|x| {
LL | Some(x + 1) LL | Some(x + 1)
@ -77,8 +77,8 @@ LL | }
LL | ); LL | );
| |
error: called `map(f).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead error: called `map(<f>).unwrap_or(None)` on an `Option` value. This can be done more directly by calling `and_then(<f>)` instead
--> $DIR/map_unwrap_or.rs:36:13 --> $DIR/map_unwrap_or.rs:35:13
| |
LL | let _ = opt LL | let _ = opt
| _____________^ | _____________^
@ -86,35 +86,24 @@ LL | | .map(|x| Some(x + 1))
LL | | .unwrap_or(None); LL | | .unwrap_or(None);
| |________________________^ | |________________________^
| |
help: use `and_then(f)` instead help: use `and_then(<f>)` instead
| |
LL | .and_then(|x| Some(x + 1)); LL | .and_then(|x| Some(x + 1));
| ^^^^^^^^ -- | ^^^^^^^^ --
error: called `map(f).unwrap_or(a)` on an `Option` value. This can be done more directly by calling `map_or(a, f)` instead error: called `map(<f>).unwrap_or(<a>)` on an `Option` value. This can be done more directly by calling `map_or(<a>, <f>)` instead
--> $DIR/map_unwrap_or.rs:47:13 --> $DIR/map_unwrap_or.rs:46:13
| |
LL | let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id); LL | let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
help: use `map_or(a, f)` instead help: use `map_or(<a>, <f>)` instead
| |
LL | let _ = Some("prefix").map_or(id, |p| format!("{}.", p)); LL | let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
| ^^^^^^ ^^^ -- | ^^^^^^ ^^^ --
error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or.rs:51:13 --> $DIR/map_unwrap_or.rs:50:13
|
LL | let _ = opt.map(|x| x + 1)
| _____________^
LL | | // Should lint even though this call is on a separate line.
LL | | .unwrap_or_else(|| 0);
| |_____________________________^
|
= note: replace `map(|x| x + 1).unwrap_or_else(|| 0)` with `map_or_else(|| 0, |x| x + 1)`
error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead
--> $DIR/map_unwrap_or.rs:55:13
| |
LL | let _ = opt.map(|x| { LL | let _ = opt.map(|x| {
| _____________^ | _____________^
@ -123,8 +112,8 @@ LL | | }
LL | | ).unwrap_or_else(|| 0); LL | | ).unwrap_or_else(|| 0);
| |__________________________^ | |__________________________^
error: called `map(f).unwrap_or_else(g)` on an `Option` value. This can be done more directly by calling `map_or_else(g, f)` instead error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or.rs:59:13 --> $DIR/map_unwrap_or.rs:54:13
| |
LL | let _ = opt.map(|x| x + 1) LL | let _ = opt.map(|x| x + 1)
| _____________^ | _____________^
@ -133,29 +122,25 @@ LL | | 0
LL | | ); LL | | );
| |_________^ | |_________^
error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or.rs:88:13 --> $DIR/map_unwrap_or.rs:66:13
| |
LL | let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); // should lint even though this call is on a separate line LL | let _ = res.map(|x| {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | _____________^
| LL | | x + 1
= note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)` LL | | }
LL | | ).unwrap_or_else(|_e| 0);
| |____________________________^
error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or.rs:90:13 --> $DIR/map_unwrap_or.rs:70:13
| |
LL | let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0); LL | let _ = res.map(|x| x + 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | _____________^
| LL | | .unwrap_or_else(|_e| {
= note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)` LL | | 0
LL | | });
| |__________^
error: called `map(f).unwrap_or_else(g)` on a `Result` value. This can be done more directly by calling `.map_or_else(g, f)` instead error: aborting due to 11 previous errors
--> $DIR/map_unwrap_or.rs:91:13
|
LL | let _ = res.map(|x| x + 1).unwrap_or_else(|e| 0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: replace `map(|x| x + 1).unwrap_or_else(|e| 0)` with `map_or_else(|e| 0, |x| x + 1)`
error: aborting due to 13 previous errors

54
tests/ui/map_unwrap_or_fixable.fixed Normal file
View File

@ -0,0 +1,54 @@
// run-rustfix
// aux-build:option_helpers.rs
#![warn(clippy::map_unwrap_or)]
#[macro_use]
extern crate option_helpers;
use std::collections::HashMap;
#[rustfmt::skip]
fn option_methods() {
let opt = Some(1);
// Check for `option.map(_).unwrap_or_else(_)` use.
// single line case
let _ = opt.map_or_else(|| 0, |x| x + 1);
// Macro case.
// Should not lint.
let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
// Issue #4144
{
let mut frequencies = HashMap::new();
let word = "foo";
frequencies
.get_mut(word)
.map(|count| {
*count += 1;
})
.unwrap_or_else(|| {
frequencies.insert(word.to_owned(), 1);
});
}
}
#[rustfmt::skip]
fn result_methods() {
let res: Result<i32, ()> = Ok(1);
// Check for `result.map(_).unwrap_or_else(_)` use.
// single line case
let _ = res.map_or_else(|_e| 0, |x| x + 1);
// macro case
let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|_e| 0); // should not lint
}
fn main() {
option_methods();
result_methods();
}

58
tests/ui/map_unwrap_or_fixable.rs Normal file
View File

@ -0,0 +1,58 @@
// run-rustfix
// aux-build:option_helpers.rs
#![warn(clippy::map_unwrap_or)]
#[macro_use]
extern crate option_helpers;
use std::collections::HashMap;
#[rustfmt::skip]
fn option_methods() {
let opt = Some(1);
// Check for `option.map(_).unwrap_or_else(_)` use.
// single line case
let _ = opt.map(|x| x + 1)
// Should lint even though this call is on a separate line.
.unwrap_or_else(|| 0);
// Macro case.
// Should not lint.
let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);
// Issue #4144
{
let mut frequencies = HashMap::new();
let word = "foo";
frequencies
.get_mut(word)
.map(|count| {
*count += 1;
})
.unwrap_or_else(|| {
frequencies.insert(word.to_owned(), 1);
});
}
}
#[rustfmt::skip]
fn result_methods() {
let res: Result<i32, ()> = Ok(1);
// Check for `result.map(_).unwrap_or_else(_)` use.
// single line case
let _ = res.map(|x| x + 1)
// should lint even though this call is on a separate line
.unwrap_or_else(|_e| 0);
// macro case
let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|_e| 0); // should not lint
}
fn main() {
option_methods();
result_methods();
}

22
tests/ui/map_unwrap_or_fixable.stderr Normal file
View File

@ -0,0 +1,22 @@
error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value. This can be done more directly by calling `map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or_fixable.rs:17:13
|
LL | let _ = opt.map(|x| x + 1)
| _____________^
LL | | // Should lint even though this call is on a separate line.
LL | | .unwrap_or_else(|| 0);
| |_____________________________^ help: try this: `opt.map_or_else(|| 0, |x| x + 1)`
|
= note: `-D clippy::map-unwrap-or` implied by `-D warnings`
error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value. This can be done more directly by calling `.map_or_else(<g>, <f>)` instead
--> $DIR/map_unwrap_or_fixable.rs:47:13
|
LL | let _ = res.map(|x| x + 1)
| _____________^
LL | | // should lint even though this call is on a separate line
LL | | .unwrap_or_else(|_e| 0);
| |_______________________________^ help: try this: `res.map_or_else(|_e| 0, |x| x + 1)`
error: aborting due to 2 previous errors

5
tests/ui/methods.rs
View File

@ -122,16 +122,13 @@ fn mul(self, other: T) -> T {
fn filter_next() { fn filter_next() {
let v = vec![3, 2, 1, 0, -1, -2, -3]; let v = vec![3, 2, 1, 0, -1, -2, -3];
// Single-line case.
let _ = v.iter().filter(|&x| *x < 0).next();
// Multi-line case. // Multi-line case.
let _ = v.iter().filter(|&x| { let _ = v.iter().filter(|&x| {
*x < 0 *x < 0
} }
).next(); ).next();
// Check that hat we don't lint if the caller is not an `Iterator`. // Check that we don't lint if the caller is not an `Iterator`.
let foo = IteratorFalsePositives { foo: 0 }; let foo = IteratorFalsePositives { foo: 0 };
let _ = foo.filter().next(); let _ = foo.filter().next();
} }

33
tests/ui/methods.stderr
View File

@ -8,27 +8,20 @@ LL | | }
| |
= note: `-D clippy::new-ret-no-self` implied by `-D warnings` = note: `-D clippy::new-ret-no-self` implied by `-D warnings`
error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead. error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
--> $DIR/methods.rs:126:13 --> $DIR/methods.rs:126:13
| |
LL | let _ = v.iter().filter(|&x| *x < 0).next();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::filter-next` implied by `-D warnings`
= note: replace `filter(|&x| *x < 0).next()` with `find(|&x| *x < 0)`
error: called `filter(p).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(p)` instead.
--> $DIR/methods.rs:129:13
|
LL | let _ = v.iter().filter(|&x| { LL | let _ = v.iter().filter(|&x| {
| _____________^ | _____________^
LL | | *x < 0 LL | | *x < 0
LL | | } LL | | }
LL | | ).next(); LL | | ).next();
| |___________________________^ | |___________________________^
|
= note: `-D clippy::filter-next` implied by `-D warnings`
error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:146:22 --> $DIR/methods.rs:143:22
| |
LL | let _ = v.iter().find(|&x| *x < 0).is_some(); LL | let _ = v.iter().find(|&x| *x < 0).is_some();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x < 0)`
@ -36,25 +29,25 @@ LL | let _ = v.iter().find(|&x| *x < 0).is_some();
= note: `-D clippy::search-is-some` implied by `-D warnings` = note: `-D clippy::search-is-some` implied by `-D warnings`
error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:147:20 --> $DIR/methods.rs:144:20
| |
LL | let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less LL | let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| **y == x)`
error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:148:20 --> $DIR/methods.rs:145:20
| |
LL | let _ = (0..1).find(|x| *x == 0).is_some(); LL | let _ = (0..1).find(|x| *x == 0).is_some();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| x == 0)`
error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:149:22 --> $DIR/methods.rs:146:22
| |
LL | let _ = v.iter().find(|x| **x == 0).is_some(); LL | let _ = v.iter().find(|x| **x == 0).is_some();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|x| *x == 0)`
error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with find. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:152:13 --> $DIR/methods.rs:149:13
| |
LL | let _ = v.iter().find(|&x| { LL | let _ = v.iter().find(|&x| {
| _____________^ | _____________^
@ -64,13 +57,13 @@ LL | | ).is_some();
| |______________________________^ | |______________________________^
error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:158:22 --> $DIR/methods.rs:155:22
| |
LL | let _ = v.iter().position(|&x| x < 0).is_some(); LL | let _ = v.iter().position(|&x| x < 0).is_some();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with position. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:161:13 --> $DIR/methods.rs:158:13
| |
LL | let _ = v.iter().position(|&x| { LL | let _ = v.iter().position(|&x| {
| _____________^ | _____________^
@ -80,13 +73,13 @@ LL | | ).is_some();
| |______________________________^ | |______________________________^
error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:167:22 --> $DIR/methods.rs:164:22
| |
LL | let _ = v.iter().rposition(|&x| x < 0).is_some(); LL | let _ = v.iter().rposition(|&x| x < 0).is_some();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `any(|&x| x < 0)`
error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`. error: called `is_some()` after searching an `Iterator` with rposition. This is more succinctly expressed by calling `any()`.
--> $DIR/methods.rs:170:13 --> $DIR/methods.rs:167:13
| |
LL | let _ = v.iter().rposition(|&x| { LL | let _ = v.iter().rposition(|&x| {
| _____________^ | _____________^
@ -95,5 +88,5 @@ LL | | }
LL | | ).is_some(); LL | | ).is_some();
| |______________________________^ | |______________________________^
error: aborting due to 12 previous errors error: aborting due to 11 previous errors

11
tests/ui/methods_fixable.fixed Normal file
View File

@ -0,0 +1,11 @@
// run-rustfix
#![warn(clippy::filter_next)]
/// Checks implementation of `FILTER_NEXT` lint.
fn main() {
let v = vec![3, 2, 1, 0, -1, -2, -3];
// Single-line case.
let _ = v.iter().find(|&x| *x < 0);
}

11
tests/ui/methods_fixable.rs Normal file
View File

@ -0,0 +1,11 @@
// run-rustfix
#![warn(clippy::filter_next)]
/// Checks implementation of `FILTER_NEXT` lint.
fn main() {
let v = vec![3, 2, 1, 0, -1, -2, -3];
// Single-line case.
let _ = v.iter().filter(|&x| *x < 0).next();
}

10
tests/ui/methods_fixable.stderr Normal file
View File

@ -0,0 +1,10 @@
error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead.
--> $DIR/methods_fixable.rs:10:13
|
LL | let _ = v.iter().filter(|&x| *x < 0).next();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `v.iter().find(|&x| *x < 0)`
|
= note: `-D clippy::filter-next` implied by `-D warnings`
error: aborting due to previous error

4
tests/ui/option_map_or_none.stderr
View File

@ -1,4 +1,4 @@
error: called `map_or(None, f)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
--> $DIR/option_map_or_none.rs:10:13 --> $DIR/option_map_or_none.rs:10:13
| |
LL | let _ = opt.map_or(None, |x| Some(x + 1)); LL | let _ = opt.map_or(None, |x| Some(x + 1));
@ -6,7 +6,7 @@ LL | let _ = opt.map_or(None, |x| Some(x + 1));
| |
= note: `-D clippy::option-map-or-none` implied by `-D warnings` = note: `-D clippy::option-map-or-none` implied by `-D warnings`
error: called `map_or(None, f)` on an `Option` value. This can be done more directly by calling `and_then(f)` instead error: called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling `and_then(..)` instead
--> $DIR/option_map_or_none.rs:13:13 --> $DIR/option_map_or_none.rs:13:13
| |
LL | let _ = opt.map_or(None, |x| { LL | let _ = opt.map_or(None, |x| {

8
tests/ui/skip_while_next.stderr
View File

@ -1,13 +1,13 @@
error: called `skip_while(p).next()` on an `Iterator` error: called `skip_while(<p>).next()` on an `Iterator`
--> $DIR/skip_while_next.rs:14:13 --> $DIR/skip_while_next.rs:14:13
| |
LL | let _ = v.iter().skip_while(|&x| *x < 0).next(); LL | let _ = v.iter().skip_while(|&x| *x < 0).next();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: `-D clippy::skip-while-next` implied by `-D warnings` = note: `-D clippy::skip-while-next` implied by `-D warnings`
= help: this is more succinctly expressed by calling `.find(!p)` instead = help: this is more succinctly expressed by calling `.find(!<p>)` instead
error: called `skip_while(p).next()` on an `Iterator` error: called `skip_while(<p>).next()` on an `Iterator`
--> $DIR/skip_while_next.rs:17:13 --> $DIR/skip_while_next.rs:17:13
| |
LL | let _ = v.iter().skip_while(|&x| { LL | let _ = v.iter().skip_while(|&x| {
@ -17,7 +17,7 @@ LL | | }
LL | | ).next(); LL | | ).next();
| |___________________________^ | |___________________________^
| |
= help: this is more succinctly expressed by calling `.find(!p)` instead = help: this is more succinctly expressed by calling `.find(!<p>)` instead
error: aborting due to 2 previous errors error: aborting due to 2 previous errors