Attempt at replacing all occurrences.

Author: hameerabbasi

compiler/rustc_codegen_ssa/src/base.rs

@@ -910,7 +910,7 @@ pub fn provide(providers: &mut Providers) {
         };
 
         let (defids, _) = tcx.collect_and_partition_mono_items(cratenum);
-        for id in &*defids {
+        for id in defids.sorted_vector() {
             let CodegenFnAttrs { optimize, .. } = tcx.codegen_fn_attrs(*id);
             match optimize {
                 attr::OptimizeAttr::None => continue,

compiler/rustc_data_structures/src/fx.rs

@@ -9,6 +9,6 @@ pub type FxIndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;
 macro_rules! define_id_collections {
     ($map_name:ident, $set_name:ident, $key:ty) => {
         pub type $map_name<T> = $crate::fx::FxHashMap<$key, T>;
-        pub type $set_name = $crate::fx::FxHashSet<$key>;
+        pub type $set_name = $crate::stable_set::StableSet<$key>;
     };
 }

compiler/rustc_data_structures/src/stable_set.rs

@@ -9,8 +9,11 @@ use crate::stable_hasher::{stable_hash_reduce, HashStable, StableHasher, ToStabl
 ///
 /// It supports insert, remove, get functions from FxHashSet.
 /// It also allows to convert hashset to a sorted vector with the method `into_sorted_vector()`.
-#[derive(Clone)]
-pub struct StableSet<T> {
+#[derive(Clone, Encodable, Decodable)]
+pub struct StableSet<T>
+where
+    T: Eq + Hash,
+{
     base: FxHashSet<T>,
 }
 
@@ -62,6 +65,16 @@ impl<T: Hash + Eq> StableSet<T> {
         vector
     }
 
+    #[inline]
+    pub fn sorted_vector<HCX>(&self, hcx: &HCX) -> Vec<&T>
+    where
+        T: ToStableHashKey<HCX>,
+    {
+        let mut vector = self.base.iter().collect::<Vec<_>>();
+        vector.sort_by_cached_key(|x| x.to_stable_hash_key(hcx));
+        vector
+    }
+
     #[inline]
     pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
     where
@@ -93,7 +106,7 @@ impl<T: Hash + Eq> StableSet<T> {
 
 impl<T, HCX> HashStable<HCX> for StableSet<T>
 where
-    T: ToStableHashKey<HCX> + Eq,
+    T: ToStableHashKey<HCX> + Eq + Hash,
 {
     #[inline]
     fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher) {
@@ -103,3 +116,23 @@ where
         });
     }
 }
+
+impl<T> FromIterator<T> for StableSet<T>
+where
+    T: Eq + Hash,
+{
+    #[inline]
+    fn from_iter<Collection: IntoIterator<Item = T>>(iter: Collection) -> Self {
+        Self { base: iter.into_iter().collect() }
+    }
+}
+
+impl<T> Extend<T> for StableSet<T>
+where
+    T: Eq + Hash,
+{
+    #[inline]
+    fn extend<Iter: IntoIterator<Item = T>>(&mut self, iter: Iter) {
+        self.base.extend(iter)
+    }
+}

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1742,7 +1742,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
         let lib_features = tcx.lib_features(());
-        self.lazy(lib_features.to_vec())
+        self.lazy(lib_features.to_vec(tcx))
     }
 
     fn encode_diagnostic_items(&mut self) -> Lazy<[(Symbol, DefIndex)]> {

compiler/rustc_middle/src/middle/mod.rs

@@ -3,23 +3,26 @@ pub mod dependency_format;
 pub mod exported_symbols;
 pub mod lang_items;
 pub mod lib_features {
-    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+    use rustc_data_structures::{fx::FxHashMap, stable_set::StableSet};
     use rustc_span::symbol::Symbol;
 
+    use crate::ty::TyCtxt;
+
     #[derive(HashStable, Debug)]
     pub struct LibFeatures {
         // A map from feature to stabilisation version.
         pub stable: FxHashMap<Symbol, Symbol>,
-        pub unstable: FxHashSet<Symbol>,
+        pub unstable: StableSet<Symbol>,
     }
 
     impl LibFeatures {
-        pub fn to_vec(&self) -> Vec<(Symbol, Option<Symbol>)> {
+        pub fn to_vec(&self, tcx: TyCtxt<'_>) -> Vec<(Symbol, Option<Symbol>)> {
+            let hcx = tcx.create_stable_hashing_context();
             let mut all_features: Vec<_> = self
                 .stable
                 .iter()
                 .map(|(f, s)| (*f, Some(*s)))
-                .chain(self.unstable.iter().map(|f| (*f, None)))
+                .chain(self.unstable.sorted_vector(&hcx).into_iter().map(|f| (*f, None)))
                 .collect();
             all_features.sort_unstable_by(|a, b| a.0.as_str().partial_cmp(b.0.as_str()).unwrap());
             all_features

compiler/rustc_middle/src/middle/resolve_lifetime.rs

@@ -2,7 +2,8 @@
 
 use crate::ty;
 
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::stable_set::StableSet;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::ItemLocalId;
 use rustc_macros::HashStable;
@@ -63,7 +64,7 @@ pub struct ResolveLifetimes {
     /// Set of lifetime def ids that are late-bound; a region can
     /// be late-bound if (a) it does NOT appear in a where-clause and
     /// (b) it DOES appear in the arguments.
-    pub late_bound: FxHashMap<LocalDefId, FxHashSet<ItemLocalId>>,
+    pub late_bound: FxHashMap<LocalDefId, StableSet<ItemLocalId>>,
 
     pub late_bound_vars: FxHashMap<LocalDefId, FxHashMap<ItemLocalId, Vec<ty::BoundVariableKind>>>,
 }

compiler/rustc_middle/src/middle/stability.rs

@@ -7,12 +7,13 @@ use crate::ty::{self, DefIdTree, TyCtxt};
 use rustc_ast::NodeId;
 use rustc_attr::{self as attr, ConstStability, Deprecation, Stability};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::stable_set::StableSet;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_feature::GateIssue;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_INDEX};
-use rustc_hir::{self, HirId};
+use rustc_hir::{self, def_id::CrateNum, HirId};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE};
 use rustc_session::lint::{BuiltinLintDiagnostics, Level, Lint, LintBuffer};
@@ -63,6 +64,12 @@ pub struct Index {
     pub stab_map: FxHashMap<LocalDefId, Stability>,
     pub const_stab_map: FxHashMap<LocalDefId, ConstStability>,
     pub depr_map: FxHashMap<LocalDefId, DeprecationEntry>,
+
+    /// Maps for each crate whether it is part of the staged API.
+    pub staged_api: FxHashMap<CrateNum, bool>,
+
+    /// Features enabled for this crate.
+    pub active_features: StableSet<Symbol>,
 }
 
 impl Index {

compiler/rustc_middle/src/query/mod.rs

@@ -775,7 +775,7 @@ rustc_queries! {
     /// The second return value maps from ADTs to ignored derived traits (e.g. Debug and Clone) and
     /// their respective impl (i.e., part of the derive macro)
     query live_symbols_and_ignored_derived_traits(_: ()) -> (
-        FxHashSet<LocalDefId>,
+        StableSet<LocalDefId>,
         FxHashMap<LocalDefId, Vec<(DefId, DefId)>>
     ) {
         storage(ArenaCacheSelector<'tcx>)
@@ -828,7 +828,7 @@ rustc_queries! {
         }
     }
 
-    query used_trait_imports(key: LocalDefId) -> &'tcx FxHashSet<LocalDefId> {
+    query used_trait_imports(key: LocalDefId) -> &'tcx StableSet<LocalDefId> {
         desc { |tcx| "used_trait_imports `{}`", tcx.def_path_str(key.to_def_id()) }
         cache_on_disk_if { true }
     }
@@ -978,7 +978,7 @@ rustc_queries! {
         desc { "checking for private elements in public interfaces" }
     }
 
-    query reachable_set(_: ()) -> FxHashSet<LocalDefId> {
+    query reachable_set(_: ()) -> StableSet<LocalDefId> {
         storage(ArenaCacheSelector<'tcx>)
         desc { "reachability" }
     }
@@ -1055,7 +1055,7 @@ rustc_queries! {
         cache_on_disk_if { true }
     }
 
-    query asm_target_features(def_id: DefId) -> &'tcx FxHashSet<Symbol> {
+    query asm_target_features(def_id: DefId) -> &'tcx StableSet<Symbol> {
         desc { |tcx| "computing target features for inline asm of `{}`", tcx.def_path_str(def_id) }
     }
 
@@ -1506,7 +1506,7 @@ rustc_queries! {
         desc { "looking up a named region" }
     }
     query is_late_bound_map(_: LocalDefId) ->
-        Option<(LocalDefId, &'tcx FxHashSet<ItemLocalId>)> {
+        Option<(LocalDefId, &'tcx StableSet<ItemLocalId>)> {
         desc { "testing if a region is late bound" }
     }
     /// For a given item (like a struct), gets the default lifetimes to be used
@@ -1645,7 +1645,7 @@ rustc_queries! {
     query maybe_unused_extern_crates(_: ()) -> &'tcx [(LocalDefId, Span)] {
         desc { "looking up all possibly unused extern crates" }
     }
-    query names_imported_by_glob_use(def_id: LocalDefId) -> &'tcx FxHashSet<Symbol> {
+    query names_imported_by_glob_use(def_id: LocalDefId) -> &'tcx StableSet<Symbol> {
         desc { |tcx| "names_imported_by_glob_use for `{}`", tcx.def_path_str(def_id.to_def_id()) }
     }
 

compiler/rustc_middle/src/ty/context.rs

@@ -25,12 +25,13 @@ use crate::ty::{
 };
 use rustc_ast as ast;
 use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::stable_set::StableSet;
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::sync::{self, Lock, Lrc, WorkerLocal};
 use rustc_data_structures::vec_map::VecMap;
@@ -480,7 +481,7 @@ pub struct TypeckResults<'tcx> {
     /// This is used for warning unused imports. During type
     /// checking, this `Lrc` should not be cloned: it must have a ref-count
     /// of 1 so that we can insert things into the set mutably.
-    pub used_trait_imports: Lrc<FxHashSet<LocalDefId>>,
+    pub used_trait_imports: Lrc<StableSet<LocalDefId>>,
 
     /// If any errors occurred while type-checking this body,
     /// this field will be set to `Some(ErrorGuaranteed)`.
@@ -2208,7 +2209,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// to identify which traits may define a given associated type to help avoid cycle errors.
     /// Returns a `DefId` iterator.
     fn super_traits_of(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> + 'tcx {
-        let mut set = FxHashSet::default();
+        let mut set = StableSet::default();
         let mut stack = vec![trait_def_id];
 
         set.insert(trait_def_id);

compiler/rustc_middle/src/ty/mod.rs

@@ -18,6 +18,7 @@ pub use adt::*;
 pub use assoc::*;
 pub use generics::*;
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::stable_set::StableSet;
 pub use vtable::*;
 
 use crate::metadata::ModChild;
@@ -135,7 +136,7 @@ pub struct ResolverOutputs {
     pub maybe_unused_trait_imports: FxHashSet<LocalDefId>,
     pub maybe_unused_extern_crates: Vec<(LocalDefId, Span)>,
     pub reexport_map: FxHashMap<LocalDefId, Vec<ModChild>>,
-    pub glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,
+    pub glob_map: FxHashMap<LocalDefId, StableSet<Symbol>>,
     /// Extern prelude entries. The value is `true` if the entry was introduced
     /// via `extern crate` item and not `--extern` option or compiler built-in.
     pub extern_prelude: FxHashMap<Symbol, bool>,

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2763,8 +2763,9 @@ fn trimmed_def_paths(tcx: TyCtxt<'_>, (): ()) -> FxHashMap<DefId, Symbol> {
     let unique_symbols_rev: &mut FxHashMap<(Namespace, Symbol), Option<DefId>> =
         &mut FxHashMap::default();
 
+    let hcx = tcx.create_stable_hashing_context();
     for symbol_set in tcx.resolutions(()).glob_map.values() {
-        for symbol in symbol_set {
+        for symbol in symbol_set.sorted_vector(&hcx) {
             unique_symbols_rev.insert((Namespace::TypeNS, *symbol), None);
             unique_symbols_rev.insert((Namespace::ValueNS, *symbol), None);
             unique_symbols_rev.insert((Namespace::MacroNS, *symbol), None);

compiler/rustc_middle/src/ty/query.rs

@@ -33,10 +33,13 @@ use crate::ty::subst::{GenericArg, SubstsRef};
 use crate::ty::util::AlwaysRequiresDrop;
 use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
 use rustc_ast::expand::allocator::AllocatorKind;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::{
+    fx::{FxHashMap, FxIndexMap},
+    stable_set::StableSet,
+};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;

compiler/rustc_passes/src/stability.rs

@@ -898,7 +898,7 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
 
     // We always collect the lib features declared in the current crate, even if there are
     // no unknown features, because the collection also does feature attribute validation.
-    let local_defined_features = tcx.lib_features(()).to_vec();
+    let local_defined_features = tcx.lib_features(()).to_vec(tcx);
     if !remaining_lib_features.is_empty() {
         check_features(&mut remaining_lib_features, &local_defined_features);
 

compiler/rustc_resolve/src/late/lifetimes.rs

@@ -8,6 +8,7 @@
 
 use crate::late::diagnostics::{ForLifetimeSpanType, MissingLifetimeSpot};
 use rustc_ast::walk_list;
+use rustc_ast_lowering::ResolverAstLowering;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::{struct_span_err, Applicability, Diagnostic};
 use rustc_hir as hir;
@@ -468,14 +469,14 @@ fn do_resolve(
     named_region_map
 }
 
-fn convert_named_region_map(named_region_map: NamedRegionMap) -> ResolveLifetimes {
+fn convert_named_region_map(named_region_map: NamedRegionMap, tcx: TyCtxt<'_>) -> ResolveLifetimes {
     let mut rl = ResolveLifetimes::default();
-
+    let hcx = tcx.create_stable_hashing_context();
     for (hir_id, v) in named_region_map.defs {
         let map = rl.defs.entry(hir_id.owner).or_default();
         map.insert(hir_id.local_id, v);
     }
-    for hir_id in named_region_map.late_bound {
+    for hir_id in named_region_map.late_bound.sorted_vector(&hcx) {
         let map = rl.late_bound.entry(hir_id.owner).or_default();
         map.insert(hir_id.local_id);
     }

compiler/rustc_resolve/src/lib.rs

@@ -24,6 +24,7 @@
 #[macro_use]
 extern crate tracing;
 
+use rustc_data_structures::stable_set::StableSet;
 pub use rustc_hir::def::{Namespace, PerNS};
 
 use Determinacy::*;
@@ -975,7 +976,7 @@ pub struct Resolver<'a> {
     underscore_disambiguator: u32,
 
     /// Maps glob imports to the names of items actually imported.
-    glob_map: FxHashMap<LocalDefId, FxHashSet<Symbol>>,
+    glob_map: FxHashMap<LocalDefId, StableSet<Symbol>>,
     /// Visibilities in "lowered" form, for all entities that have them.
     visibilities: FxHashMap<LocalDefId, ty::Visibility>,
     used_imports: FxHashSet<NodeId>,

compiler/rustc_typeck/src/check/mod.rs

@@ -312,7 +312,7 @@ fn has_typeck_results(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
     }
 }
 
-fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &FxHashSet<LocalDefId> {
+fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &StableSet<LocalDefId> {
     &*tcx.typeck(def_id).used_trait_imports
 }
 

compiler/rustc_typeck/src/check/writeback.rs

@@ -425,8 +425,9 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
         let fcx_typeck_results = self.fcx.typeck_results.borrow();
         let fcx_coercion_casts = fcx_typeck_results.coercion_casts();
         assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner);
+        let hcx = self.tcx().create_stable_hashing_context();
 
-        for local_id in fcx_coercion_casts {
+        for local_id in fcx_coercion_casts.sorted_vector(&hcx) {
             self.typeck_results.set_coercion_cast(*local_id);
         }
     }