Extend iter_on lints to catch more cases

Author: Centri3

clippy_lints/src/dereference.rs

@@ -37,6 +37,7 @@ use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::collections::VecDeque;
+use std::iter::once;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -455,7 +456,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
                                     && cx.tcx.infer_ctxt().build()
                                         .type_implements_trait(
                                             trait_id,
-                                            [impl_ty.into()].into_iter().chain(subs.iter().copied()),
+                                            once(impl_ty.into()).chain(subs.iter().copied()),
                                             cx.param_env,
                                         )
                                         .must_apply_modulo_regions()

clippy_lints/src/manual_strip.rs

@@ -1,3 +1,5 @@
+use std::iter::once;
+
 use clippy_utils::consts::{constant, Constant};
 use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
@@ -112,11 +114,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                         multispan_sugg(
                             diag,
                             &format!("try using the `strip_{kind_word}` method"),
-                            vec![(test_span,
+                            once((test_span,
                                   format!("if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
                                           snippet(cx, target_arg.span, ".."),
-                                          snippet(cx, pattern.span, "..")))]
-                            .into_iter().chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+                                          snippet(cx, pattern.span, ".."))))
+                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
                         );
                     });
                 }

clippy_lints/src/methods/iter_on_single_or_empty_collections.rs

@@ -42,7 +42,6 @@ mod iter_kv_map;
 mod iter_next_slice;
 mod iter_nth;
 mod iter_nth_zero;
-mod iter_on_single_or_empty_collections;
 mod iter_overeager_cloned;
 mod iter_skip_next;
 mod iter_skip_zero;
@@ -83,6 +82,7 @@ mod single_char_add_str;
 mod single_char_insert_string;
 mod single_char_pattern;
 mod single_char_push_string;
+mod single_or_empty_collections_iter;
 mod skip_while_next;
 mod stable_sort_primitive;
 mod str_splitn;
@@ -2430,15 +2430,15 @@ declare_clippy_lint! {
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on collections containing a single item.
     ///
     /// ### Why is this bad?
+    /// It is simpler to use the once function from the standard library.
     ///
-    /// It is simpler to use the once function from the standard library:
+    /// ### Known problems
+    /// The type of the resulting iterator might become incompatible with its usage.
     ///
     /// ### Example
-    ///
     /// ```rust
     /// let a = [123].iter();
     /// let b = Some(123).into_iter();
@@ -2449,27 +2449,23 @@ declare_clippy_lint! {
     /// let a = iter::once(&123);
     /// let b = iter::once(123);
     /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
     #[clippy::version = "1.65.0"]
     pub ITER_ON_SINGLE_ITEMS,
-    nursery,
+    pedantic,
     "Iterator for array of length 1"
 }
 
 declare_clippy_lint! {
     /// ### What it does
-    ///
-    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections
+    /// Checks for calls to `iter`, `iter_mut` or `into_iter` on empty collections.
     ///
     /// ### Why is this bad?
+    /// It is simpler to use the empty function from the standard library.
     ///
-    /// It is simpler to use the empty function from the standard library:
+    /// ### Known problems
+    /// The type of the resulting iterator might become incompatible with its usage.
     ///
     /// ### Example
-    ///
     /// ```rust
     /// use std::{slice, option};
     /// let a: slice::Iter<i32> = [].iter();
@@ -2481,13 +2477,9 @@ declare_clippy_lint! {
     /// let a: iter::Empty<i32> = iter::empty();
     /// let b: iter::Empty<i32> = iter::empty();
     /// ```
-    ///
-    /// ### Known problems
-    ///
-    /// The type of the resulting iterator might become incompatible with its usage
     #[clippy::version = "1.65.0"]
     pub ITER_ON_EMPTY_COLLECTIONS,
-    nursery,
+    pedantic,
     "Iterator for empty array"
 }
 
@@ -3629,6 +3621,8 @@ fn method_call<'tcx>(
 
 impl<'tcx> LateLintPass<'tcx> for Methods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+        single_or_empty_collections_iter::check(cx, expr, &self.msrv);
+
         if expr.span.from_expansion() {
             return;
         }
@@ -3924,9 +3918,6 @@ impl Methods {
                 ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, &self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
                 ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
-                ("iter" | "iter_mut" | "into_iter", []) => {
-                    iter_on_single_or_empty_collections::check(cx, expr, name, recv);
-                },
                 ("join", [join_arg]) => {
                     if let Some(("collect", _, _, span, _)) = method_call(recv) {
                         unnecessary_join::check(cx, expr, recv, join_arg, span);