mirror of https://github.com/rust-lang/rust.git
Avoid unnecessary sorting of traits
This commit is contained in:
parent
5affbb1715
commit
b5d0608761
|
@ -7,6 +7,7 @@ use crate::rmeta::*;
|
|||
use rustc_ast as ast;
|
||||
use rustc_data_structures::captures::Captures;
|
||||
use rustc_data_structures::fingerprint::Fingerprint;
|
||||
use rustc_data_structures::fx::FxIndexMap;
|
||||
use rustc_data_structures::owned_slice::OwnedSlice;
|
||||
use rustc_data_structures::sync::{Lock, Lrc, OnceLock};
|
||||
use rustc_data_structures::unhash::UnhashMap;
|
||||
|
@ -83,12 +84,12 @@ pub(crate) struct CrateMetadata {
|
|||
/// Trait impl data.
|
||||
/// FIXME: Used only from queries and can use query cache,
|
||||
/// so pre-decoding can probably be avoided.
|
||||
trait_impls: FxHashMap<(u32, DefIndex), LazyArray<(DefIndex, Option<SimplifiedType>)>>,
|
||||
trait_impls: FxIndexMap<(u32, DefIndex), LazyArray<(DefIndex, Option<SimplifiedType>)>>,
|
||||
/// Inherent impls which do not follow the normal coherence rules.
|
||||
///
|
||||
/// These can be introduced using either `#![rustc_coherence_is_core]`
|
||||
/// or `#[rustc_allow_incoherent_impl]`.
|
||||
incoherent_impls: FxHashMap<SimplifiedType, LazyArray<DefIndex>>,
|
||||
incoherent_impls: FxIndexMap<SimplifiedType, LazyArray<DefIndex>>,
|
||||
/// Proc macro descriptions for this crate, if it's a proc macro crate.
|
||||
raw_proc_macros: Option<&'static [ProcMacro]>,
|
||||
/// Source maps for code from the crate.
|
||||
|
|
|
@ -2,7 +2,7 @@ use crate::errors::{FailCreateFileEncoder, FailWriteFile};
|
|||
use crate::rmeta::*;
|
||||
|
||||
use rustc_ast::Attribute;
|
||||
use rustc_data_structures::fx::FxIndexSet;
|
||||
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
|
||||
use rustc_data_structures::memmap::{Mmap, MmapMut};
|
||||
use rustc_data_structures::sync::{join, par_for_each_in, Lrc};
|
||||
use rustc_data_structures::temp_dir::MaybeTempDir;
|
||||
|
@ -1508,10 +1508,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
let inherent_impls = tcx.with_stable_hashing_context(|hcx| {
|
||||
tcx.crate_inherent_impls(()).unwrap().inherent_impls.to_sorted(&hcx, true)
|
||||
});
|
||||
for (def_id, impls) in inherent_impls {
|
||||
for (def_id, impls) in &tcx.crate_inherent_impls(()).unwrap().inherent_impls {
|
||||
record_defaulted_array!(self.tables.inherent_impls[def_id.to_def_id()] <- impls.iter().map(|def_id| {
|
||||
assert!(def_id.is_local());
|
||||
def_id.index
|
||||
|
@ -1992,8 +1989,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
fn encode_impls(&mut self) -> LazyArray<TraitImpls> {
|
||||
empty_proc_macro!(self);
|
||||
let tcx = self.tcx;
|
||||
let mut fx_hash_map: FxHashMap<DefId, Vec<(DefIndex, Option<SimplifiedType>)>> =
|
||||
FxHashMap::default();
|
||||
let mut trait_impls: FxIndexMap<DefId, Vec<(DefIndex, Option<SimplifiedType>)>> =
|
||||
FxIndexMap::default();
|
||||
|
||||
for id in tcx.hir().items() {
|
||||
let DefKind::Impl { of_trait } = tcx.def_kind(id.owner_id) else {
|
||||
|
@ -2012,7 +2009,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
trait_ref.self_ty(),
|
||||
TreatParams::AsCandidateKey,
|
||||
);
|
||||
fx_hash_map
|
||||
trait_impls
|
||||
.entry(trait_ref.def_id)
|
||||
.or_default()
|
||||
.push((id.owner_id.def_id.local_def_index, simplified_self_ty));
|
||||
|
@ -2033,47 +2030,30 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
let mut all_impls: Vec<_> = fx_hash_map.into_iter().collect();
|
||||
|
||||
// Bring everything into deterministic order for hashing
|
||||
all_impls.sort_by_cached_key(|&(trait_def_id, _)| tcx.def_path_hash(trait_def_id));
|
||||
|
||||
let all_impls: Vec<_> = all_impls
|
||||
let trait_impls: Vec<_> = trait_impls
|
||||
.into_iter()
|
||||
.map(|(trait_def_id, mut impls)| {
|
||||
// Bring everything into deterministic order for hashing
|
||||
impls.sort_by_cached_key(|&(index, _)| {
|
||||
tcx.hir().def_path_hash(LocalDefId { local_def_index: index })
|
||||
});
|
||||
|
||||
TraitImpls {
|
||||
trait_id: (trait_def_id.krate.as_u32(), trait_def_id.index),
|
||||
impls: self.lazy_array(&impls),
|
||||
}
|
||||
.map(|(trait_def_id, impls)| TraitImpls {
|
||||
trait_id: (trait_def_id.krate.as_u32(), trait_def_id.index),
|
||||
impls: self.lazy_array(&impls),
|
||||
})
|
||||
.collect();
|
||||
|
||||
self.lazy_array(&all_impls)
|
||||
self.lazy_array(&trait_impls)
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
fn encode_incoherent_impls(&mut self) -> LazyArray<IncoherentImpls> {
|
||||
empty_proc_macro!(self);
|
||||
let tcx = self.tcx;
|
||||
let all_impls = tcx.with_stable_hashing_context(|hcx| {
|
||||
tcx.crate_inherent_impls(()).unwrap().incoherent_impls.to_sorted(&hcx, true)
|
||||
});
|
||||
|
||||
let all_impls: Vec<_> = all_impls
|
||||
.into_iter()
|
||||
.map(|(&simp, impls)| {
|
||||
let mut impls: Vec<_> =
|
||||
impls.into_iter().map(|def_id| def_id.local_def_index).collect();
|
||||
impls.sort_by_cached_key(|&local_def_index| {
|
||||
tcx.hir().def_path_hash(LocalDefId { local_def_index })
|
||||
});
|
||||
|
||||
IncoherentImpls { self_ty: simp, impls: self.lazy_array(impls) }
|
||||
let all_impls: Vec<_> = tcx
|
||||
.crate_inherent_impls(())
|
||||
.unwrap()
|
||||
.incoherent_impls
|
||||
.iter()
|
||||
.map(|(&simp, impls)| IncoherentImpls {
|
||||
self_ty: simp,
|
||||
impls: self.lazy_array(impls.iter().map(|def_id| def_id.local_def_index)),
|
||||
})
|
||||
.collect();
|
||||
|
||||
|
@ -2317,6 +2297,8 @@ pub fn provide(providers: &mut Providers) {
|
|||
span_bug!(tcx.def_span(def_id), "no traits in scope for a doc link")
|
||||
})
|
||||
},
|
||||
|
||||
// TODO: Uplift these into
|
||||
traits: |tcx, LocalCrate| {
|
||||
let mut traits = Vec::new();
|
||||
for id in tcx.hir().items() {
|
||||
|
@ -2325,8 +2307,6 @@ pub fn provide(providers: &mut Providers) {
|
|||
}
|
||||
}
|
||||
|
||||
// Bring everything into deterministic order.
|
||||
traits.sort_by_cached_key(|&def_id| tcx.def_path_hash(def_id));
|
||||
tcx.arena.alloc_slice(&traits)
|
||||
},
|
||||
trait_impls_in_crate: |tcx, LocalCrate| {
|
||||
|
@ -2339,8 +2319,6 @@ pub fn provide(providers: &mut Providers) {
|
|||
}
|
||||
}
|
||||
|
||||
// Bring everything into deterministic order.
|
||||
trait_impls.sort_by_cached_key(|&def_id| tcx.def_path_hash(def_id));
|
||||
tcx.arena.alloc_slice(&trait_impls)
|
||||
},
|
||||
|
||||
|
|
|
@ -40,7 +40,6 @@ use rustc_data_structures::intern::Interned;
|
|||
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
|
||||
use rustc_data_structures::steal::Steal;
|
||||
use rustc_data_structures::tagged_ptr::CopyTaggedPtr;
|
||||
use rustc_data_structures::unord::UnordMap;
|
||||
use rustc_errors::{Diag, ErrorGuaranteed, StashKey};
|
||||
use rustc_hir as hir;
|
||||
use rustc_hir::def::{CtorKind, CtorOf, DefKind, DocLinkResMap, LifetimeRes, Res};
|
||||
|
@ -2096,8 +2095,8 @@ pub fn provide(providers: &mut Providers) {
|
|||
/// (constructing this map requires touching the entire crate).
|
||||
#[derive(Clone, Debug, Default, HashStable)]
|
||||
pub struct CrateInherentImpls {
|
||||
pub inherent_impls: LocalDefIdMap<Vec<DefId>>,
|
||||
pub incoherent_impls: UnordMap<SimplifiedType, Vec<LocalDefId>>,
|
||||
pub inherent_impls: FxIndexMap<LocalDefId, Vec<DefId>>,
|
||||
pub incoherent_impls: FxIndexMap<SimplifiedType, Vec<LocalDefId>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, HashStable)]
|
||||
|
|
Loading…
Reference in New Issue