hmm

Author: bend-n

clippy_config/src/conf.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::unnecessary_collect)]
 use crate::ClippyConfiguration;
 use crate::types::{
     DisallowedPath, DisallowedPathWithoutReplacement, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour,
@@ -959,10 +960,10 @@ fn deserialize(file: &SourceFile) -> TryConf {
                         // info for the user instead.
 
                         let names = conf.conf.module_item_order_groupings.grouping_names();
-                        let suggestion = suggest_candidate(grouping, names.iter().map(String::as_str))
+                        let suggestion = suggest_candidate(grouping, names.clone())
                             .map(|s| format!(" perhaps you meant `{s}`?"))
                             .unwrap_or_default();
-                        let names = names.iter().map(|s| format!("`{s}`")).join(", ");
+                        let names = names.map(|s| format!("`{s}`")).join(", ");
                         let message = format!(
                             "unknown ordering group: `{grouping}` was not specified in `module-items-ordered-within-groupings`,{suggestion} expected one of: {names}"
                         );

clippy_config/src/types.rs

@@ -422,8 +422,8 @@ impl SourceItemOrderingModuleItemGroupings {
         self.back_lut.get(item)
     }
 
-    pub fn grouping_names(&self) -> Vec<String> {
-        self.groups.iter().map(|(name, _)| name.clone()).collect()
+    pub fn grouping_names(&self) -> impl Iterator<Item = &str> + Clone {
+        self.groups.iter().map(|(name, _)| &**name)
     }
 
     pub fn is_grouping(&self, grouping: &str) -> bool {

clippy_lints/src/doc/suspicious_doc_comments.rs

@@ -10,7 +10,7 @@ use rustc_span::Span;
 use super::SUSPICIOUS_DOC_COMMENTS;
 
 pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) -> bool {
-    let replacements: Vec<_> = collect_doc_replacements(attrs);
+    let replacements = collect_doc_replacements(attrs).collect::<Vec<_>>();
 
     if let Some((&(lo_span, _), &(hi_span, _))) = replacements.first().zip(replacements.last()) {
         span_lint_and_then(
@@ -33,26 +33,23 @@ pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) -> bool {
     }
 }
 
-fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
-    attrs
-        .iter()
-        .filter_map(|attr| {
-            if let Attribute::Parsed(AttributeKind::DocComment {
-                style: AttrStyle::Outer,
-                kind,
-                comment,
-                ..
-            }) = attr
-                && let Some(com) = comment.as_str().strip_prefix('!')
-            {
-                let sugg = match kind {
-                    CommentKind::Line => format!("//!{com}"),
-                    CommentKind::Block => format!("/*!{com}*/"),
-                };
-                Some((attr.span(), sugg))
-            } else {
-                None
-            }
-        })
-        .collect()
+fn collect_doc_replacements(attrs: &[Attribute]) -> impl Iterator<Item = (Span, String)> {
+    attrs.iter().filter_map(|attr| {
+        if let Attribute::Parsed(AttributeKind::DocComment {
+            style: AttrStyle::Outer,
+            kind,
+            comment,
+            ..
+        }) = attr
+            && let Some(com) = comment.as_str().strip_prefix('!')
+        {
+            let sugg = match kind {
+                CommentKind::Line => format!("//!{com}"),
+                CommentKind::Block => format!("/*!{com}*/"),
+            };
+            Some((attr.span(), sugg))
+        } else {
+            None
+        }
+    })
 }

clippy_lints/src/lifetimes.rs

@@ -394,7 +394,7 @@ fn non_elidable_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ide
         let mut visitor = RefVisitor::new(cx);
         visitor.visit_ty_unambig(self_ty);
 
-        !visitor.all_lts().is_empty()
+        visitor.all_lts().next().is_some()
     } else {
         false
     }
@@ -404,7 +404,7 @@ fn non_elidable_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ide
 /// relative order.
 #[must_use]
 fn named_lifetime_occurrences(lts: &[Lifetime]) -> Vec<(LocalDefId, usize)> {
-    let mut occurrences = Vec::new();
+    let mut occurrences: Vec<(LocalDefId, usize)> = Vec::new();
     for lt in lts {
         if let Some(curr_def_id) = named_lifetime(lt) {
             if let Some(pair) = occurrences
@@ -444,12 +444,8 @@ impl<'a, 'tcx> RefVisitor<'a, 'tcx> {
         }
     }
 
-    fn all_lts(&self) -> Vec<Lifetime> {
-        self.lts
-            .iter()
-            .chain(self.nested_elision_site_lts.iter())
-            .copied()
-            .collect::<Vec<_>>()
+    fn all_lts(&self) -> impl Iterator<Item = Lifetime> {
+        self.lts.iter().chain(self.nested_elision_site_lts.iter()).copied()
     }
 
     fn abort(&self) -> bool {
@@ -472,7 +468,7 @@ impl<'tcx> Visitor<'tcx> for RefVisitor<'_, 'tcx> {
         {
             let mut sub_visitor = RefVisitor::new(self.cx);
             sub_visitor.visit_trait_ref(trait_ref);
-            self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
+            self.nested_elision_site_lts.extend(sub_visitor.all_lts());
         } else {
             walk_poly_trait_ref(self, poly_tref);
         }
@@ -483,7 +479,7 @@ impl<'tcx> Visitor<'tcx> for RefVisitor<'_, 'tcx> {
             TyKind::FnPtr(&FnPtrTy { decl, .. }) => {
                 let mut sub_visitor = RefVisitor::new(self.cx);
                 sub_visitor.visit_fn_decl(decl);
-                self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
+                self.nested_elision_site_lts.extend(sub_visitor.all_lts());
             },
             TyKind::TraitObject(bounds, lt) => {
                 if !lt.is_elided() {
@@ -509,7 +505,7 @@ fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, generics: &'tcx Generics<'_
                 let mut visitor = RefVisitor::new(cx);
                 // walk the type F, it may not contain LT refs
                 walk_unambig_ty(&mut visitor, pred.bounded_ty);
-                if !visitor.all_lts().is_empty() {
+                if visitor.all_lts().next().is_some() {
                     return true;
                 }
                 // if the bounds define new lifetimes, they are fine to occur

clippy_lints/src/non_send_fields_in_send_ty.rs

@@ -107,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
                         non_send_fields.push(NonSendField {
                             def: field_def,
                             ty: field_ty,
-                            generic_params: collect_generic_params(field_ty),
+                            generic_params: collect_generic_params(field_ty).collect(),
                         });
                     }
                 }
@@ -170,14 +170,13 @@ impl NonSendField<'_> {
 
 /// Given a type, collect all of its generic parameters.
 /// Example: `MyStruct<P, Box<Q, R>>` => `vec![P, Q, R]`
-fn collect_generic_params(ty: Ty<'_>) -> Vec<Ty<'_>> {
+fn collect_generic_params(ty: Ty<'_>) -> impl Iterator<Item = Ty<'_>> {
     ty.walk()
         .filter_map(|inner| match inner.kind() {
             GenericArgKind::Type(inner_ty) => Some(inner_ty),
             _ => None,
         })
         .filter(|&inner_ty| is_ty_param(inner_ty))
-        .collect()
 }
 
 /// Be more strict when the heuristic is disabled

clippy_lints/src/unnecessary_collect.rs

@@ -9,7 +9,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::{self};
 use rustc_span::Span;
 
-use rustc_hir::*;
+use rustc_hir::{Body, ExprKind, FnDecl, Stmt, StmtKind};
 use rustc_lint::LateLintPass;
 use rustc_session::impl_lint_pass;
 
@@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryCollect {
         && let ty::Adt(v, args) = vec_ty.kind()
         && cx.tcx.is_diagnostic_item(sym::Vec, v.did())
         // make sure we're collecting to just a vec, and not a vec<result> String or other such tomfoolery
-        && args.get(0).and_then(|x| x.as_type()) == Some(item)
+        && args.first().and_then(|x| x.as_type()) == Some(item)
         {
             span_lint_and_then(
                 cx,

clippy_utils/src/lib.rs

@@ -2876,12 +2876,13 @@ pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
 /// Returns all the comments a given span contains.
 ///
 /// Comments are returned wrapped with their relevant delimiters.
+#[allow(clippy::unnecessary_collect)]
 pub fn span_extract_comments(sm: &SourceMap, span: Span) -> Vec<String> {
     let snippet = sm.span_to_snippet(span).unwrap_or_default();
     tokenize_with_text(&snippet)
         .filter(|(t, ..)| matches!(t, TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }))
         .map(|(_, s, _)| s.to_string())
-        .collect::<Vec<_>>()
+        .collect()
 }
 
 pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {

clippy_utils/src/str_utils.rs

@@ -153,6 +153,7 @@ pub fn camel_case_indices(s: &str) -> Vec<StrIndex> {
 /// # use clippy_utils::str_utils::{camel_case_split, StrIndex};
 /// assert_eq!(camel_case_split("AbcDef"), vec!["Abc", "Def"]);
 /// ```
+#[allow(clippy::unnecessary_collect)]
 pub fn camel_case_split(s: &str) -> Vec<&str> {
     let mut offsets = camel_case_indices(s)
         .iter()

tests/compile-test.rs

@@ -44,6 +44,7 @@ static INTERNAL_TEST_DEPENDENCIES: &[&str] = &["clippy_config", "clippy_lints",
 /// dependencies must be added to Cargo.toml at the project root. Test
 /// dependencies that are not *directly* used by this test module require an
 /// `extern crate` declaration.
+#[allow(clippy::unnecessary_collect)]
 fn internal_extern_flags() -> Vec<String> {
     let current_exe_path = env::current_exe().unwrap();
     let deps_path = current_exe_path.parent().unwrap();