avoid collecting into vecs in some places

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

@@ -357,31 +357,27 @@ fn add_unused_functions(cx: &CodegenCx<'_, '_>) {
 
     let ignore_unused_generics = tcx.sess.instrument_coverage_except_unused_generics();
 
-    let eligible_def_ids: Vec<DefId> = tcx
+    let eligible_def_ids = tcx.mir_keys(()).iter().filter_map(|local_def_id| {
-        .mir_keys(())
+        let def_id = local_def_id.to_def_id();
-        .iter()
+        let kind = tcx.def_kind(def_id);
-        .filter_map(|local_def_id| {
+        // `mir_keys` will give us `DefId`s for all kinds of things, not
-            let def_id = local_def_id.to_def_id();
+        // just "functions", like consts, statics, etc. Filter those out.
-            let kind = tcx.def_kind(def_id);
+        // If `ignore_unused_generics` was specified, filter out any
-            // `mir_keys` will give us `DefId`s for all kinds of things, not
+        // generic functions from consideration as well.
-            // just "functions", like consts, statics, etc. Filter those out.
+        if !matches!(kind, DefKind::Fn | DefKind::AssocFn | DefKind::Closure) {
-            // If `ignore_unused_generics` was specified, filter out any
+            return None;
-            // generic functions from consideration as well.
+        }
-            if !matches!(kind, DefKind::Fn | DefKind::AssocFn | DefKind::Closure) {
+        if ignore_unused_generics && tcx.generics_of(def_id).requires_monomorphization(tcx) {
-                return None;
+            return None;
-            }
+        }
-            if ignore_unused_generics && tcx.generics_of(def_id).requires_monomorphization(tcx) {
+        Some(local_def_id.to_def_id())
-                return None;
+    });
-            }
-            Some(local_def_id.to_def_id())
-        })
-        .collect();
 
     let codegenned_def_ids = codegenned_and_inlined_items(tcx);
 
     // For each `DefId` that should have coverage instrumentation but wasn't
     // codegenned, add it to the function coverage map as an unused function.
-    for def_id in eligible_def_ids.into_iter().filter(|id| !codegenned_def_ids.contains(id)) {
+    for def_id in eligible_def_ids.filter(|id| !codegenned_def_ids.contains(id)) {
         // Skip any function that didn't have coverage data added to it by the
         // coverage instrumentor.
         let body = tcx.instance_mir(ty::InstanceDef::Item(def_id));

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -860,10 +860,7 @@ fn report_ambiguous_associated_type(
                              traits with associated type `{name}`, you could use the \
                              fully-qualified path",
                         ),
-                        traits
+                        traits.iter().map(|trait_str| format!("<Example as {trait_str}>::{name}")),
-                            .iter()
-                            .map(|trait_str| format!("<Example as {trait_str}>::{name}"))
-                            .collect::<Vec<_>>(),
                         Applicability::HasPlaceholders,
                     );
                 }

compiler/rustc_hir_typeck/src/expr.rs

@@ -2156,10 +2156,7 @@ fn report_private_fields(
                     err.span_suggestions(
                         span.shrink_to_hi().with_hi(expr_span.hi()),
                         "you might have meant to use an associated function to build this type",
-                        items
+                        items.iter().map(|(_, name, args)| suggestion(name, *args)),
-                            .iter()
-                            .map(|(_, name, args)| suggestion(name, *args))
-                            .collect::<Vec<String>>(),
                         Applicability::MaybeIncorrect,
                     );
                 }

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -1884,10 +1884,7 @@ fn suggest_alternative_construction_methods(
                 err.span_suggestions_with_style(
                     path_span.shrink_to_hi().with_hi(call_span.hi()),
                     "you might have meant to use an associated function to build this type",
-                    items
+                    items.iter().map(|(_, name, len)| suggestion(name, *len)),
-                        .iter()
-                        .map(|(_, name, len)| suggestion(name, *len))
-                        .collect::<Vec<String>>(),
                     Applicability::MaybeIncorrect,
                     SuggestionStyle::ShowAlways,
                 );

compiler/rustc_trait_selection/src/solve/fulfill.rs

@@ -57,7 +57,7 @@ fn clone_pending(&self) -> Vec<PredicateObligation<'tcx>> {
 
     fn take_pending(&mut self) -> Vec<PredicateObligation<'tcx>> {
         let mut obligations = mem::take(&mut self.pending);
-        obligations.extend(self.overflowed.drain(..));
+        obligations.append(&mut self.overflowed);
         obligations
     }