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, InherentImplLintScope, MacroMatcher, MatchLintBehaviour,
@@ -966,10 +967,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

@@ -32,7 +32,7 @@ pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) -> bool {
         false
     }
 }
-
+#[expect(clippy::unnecessary_collect)]
 fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
     attrs
         .iter()

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
     }
@@ -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

@@ -44,7 +44,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.92.0"]
     pub UNNECESSARY_COLLECT,
     nursery,
-    "default lint description"
+    "checks for functions returning vecs produced from vec::from_iter"
 }
 
 pub struct UnnecessaryCollect {

clippy_utils/src/lib.rs

@@ -2777,12 +2777,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();