also suggest in the multi-line case

This used to be a workaround for a rustc diagnostics issue which has
since been resolved

Author: ada4a

clippy_lints/src/methods/filter_next.rs

@@ -41,40 +41,32 @@ pub(super) fn check(
         expr.span,
         format!("called `filter(..).{next_method}()` on an `{required_trait}`"),
         |diag| {
-            let sugg_msg = format!("use `.{find_method}(..)` instead");
-
             let mut app = Applicability::MachineApplicable;
-            // add note if not multi-line
             let filter_snippet = snippet_with_applicability(cx, filter_arg.span, "..", &mut app);
-            if filter_snippet.lines().count() <= 1 {
-                let iter_snippet = snippet_with_applicability(cx, recv.span, "..", &mut app);
-                let pat = if let Some(id) = path_to_local_with_projections(recv)
-                    && let Node::Pat(pat) = cx.tcx.hir_node(id)
-                    && let PatKind::Binding(BindingMode(_, Mutability::Not), _, ident, _) = pat.kind
-                {
-                    app = Applicability::Unspecified;
-                    Some((pat.span, ident))
-                } else {
-                    None
-                };
-
-                diag.span_suggestion_verbose(
-                    expr.span,
-                    sugg_msg,
-                    format!("{iter_snippet}.{find_method}({filter_snippet})"),
-                    app,
-                );
+            let iter_snippet = snippet_with_applicability(cx, recv.span, "..", &mut app);
 
-                if let Some((pat_span, ident)) = pat {
-                    diag.span_help(
-                        pat_span,
-                        format!(
-                            "you will also need to make `{ident}` mutable, because `{find_method}` takes `&mut self`"
-                        ),
-                    );
-                }
+            let pat = if let Some(id) = path_to_local_with_projections(recv)
+                && let Node::Pat(pat) = cx.tcx.hir_node(id)
+                && let PatKind::Binding(BindingMode(_, Mutability::Not), _, ident, _) = pat.kind
+            {
+                app = Applicability::Unspecified;
+                Some((pat.span, ident))
             } else {
-                diag.help(sugg_msg);
+                None
+            };
+
+            diag.span_suggestion_verbose(
+                expr.span,
+                format!("use `.{find_method}(..)` instead"),
+                format!("{iter_snippet}.{find_method}({filter_snippet})"),
+                app,
+            );
+
+            if let Some((pat_span, ident)) = pat {
+                diag.span_help(
+                    pat_span,
+                    format!("you will also need to make `{ident}` mutable, because `{find_method}` takes `&mut self`"),
+                );
             }
         },
     );

tests/ui/filter_next.fixed

@@ -19,6 +19,19 @@ fn filter_next() {
     let _ = v.iter().rfind(|&x| *x < 0);
     //~^ filter_next
 
+    // Multi-line case.
+    #[rustfmt::skip]
+    let _ = v.iter().find(|&x| {
+    //~^ filter_next
+                                *x < 0
+                            });
+
+    #[rustfmt::skip]
+    let _ = v.iter().rfind(|&x| {
+    //~^ filter_next
+                                *x < 0
+                            });
+
     // Check that we don't lint if the caller is not an `Iterator`.
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.filter().next();

tests/ui/filter_next.rs

@@ -19,6 +19,21 @@ fn filter_next() {
     let _ = v.iter().filter(|&x| *x < 0).next_back();
     //~^ filter_next
 
+    // Multi-line case.
+    #[rustfmt::skip]
+    let _ = v.iter().filter(|&x| {
+    //~^ filter_next
+                                *x < 0
+                            }
+                   ).next();
+
+    #[rustfmt::skip]
+    let _ = v.iter().filter(|&x| {
+    //~^ filter_next
+                                *x < 0
+                            }
+                   ).next_back();
+
     // Check that we don't lint if the caller is not an `Iterator`.
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.filter().next();

tests/ui/filter_next.stderr

@@ -24,8 +24,46 @@ LL -     let _ = v.iter().filter(|&x| *x < 0).next_back();
 LL +     let _ = v.iter().rfind(|&x| *x < 0);
    |
 
+error: called `filter(..).next()` on an `Iterator`
+  --> tests/ui/filter_next.rs:24:13
+   |
+LL |       let _ = v.iter().filter(|&x| {
+   |  _____________^
+LL | |
+LL | |                                 *x < 0
+LL | |                             }
+LL | |                    ).next();
+   | |___________________________^
+   |
+help: use `.find(..)` instead
+   |
+LL ~     let _ = v.iter().find(|&x| {
+LL +
+LL +                                 *x < 0
+LL ~                             });
+   |
+
+error: called `filter(..).next_back()` on an `DoubleEndedIterator`
+  --> tests/ui/filter_next.rs:31:13
+   |
+LL |       let _ = v.iter().filter(|&x| {
+   |  _____________^
+LL | |
+LL | |                                 *x < 0
+LL | |                             }
+LL | |                    ).next_back();
+   | |________________________________^
+   |
+help: use `.rfind(..)` instead
+   |
+LL ~     let _ = v.iter().rfind(|&x| {
+LL +
+LL +                                 *x < 0
+LL ~                             });
+   |
+
 error: called `filter(..).next_back()` on an `DoubleEndedIterator`
-  --> tests/ui/filter_next.rs:43:13
+  --> tests/ui/filter_next.rs:58:13
    |
 LL |     let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,5 +74,5 @@ LL -     let _ = vec![1].into_iter().filter(|&x| x < 0).next_back();
 LL +     let _ = vec![1].into_iter().rfind(|&x| x < 0);
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 5 previous errors
 

tests/ui/filter_next_unfixable.rs

@@ -1,23 +1,7 @@
 //@no-rustfix
 #![warn(clippy::filter_next)]
 
-#[rustfmt::skip]
-fn main() {
-    let v = [3, 2, 1, 0, -1, -2, -3];
-
-    // Multi-line case -- only a note is emitted
-    let _ = v.iter().filter(|&x| {
-    //~^ filter_next
-                                *x < 0
-                            }
-                   ).next();
-
-    let _ = v.iter().filter(|&x| {
-    //~^ filter_next
-                                *x < 0
-                            }
-                   ).next_back();
-}
+fn main() {}
 
 // The fixed version doesn't compile, as `iter` isn't `mut`.
 // We do emit a note suggesting adding it, but not an autofix

tests/ui/filter_next_unfixable.stderr

@@ -1,56 +1,30 @@
 error: called `filter(..).next()` on an `Iterator`
-  --> tests/ui/filter_next_unfixable.rs:9:13
-   |
-LL |       let _ = v.iter().filter(|&x| {
-   |  _____________^
-LL | |
-LL | |                                 *x < 0
-LL | |                             }
-LL | |                    ).next();
-   | |___________________________^
-   |
-   = help: use `.find(..)` instead
-   = note: `-D clippy::filter-next` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
-
-error: called `filter(..).next_back()` on an `DoubleEndedIterator`
-  --> tests/ui/filter_next_unfixable.rs:15:13
-   |
-LL |       let _ = v.iter().filter(|&x| {
-   |  _____________^
-LL | |
-LL | |                                 *x < 0
-LL | |                             }
-LL | |                    ).next_back();
-   | |________________________________^
-   |
-   = help: use `.rfind(..)` instead
-
-error: called `filter(..).next()` on an `Iterator`
-  --> tests/ui/filter_next_unfixable.rs:27:17
+  --> tests/ui/filter_next_unfixable.rs:11:17
    |
 LL |         let _ = iter.filter(|_| true).next();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: you will also need to make `iter` mutable, because `find` takes `&mut self`
-  --> tests/ui/filter_next_unfixable.rs:26:13
+  --> tests/ui/filter_next_unfixable.rs:10:13
    |
 LL |         let iter = (0..10);
    |             ^^^^
+   = note: `-D clippy::filter-next` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::filter_next)]`
 help: use `.find(..)` instead
    |
 LL -         let _ = iter.filter(|_| true).next();
 LL +         let _ = iter.find(|_| true);
    |
 
 error: called `filter(..).next_back()` on an `DoubleEndedIterator`
-  --> tests/ui/filter_next_unfixable.rs:32:17
+  --> tests/ui/filter_next_unfixable.rs:16:17
    |
 LL |         let _ = iter.filter(|_| true).next_back();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: you will also need to make `iter` mutable, because `rfind` takes `&mut self`
-  --> tests/ui/filter_next_unfixable.rs:31:13
+  --> tests/ui/filter_next_unfixable.rs:15:13
    |
 LL |         let iter = (0..10);
    |             ^^^^
@@ -60,5 +34,5 @@ LL -         let _ = iter.filter(|_| true).next_back();
 LL +         let _ = iter.rfind(|_| true);
    |
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors