remove uncessary collect

Author: chenyukang

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -1,4 +1,4 @@
-use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_index::bit_set::SparseBitMatrix;
 use rustc_index::interval::IntervalSet;
 use rustc_index::interval::SparseIntervalMatrix;
@@ -41,7 +41,7 @@ pub(crate) struct LivenessValues {
 
     /// Which regions are live. This is exclusive with the fine-grained tracking in `points`, and
     /// currently only used for validating promoteds (which don't care about more precise tracking).
-    live_regions: Option<FxIndexSet<RegionVid>>,
+    live_regions: Option<FxHashSet<RegionVid>>,
 
     /// For each region: the points where it is live.
     ///
@@ -103,6 +103,10 @@ impl LivenessValues {
         self.points.as_ref().expect("use with_specific_points").rows()
     }
 
+    /// Iterate through each region that has a value in this set.
+    // We are passing query instability implications to the caller.
+    #[rustc_lint_query_instability]
+    #[allow(rustc::potential_query_instability)]
     pub(crate) fn live_regions_unordered(&self) -> impl Iterator<Item = RegionVid> + '_ {
         self.live_regions.as_ref().unwrap().iter().copied()
     }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -599,6 +599,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         //
         // add_location doesn't care about ordering so not a problem for the live regions to be
         // unordered.
+        #[allow(rustc::potential_query_instability)]
         for region in liveness_constraints.live_regions_unordered() {
             self.cx
                 .borrowck_context

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -563,8 +563,7 @@ fn link_staticlib<'a>(
                 .extract_bundled_libs(path, tempdir.as_ref(), &relevant_libs)
                 .unwrap_or_else(|e| sess.dcx().emit_fatal(e));
 
-            let relevant_libs: Vec<Symbol> = relevant_libs.into_iter().collect();
-            for filename in relevant_libs {
+            for filename in relevant_libs.iter() {
                 let joined = tempdir.as_ref().join(filename.as_str());
                 let path = joined.as_path();
                 ab.add_archive(path, Box::new(|_| false)).unwrap();
@@ -2215,6 +2214,7 @@ fn linker_with_args<'a>(
         .expect("failed to find crate type in dependency format list");
 
     // We sort the libraries below
+    #[allow(rustc::potential_query_instability)]
     let mut native_libraries_from_nonstatics = codegen_results
         .crate_info
         .native_libraries

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -320,6 +320,7 @@ fn exported_symbols_provider_local(
         let (_, cgus) = tcx.collect_and_partition_mono_items(());
 
         // The symbols created in this loop are sorted below it
+        #[allow(rustc::potential_query_instability)]
         for (mono_item, data) in cgus.iter().flat_map(|cgu| cgu.items().iter()) {
             if data.linkage != Linkage::External {
                 // We can only re-use things with external linkage, otherwise

compiler/rustc_codegen_ssa/src/base.rs

@@ -912,6 +912,7 @@ impl CrateInfo {
                 .collect();
             let prefix = if target.is_like_windows && target.arch == "x86" { "_" } else { "" };
 
+            #[allow(rustc::potential_query_instability)]
             info.linked_symbols
                 .iter_mut()
                 .filter(|(crate_type, _)| {

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -514,6 +514,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // Unlike all the other GC helpers where we check if an `AllocId` is found in the interpreter or
         // is live, here all the IDs in the map are for dead allocations so we don't
         // need to check for liveness.
+        #[allow(rustc::potential_query_instability)] // Only used from Miri, not queries.
         self.memory.dead_alloc_map.retain(|id, _| reachable_allocs.contains(id));
     }
 }

compiler/rustc_interface/src/passes.rs

@@ -306,8 +306,7 @@ fn early_lint_checks(tcx: TyCtxt<'_>, (): ()) {
 
     // Gate identifiers containing invalid Unicode codepoints that were recovered during lexing.
     sess.parse_sess.bad_unicode_identifiers.with_lock(|identifiers| {
-        let identifiers: Vec<_> = identifiers.drain(..).collect();
-        for (ident, mut spans) in identifiers.into_iter() {
+        for (ident, mut spans) in identifiers.drain(..) {
             spans.sort();
             if ident == sym::ferris {
                 let first_span = spans[0];
@@ -437,6 +436,7 @@ fn write_out_deps(tcx: TyCtxt<'_>, outputs: &OutputFilenames, out_filenames: &[P
         files.extend(extra_tracked_files);
 
         // We also need to track used PGO profile files
+        #[allow(rustc::potential_query_instability)]
         if let Some(ref profile_instr) = sess.opts.cg.profile_use {
             files.push(normalize_path(profile_instr.as_path().to_path_buf()));
         }

compiler/rustc_lint/src/non_ascii_idents.rs

@@ -175,6 +175,8 @@ impl EarlyLintPass for NonAsciiIdents {
 
         // Sort by `Span` so that error messages make sense with respect to the
         // order of identifier locations in the code.
+        // We will soon sort, so the initial order does not matter.
+        #[allow(rustc::potential_query_instability)]
         let mut symbols: Vec<_> = symbols.iter().collect();
         symbols.sort_by_key(|k| k.1);
         for (symbol, &sp) in symbols.iter() {
@@ -297,6 +299,8 @@ impl EarlyLintPass for NonAsciiIdents {
             }
 
             if has_suspicious {
+                // The end result is put in `lint_reports` which is sorted.
+                #[allow(rustc::potential_query_instability)]
                 let verified_augmented_script_sets = script_states
                     .iter()
                     .flat_map(|(k, v)| match v {
@@ -309,6 +313,8 @@ impl EarlyLintPass for NonAsciiIdents {
                 let mut lint_reports: BTreeMap<(Span, Vec<char>), AugmentedScriptSet> =
                     BTreeMap::new();
 
+                // The end result is put in `lint_reports` which is sorted.
+                #[allow(rustc::potential_query_instability)]
                 'outerloop: for (augment_script_set, usage) in script_states {
                     let ScriptSetUsage::Suspicious(mut ch_list, sp) = usage else { continue };
 

compiler/rustc_session/src/parse.rs

@@ -11,7 +11,7 @@ use crate::lint::{
 };
 use crate::Session;
 use rustc_ast::node_id::NodeId;
-use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
 use rustc_data_structures::sync::{AppendOnlyVec, Lock, Lrc};
 use rustc_errors::{emitter::SilentEmitter, DiagCtxt};
 use rustc_errors::{
@@ -30,7 +30,7 @@ use std::str;
 /// used and should be feature gated accordingly in `check_crate`.
 #[derive(Default)]
 pub struct GatedSpans {
-    pub spans: Lock<FxIndexMap<Symbol, Vec<Span>>>,
+    pub spans: Lock<FxHashMap<Symbol, Vec<Span>>>,
 }
 
 impl GatedSpans {
@@ -50,9 +50,12 @@ impl GatedSpans {
     }
 
     /// Prepend the given set of `spans` onto the set in `self`.
-    pub fn merge(&self, mut spans: FxIndexMap<Symbol, Vec<Span>>) {
+    pub fn merge(&self, mut spans: FxHashMap<Symbol, Vec<Span>>) {
         let mut inner = self.spans.borrow_mut();
-        for (gate, mut gate_spans) in inner.drain(..) {
+        // The entries will be moved to another map so the drain order does not
+        // matter.
+        #[allow(rustc::potential_query_instability)]
+        for (gate, mut gate_spans) in inner.drain() {
             spans.entry(gate).or_default().append(&mut gate_spans);
         }
         *inner = spans;
@@ -62,7 +65,7 @@ impl GatedSpans {
 #[derive(Default)]
 pub struct SymbolGallery {
     /// All symbols occurred and their first occurrence span.
-    pub symbols: Lock<FxIndexMap<Symbol, Span>>,
+    pub symbols: Lock<FxHashMap<Symbol, Span>>,
 }
 
 impl SymbolGallery {