From b6e8635fefebd80647ecd2463f0c90df79c81ca4 Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Fri, 2 Jun 2017 15:45:56 +0200 Subject: [PATCH 1/4] ICH: Make StableHashingContext work with any TyCtxt, not just the global one. --- src/librustc/ich/caching_codemap_view.rs | 4 +- src/librustc/ich/hcx.rs | 74 +++++++------- src/librustc/ich/impls_hir.rs | 99 ++++++++++--------- src/librustc/ich/impls_mir.rs | 78 ++++++++------- src/librustc/ich/impls_syntax.rs | 40 ++++---- src/librustc/ich/impls_ty.rs | 94 ++++++++++-------- src/librustc/macros.rs | 16 +-- src/librustc/mir/cache.rs | 4 +- src/librustc/ty/mod.rs | 8 +- src/librustc_incremental/calculate_svh/mod.rs | 4 +- src/librustc_metadata/isolated_encoder.rs | 12 +-- src/librustc_metadata/schema.rs | 14 +-- 12 files changed, 239 insertions(+), 208 deletions(-) diff --git a/src/librustc/ich/caching_codemap_view.rs b/src/librustc/ich/caching_codemap_view.rs index 9aecd8ad83602..bf47b9bb9d43d 100644 --- a/src/librustc/ich/caching_codemap_view.rs +++ b/src/librustc/ich/caching_codemap_view.rs @@ -29,8 +29,8 @@ pub struct CachingCodemapView<'tcx> { time_stamp: usize, } -impl<'tcx> CachingCodemapView<'tcx> { - pub fn new<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CachingCodemapView<'tcx> { +impl<'gcx> CachingCodemapView<'gcx> { + pub fn new<'a, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> CachingCodemapView<'gcx> { let codemap = tcx.sess.codemap(); let files = codemap.files(); let first_file = files[0].clone(); diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs index a835548894182..2784a7bd024f6 100644 --- a/src/librustc/ich/hcx.rs +++ b/src/librustc/ich/hcx.rs @@ -33,9 +33,9 @@ use rustc_data_structures::accumulate_vec::AccumulateVec; /// enough information to transform DefIds and HirIds into stable DefPaths (i.e. /// a reference to the TyCtxt) and it holds a few caches for speeding up various /// things (e.g. each DefId/DefPath is only hashed once). -pub struct StableHashingContext<'a, 'tcx: 'a> { - tcx: ty::TyCtxt<'a, 'tcx, 'tcx>, - codemap: CachingCodemapView<'tcx>, +pub struct StableHashingContext<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { + tcx: ty::TyCtxt<'a, 'gcx, 'tcx>, + codemap: CachingCodemapView<'gcx>, hash_spans: bool, hash_bodies: bool, overflow_checks_enabled: bool, @@ -51,9 +51,9 @@ pub enum NodeIdHashingMode { HashTraitsInScope, } -impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> { +impl<'a, 'gcx, 'tcx> StableHashingContext<'a, 'gcx, 'tcx> { - pub fn new(tcx: ty::TyCtxt<'a, 'tcx, 'tcx>) -> Self { + pub fn new(tcx: ty::TyCtxt<'a, 'gcx, 'tcx>) -> Self { let hash_spans_initial = tcx.sess.opts.debuginfo != NoDebugInfo; let check_overflow_initial = tcx.sess.overflow_checks(); @@ -111,7 +111,7 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> { } #[inline] - pub fn tcx(&self) -> ty::TyCtxt<'a, 'tcx, 'tcx> { + pub fn tcx(&self) -> ty::TyCtxt<'a, 'gcx, 'tcx> { self.tcx } @@ -131,7 +131,7 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> { } #[inline] - pub fn codemap(&mut self) -> &mut CachingCodemapView<'tcx> { + pub fn codemap(&mut self) -> &mut CachingCodemapView<'gcx> { &mut self.codemap } @@ -195,9 +195,9 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> { } -impl<'a, 'tcx> HashStable> for ast::NodeId { +impl<'a, 'gcx, 'tcx> HashStable> for ast::NodeId { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { match hcx.node_id_hashing_mode { NodeIdHashingMode::Ignore => { @@ -230,7 +230,7 @@ impl<'a, 'tcx> HashStable> for ast::NodeId { } } -impl<'a, 'tcx> HashStable> for Span { +impl<'a, 'gcx, 'tcx> HashStable> for Span { // Hash a span in a stable way. We can't directly hash the span's BytePos // fields (that would be similar to hashing pointers, since those are just @@ -242,7 +242,7 @@ impl<'a, 'tcx> HashStable> for Span { // Also, hashing filenames is expensive so we avoid doing it twice when the // span starts and ends in the same file, which is almost always the case. fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use syntax_pos::Pos; @@ -305,15 +305,16 @@ impl<'a, 'tcx> HashStable> for Span { } } -pub fn hash_stable_hashmap<'a, 'tcx, K, V, R, SK, F, W>(hcx: &mut StableHashingContext<'a, 'tcx>, - hasher: &mut StableHasher, - map: &HashMap, - extract_stable_key: F) +pub fn hash_stable_hashmap<'a, 'gcx, 'tcx, K, V, R, SK, F, W>( + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, + hasher: &mut StableHasher, + map: &HashMap, + extract_stable_key: F) where K: Eq + std_hash::Hash, - V: HashStable>, + V: HashStable>, R: std_hash::BuildHasher, - SK: HashStable> + Ord + Clone, - F: Fn(&mut StableHashingContext<'a, 'tcx>, &K) -> SK, + SK: HashStable> + Ord + Clone, + F: Fn(&mut StableHashingContext<'a, 'gcx, 'tcx>, &K) -> SK, W: StableHasherResult, { let mut keys: Vec<_> = map.keys() @@ -327,14 +328,15 @@ pub fn hash_stable_hashmap<'a, 'tcx, K, V, R, SK, F, W>(hcx: &mut StableHashingC } } -pub fn hash_stable_hashset<'a, 'tcx, K, R, SK, F, W>(hcx: &mut StableHashingContext<'a, 'tcx>, - hasher: &mut StableHasher, - set: &HashSet, - extract_stable_key: F) +pub fn hash_stable_hashset<'a, 'tcx, 'gcx, K, R, SK, F, W>( + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, + hasher: &mut StableHasher, + set: &HashSet, + extract_stable_key: F) where K: Eq + std_hash::Hash, R: std_hash::BuildHasher, - SK: HashStable> + Ord + Clone, - F: Fn(&mut StableHashingContext<'a, 'tcx>, &K) -> SK, + SK: HashStable> + Ord + Clone, + F: Fn(&mut StableHashingContext<'a, 'gcx, 'tcx>, &K) -> SK, W: StableHasherResult, { let mut keys: Vec<_> = set.iter() @@ -344,10 +346,11 @@ pub fn hash_stable_hashset<'a, 'tcx, K, R, SK, F, W>(hcx: &mut StableHashingCont keys.hash_stable(hcx, hasher); } -pub fn hash_stable_nodemap<'a, 'tcx, V, W>(hcx: &mut StableHashingContext<'a, 'tcx>, - hasher: &mut StableHasher, - map: &NodeMap) - where V: HashStable>, +pub fn hash_stable_nodemap<'a, 'tcx, 'gcx, V, W>( + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, + hasher: &mut StableHasher, + map: &NodeMap) + where V: HashStable>, W: StableHasherResult, { hash_stable_hashmap(hcx, hasher, map, |hcx, node_id| { @@ -356,14 +359,15 @@ pub fn hash_stable_nodemap<'a, 'tcx, V, W>(hcx: &mut StableHashingContext<'a, 't } -pub fn hash_stable_btreemap<'a, 'tcx, K, V, SK, F, W>(hcx: &mut StableHashingContext<'a, 'tcx>, - hasher: &mut StableHasher, - map: &BTreeMap, - extract_stable_key: F) +pub fn hash_stable_btreemap<'a, 'tcx, 'gcx, K, V, SK, F, W>( + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, + hasher: &mut StableHasher, + map: &BTreeMap, + extract_stable_key: F) where K: Eq + Ord, - V: HashStable>, - SK: HashStable> + Ord + Clone, - F: Fn(&mut StableHashingContext<'a, 'tcx>, &K) -> SK, + V: HashStable>, + SK: HashStable> + Ord + Clone, + F: Fn(&mut StableHashingContext<'a, 'gcx, 'tcx>, &K) -> SK, W: StableHasherResult, { let mut keys: Vec<_> = map.keys() diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index c582cac67e22b..678ec797a86b1 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -21,20 +21,20 @@ use syntax::ast; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; -impl<'a, 'tcx> HashStable> for DefId { +impl<'a, 'gcx, 'tcx> HashStable> for DefId { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { hcx.def_path_hash(*self).hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for hir::HirId { +impl<'a, 'gcx, 'tcx> HashStable> for hir::HirId { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::HirId { owner, @@ -55,9 +55,9 @@ impl_stable_hash_for!(tuple_struct hir::ItemLocalId { index }); // want to pick up on a reference changing its target, so we hash the NodeIds // in "DefPath Mode". -impl<'a, 'tcx> HashStable> for hir::ItemId { +impl<'a, 'gcx, 'tcx> HashStable> for hir::ItemId { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::ItemId { id @@ -69,9 +69,9 @@ impl<'a, 'tcx> HashStable> for hir::ItemId { } } -impl<'a, 'tcx> HashStable> for hir::TraitItemId { +impl<'a, 'gcx, 'tcx> HashStable> for hir::TraitItemId { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::TraitItemId { node_id @@ -83,9 +83,9 @@ impl<'a, 'tcx> HashStable> for hir::TraitItemId { } } -impl<'a, 'tcx> HashStable> for hir::ImplItemId { +impl<'a, 'gcx, 'tcx> HashStable> for hir::ImplItemId { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::ImplItemId { node_id @@ -215,9 +215,9 @@ impl_stable_hash_for!(struct hir::TypeBinding { span }); -impl<'a, 'tcx> HashStable> for hir::Ty { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Ty { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let node_id_hashing_mode = match self.node { hir::TySlice(..) | @@ -299,9 +299,9 @@ impl_stable_hash_for!(enum hir::FunctionRetTy { Return(t) }); -impl<'a, 'tcx> HashStable> for hir::TraitRef { +impl<'a, 'gcx, 'tcx> HashStable> for hir::TraitRef { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::TraitRef { ref path, @@ -338,9 +338,9 @@ impl_stable_hash_for!(struct hir::MacroDef { }); -impl<'a, 'tcx> HashStable> for hir::Block { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Block { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::Block { ref stmts, @@ -386,9 +386,9 @@ impl<'a, 'tcx> HashStable> for hir::Block { } } -impl<'a, 'tcx> HashStable> for hir::Pat { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Pat { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let node_id_hashing_mode = match self.node { hir::PatKind::Wild | @@ -529,9 +529,9 @@ impl_stable_hash_for!(enum hir::UnsafeSource { UserProvided }); -impl<'a, 'tcx> HashStable> for hir::Expr { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Expr { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { hcx.while_hashing_hir_bodies(true, |hcx| { let hir::Expr { @@ -652,9 +652,9 @@ impl_stable_hash_for!(enum hir::LoopSource { ForLoop }); -impl<'a, 'tcx> HashStable> for hir::MatchSource { +impl<'a, 'gcx, 'tcx> HashStable> for hir::MatchSource { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use hir::MatchSource; @@ -703,9 +703,9 @@ impl_stable_hash_for!(enum hir::ScopeTarget { Loop(loop_id_result) }); -impl<'a, 'tcx> HashStable> for ast::Ident { +impl<'a, 'gcx, 'tcx> HashStable> for ast::Ident { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ast::Ident { ref name, @@ -716,9 +716,9 @@ impl<'a, 'tcx> HashStable> for ast::Ident { } } -impl<'a, 'tcx> HashStable> for hir::TraitItem { +impl<'a, 'gcx, 'tcx> HashStable> for hir::TraitItem { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::TraitItem { id, @@ -749,9 +749,9 @@ impl_stable_hash_for!(enum hir::TraitItemKind { Type(bounds, rhs) }); -impl<'a, 'tcx> HashStable> for hir::ImplItem { +impl<'a, 'gcx, 'tcx> HashStable> for hir::ImplItem { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::ImplItem { id, @@ -781,9 +781,9 @@ impl_stable_hash_for!(enum hir::ImplItemKind { Type(t) }); -impl<'a, 'tcx> HashStable> for hir::Visibility { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Visibility { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -802,9 +802,9 @@ impl<'a, 'tcx> HashStable> for hir::Visibility { } } -impl<'a, 'tcx> HashStable> for hir::Defaultness { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Defaultness { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -823,9 +823,9 @@ impl_stable_hash_for!(enum hir::ImplPolarity { Negative }); -impl<'a, 'tcx> HashStable> for hir::Mod { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Mod { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::Mod { inner, @@ -878,9 +878,9 @@ impl_stable_hash_for!(enum hir::VariantData { Unit(id) }); -impl<'a, 'tcx> HashStable> for hir::Item { +impl<'a, 'gcx, 'tcx> HashStable> for hir::Item { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let node_id_hashing_mode = match self.node { hir::ItemExternCrate(..) | @@ -961,9 +961,10 @@ impl_stable_hash_for!(struct hir::ImplItemRef { defaultness }); -impl<'a, 'tcx> HashStable> for hir::AssociatedItemKind { +impl<'a, 'gcx, 'tcx> HashStable> +for hir::AssociatedItemKind { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -1008,9 +1009,9 @@ impl_stable_hash_for!(struct hir::Body { value }); -impl<'a, 'tcx> HashStable> for hir::BodyId { +impl<'a, 'gcx, 'tcx> HashStable> for hir::BodyId { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { if hcx.hash_bodies() { hcx.tcx().hir.body(*self).hash_stable(hcx, hasher); @@ -1024,9 +1025,9 @@ impl_stable_hash_for!(struct hir::InlineAsmOutput { is_indirect }); -impl<'a, 'tcx> HashStable> for hir::GlobalAsm { +impl<'a, 'gcx, 'tcx> HashStable> for hir::GlobalAsm { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::GlobalAsm { asm, @@ -1037,9 +1038,9 @@ impl<'a, 'tcx> HashStable> for hir::GlobalAsm { } } -impl<'a, 'tcx> HashStable> for hir::InlineAsm { +impl<'a, 'gcx, 'tcx> HashStable> for hir::InlineAsm { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let hir::InlineAsm { asm, @@ -1114,10 +1115,11 @@ impl_stable_hash_for!(enum hir::Constness { NotConst }); -impl<'a, 'tcx> HashStable> for hir::def_id::DefIndex { +impl<'a, 'gcx, 'tcx> HashStable> +for hir::def_id::DefIndex { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { DefId::local(*self).hash_stable(hcx, hasher); } @@ -1129,9 +1131,10 @@ impl_stable_hash_for!(struct hir::def::Export { span }); -impl<'a, 'tcx> HashStable> for ::middle::lang_items::LangItem { +impl<'a, 'gcx, 'tcx> HashStable> +for ::middle::lang_items::LangItem { fn hash_stable(&self, - _: &mut StableHashingContext<'a, 'tcx>, + _: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { ::std::hash::Hash::hash(self, hasher); } diff --git a/src/librustc/ich/impls_mir.rs b/src/librustc/ich/impls_mir.rs index edaeb596fe58d..ae2bea3027d44 100644 --- a/src/librustc/ich/impls_mir.rs +++ b/src/librustc/ich/impls_mir.rs @@ -32,10 +32,11 @@ impl_stable_hash_for!(struct mir::LocalDecl<'tcx> { impl_stable_hash_for!(struct mir::UpvarDecl { debug_name, by_ref }); impl_stable_hash_for!(struct mir::BasicBlockData<'tcx> { statements, terminator, is_cleanup }); -impl<'a, 'tcx> HashStable> for mir::Terminator<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::Terminator<'tcx> { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let mir::Terminator { ref kind, @@ -72,59 +73,61 @@ impl<'a, 'tcx> HashStable> for mir::Terminator<'t } -impl<'a, 'tcx> HashStable> for mir::Local { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Local { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use rustc_data_structures::indexed_vec::Idx; self.index().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for mir::BasicBlock { +impl<'a, 'gcx, 'tcx> HashStable> for mir::BasicBlock { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use rustc_data_structures::indexed_vec::Idx; self.index().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for mir::Field { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Field { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use rustc_data_structures::indexed_vec::Idx; self.index().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for mir::VisibilityScope { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::VisibilityScope { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use rustc_data_structures::indexed_vec::Idx; self.index().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for mir::Promoted { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Promoted { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use rustc_data_structures::indexed_vec::Idx; self.index().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for mir::TerminatorKind<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::TerminatorKind<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); @@ -182,9 +185,10 @@ impl<'a, 'tcx> HashStable> for mir::TerminatorKin } } -impl<'a, 'tcx> HashStable> for mir::AssertMessage<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::AssertMessage<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); @@ -202,9 +206,10 @@ impl<'a, 'tcx> HashStable> for mir::AssertMessage impl_stable_hash_for!(struct mir::Statement<'tcx> { source_info, kind }); -impl<'a, 'tcx> HashStable> for mir::StatementKind<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::StatementKind<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); @@ -231,9 +236,9 @@ impl<'a, 'tcx> HashStable> for mir::StatementKind } } -impl<'a, 'tcx> HashStable> for mir::Lvalue<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Lvalue<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -250,12 +255,13 @@ impl<'a, 'tcx> HashStable> for mir::Lvalue<'tcx> } } -impl<'a, 'tcx, B, V> HashStable> for mir::Projection<'tcx, B, V> - where B: HashStable>, - V: HashStable> +impl<'a, 'gcx, 'tcx, B, V> HashStable> +for mir::Projection<'tcx, B, V> + where B: HashStable>, + V: HashStable> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let mir::Projection { ref base, @@ -267,11 +273,12 @@ impl<'a, 'tcx, B, V> HashStable> for mir::Project } } -impl<'a, 'tcx, V> HashStable> for mir::ProjectionElem<'tcx, V> - where V: HashStable> +impl<'a, 'gcx, 'tcx, V> HashStable> +for mir::ProjectionElem<'tcx, V> + where V: HashStable> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -302,9 +309,9 @@ impl<'a, 'tcx, V> HashStable> for mir::Projection impl_stable_hash_for!(struct mir::VisibilityScopeData { span, parent_scope }); -impl<'a, 'tcx> HashStable> for mir::Operand<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Operand<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); @@ -319,9 +326,9 @@ impl<'a, 'tcx> HashStable> for mir::Operand<'tcx> } } -impl<'a, 'tcx> HashStable> for mir::Rvalue<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Rvalue<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); @@ -379,9 +386,10 @@ impl_stable_hash_for!(enum mir::CastKind { Unsize }); -impl<'a, 'tcx> HashStable> for mir::AggregateKind<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for mir::AggregateKind<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -435,9 +443,9 @@ impl_stable_hash_for!(enum mir::NullOp { impl_stable_hash_for!(struct mir::Constant<'tcx> { span, ty, literal }); -impl<'a, 'tcx> HashStable> for mir::Literal<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for mir::Literal<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs index f6ad97445e8bf..995f797df2fbe 100644 --- a/src/librustc/ich/impls_syntax.rs +++ b/src/librustc/ich/impls_syntax.rs @@ -27,20 +27,21 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; use rustc_data_structures::accumulate_vec::AccumulateVec; -impl<'a, 'tcx> HashStable> for ::syntax::symbol::InternedString { +impl<'a, 'gcx, 'tcx> HashStable> +for ::syntax::symbol::InternedString { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let s: &str = &**self; s.hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for ast::Name { +impl<'a, 'gcx, 'tcx> HashStable> for ast::Name { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { self.as_str().hash_stable(hcx, hasher); } @@ -82,9 +83,10 @@ impl_stable_hash_for!(enum ::syntax::abi::Abi { impl_stable_hash_for!(struct ::syntax::attr::Deprecation { since, note }); impl_stable_hash_for!(struct ::syntax::attr::Stability { level, feature, rustc_depr }); -impl<'a, 'tcx> HashStable> for ::syntax::attr::StabilityLevel { +impl<'a, 'gcx, 'tcx> HashStable> +for ::syntax::attr::StabilityLevel { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -135,9 +137,9 @@ impl_stable_hash_for!(struct ::syntax::ast::Lifetime { id, span, ident }); impl_stable_hash_for!(enum ::syntax::ast::StrStyle { Cooked, Raw(pounds) }); impl_stable_hash_for!(enum ::syntax::ast::AttrStyle { Outer, Inner }); -impl<'a, 'tcx> HashStable> for [ast::Attribute] { +impl<'a, 'gcx, 'tcx> HashStable> for [ast::Attribute] { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { // Some attributes are always ignored during hashing. let filtered: AccumulateVec<[&ast::Attribute; 8]> = self @@ -155,9 +157,9 @@ impl<'a, 'tcx> HashStable> for [ast::Attribute] { } } -impl<'a, 'tcx> HashStable> for ast::Attribute { +impl<'a, 'gcx, 'tcx> HashStable> for ast::Attribute { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { // Make sure that these have been filtered out. debug_assert!(self.name().map(|name| !hcx.is_ignored_attr(name)).unwrap_or(true)); @@ -184,9 +186,10 @@ impl<'a, 'tcx> HashStable> for ast::Attribute { } } -impl<'a, 'tcx> HashStable> for tokenstream::TokenTree { +impl<'a, 'gcx, 'tcx> HashStable> +for tokenstream::TokenTree { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -205,9 +208,10 @@ impl<'a, 'tcx> HashStable> for tokenstream::Token } } -impl<'a, 'tcx> HashStable> for tokenstream::TokenStream { +impl<'a, 'gcx, 'tcx> HashStable> +for tokenstream::TokenStream { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { for sub_tt in self.trees() { sub_tt.hash_stable(hcx, hasher); @@ -215,8 +219,8 @@ impl<'a, 'tcx> HashStable> for tokenstream::Token } } -fn hash_token<'a, 'tcx, W: StableHasherResult>(token: &token::Token, - hcx: &mut StableHashingContext<'a, 'tcx>, +fn hash_token<'a, 'gcx, 'tcx, W: StableHasherResult>(token: &token::Token, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher, error_reporting_span: Span) { mem::discriminant(token).hash_stable(hcx, hasher); @@ -322,9 +326,9 @@ impl_stable_hash_for!(enum ::syntax::ast::MetaItemKind { NameValue(lit) }); -impl<'a, 'tcx> HashStable> for FileMap { +impl<'a, 'gcx, 'tcx> HashStable> for FileMap { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let FileMap { ref name, diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index a362dc31ff180..4e78d79ef8737 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -19,27 +19,30 @@ use std::mem; use syntax_pos::symbol::InternedString; use ty; -impl<'a, 'tcx, T> HashStable> for &'tcx ty::Slice - where T: HashStable> { +impl<'a, 'gcx, 'tcx, T> HashStable> +for &'tcx ty::Slice + where T: HashStable> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { (&self[..]).hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for ty::subst::Kind<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::subst::Kind<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { self.as_type().hash_stable(hcx, hasher); self.as_region().hash_stable(hcx, hasher); } } -impl<'a, 'tcx> HashStable> for ty::RegionKind { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::RegionKind { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -72,9 +75,10 @@ impl<'a, 'tcx> HashStable> for ty::RegionKind { } } -impl<'a, 'tcx> HashStable> for ty::adjustment::AutoBorrow<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::adjustment::AutoBorrow<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -89,9 +93,10 @@ impl<'a, 'tcx> HashStable> for ty::adjustment::Au } } -impl<'a, 'tcx> HashStable> for ty::adjustment::Adjust<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::adjustment::Adjust<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -122,9 +127,10 @@ impl_stable_hash_for!(enum ty::BorrowKind { MutBorrow }); -impl<'a, 'tcx> HashStable> for ty::UpvarCapture<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::UpvarCapture<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -143,11 +149,11 @@ impl_stable_hash_for!(struct ty::FnSig<'tcx> { abi }); -impl<'a, 'tcx, T> HashStable> for ty::Binder - where T: HashStable> + ty::fold::TypeFoldable<'tcx> +impl<'a, 'gcx, 'tcx, T> HashStable> for ty::Binder + where T: HashStable> + ty::fold::TypeFoldable<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { hcx.tcx().anonymize_late_bound_regions(self).0.hash_stable(hcx, hasher); } @@ -166,12 +172,13 @@ impl_stable_hash_for!(struct ty::TraitPredicate<'tcx> { trait_ref }); impl_stable_hash_for!(tuple_struct ty::EquatePredicate<'tcx> { t1, t2 }); impl_stable_hash_for!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b }); -impl<'a, 'tcx, A, B> HashStable> for ty::OutlivesPredicate - where A: HashStable>, - B: HashStable>, +impl<'a, 'gcx, 'tcx, A, B> HashStable> +for ty::OutlivesPredicate + where A: HashStable>, + B: HashStable>, { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::OutlivesPredicate(ref a, ref b) = *self; a.hash_stable(hcx, hasher); @@ -183,9 +190,9 @@ impl_stable_hash_for!(struct ty::ProjectionPredicate<'tcx> { projection_ty, ty } impl_stable_hash_for!(struct ty::ProjectionTy<'tcx> { trait_ref, item_def_id }); -impl<'a, 'tcx> HashStable> for ty::Predicate<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for ty::Predicate<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -221,9 +228,9 @@ impl<'a, 'tcx> HashStable> for ty::Predicate<'tcx } } -impl<'a, 'tcx> HashStable> for ty::AdtFlags { +impl<'a, 'gcx, 'tcx> HashStable> for ty::AdtFlags { fn hash_stable(&self, - _: &mut StableHashingContext<'a, 'tcx>, + _: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { std_hash::Hash::hash(self, hasher); } @@ -248,10 +255,10 @@ impl_stable_hash_for!(struct ty::FieldDef { vis }); -impl<'a, 'tcx> HashStable> +impl<'a, 'gcx, 'tcx> HashStable> for ::middle::const_val::ConstVal<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use middle::const_val::ConstVal; @@ -324,9 +331,9 @@ impl_stable_hash_for!(enum ty::adjustment::CustomCoerceUnsized { Struct(index) }); -impl<'a, 'tcx> HashStable> for ty::Generics { +impl<'a, 'gcx, 'tcx> HashStable> for ty::Generics { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::Generics { parent, @@ -350,9 +357,10 @@ impl<'a, 'tcx> HashStable> for ty::Generics { } } -impl<'a, 'tcx> HashStable> for ty::RegionParameterDef { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::RegionParameterDef { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::RegionParameterDef { name, @@ -379,12 +387,12 @@ impl_stable_hash_for!(struct ty::TypeParameterDef { }); -impl<'a, 'tcx, T> HashStable> +impl<'a, 'gcx, 'tcx, T> HashStable> for ::middle::resolve_lifetime::Set1 - where T: HashStable> + where T: HashStable> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use middle::resolve_lifetime::Set1; @@ -427,10 +435,11 @@ impl_stable_hash_for!(enum ty::cast::CastKind { FnPtrAddrCast }); -impl<'a, 'tcx> HashStable> for ::middle::region::CodeExtent +impl<'a, 'gcx, 'tcx> HashStable> +for ::middle::region::CodeExtent { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use middle::region::CodeExtent; @@ -472,10 +481,11 @@ impl_stable_hash_for!(enum ty::BoundRegion { BrEnv }); -impl<'a, 'tcx> HashStable> for ty::TypeVariants<'tcx> +impl<'a, 'gcx, 'tcx> HashStable> +for ty::TypeVariants<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { use ty::TypeVariants::*; @@ -563,10 +573,11 @@ impl_stable_hash_for!(struct ty::TypeAndMut<'tcx> { mutbl }); -impl<'a, 'tcx> HashStable> for ty::ExistentialPredicate<'tcx> +impl<'a, 'gcx, 'tcx> HashStable> +for ty::ExistentialPredicate<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -595,9 +606,10 @@ impl_stable_hash_for!(struct ty::ExistentialProjection<'tcx> { }); -impl<'a, 'tcx> HashStable> for ty::TypeckTables<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> +for ty::TypeckTables<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::TypeckTables { ref type_dependent_defs, diff --git a/src/librustc/macros.rs b/src/librustc/macros.rs index c18e585f79553..f814f941b06f1 100644 --- a/src/librustc/macros.rs +++ b/src/librustc/macros.rs @@ -73,10 +73,10 @@ macro_rules! __impl_stable_hash_field { #[macro_export] macro_rules! impl_stable_hash_for { (enum $enum_name:path { $( $variant:ident $( ( $($arg:ident),* ) )* ),* }) => { - impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'tcx>> for $enum_name { + impl<'a, 'gcx, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'gcx, 'tcx>> for $enum_name { #[inline] fn hash_stable(&self, - __ctx: &mut $crate::ich::StableHashingContext<'a, 'tcx>, + __ctx: &mut $crate::ich::StableHashingContext<'a, 'gcx, 'tcx>, __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher) { use $enum_name::*; ::std::mem::discriminant(self).hash_stable(__ctx, __hasher); @@ -92,10 +92,10 @@ macro_rules! impl_stable_hash_for { } }; (struct $struct_name:path { $($field:ident),* }) => { - impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'tcx>> for $struct_name { + impl<'a, 'gcx, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'gcx, 'tcx>> for $struct_name { #[inline] fn hash_stable(&self, - __ctx: &mut $crate::ich::StableHashingContext<'a, 'tcx>, + __ctx: &mut $crate::ich::StableHashingContext<'a, 'gcx, 'tcx>, __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher) { let $struct_name { $(ref $field),* @@ -106,10 +106,10 @@ macro_rules! impl_stable_hash_for { } }; (tuple_struct $struct_name:path { $($field:ident),* }) => { - impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'tcx>> for $struct_name { + impl<'a, 'gcx, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a, 'gcx, 'tcx>> for $struct_name { #[inline] fn hash_stable(&self, - __ctx: &mut $crate::ich::StableHashingContext<'a, 'tcx>, + __ctx: &mut $crate::ich::StableHashingContext<'a, 'gcx, 'tcx>, __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher) { let $struct_name ( $(ref $field),* @@ -125,11 +125,11 @@ macro_rules! impl_stable_hash_for { macro_rules! impl_stable_hash_for_spanned { ($T:path) => ( - impl<'a, 'tcx> HashStable> for ::syntax::codemap::Spanned<$T> + impl<'a, 'gcx, 'tcx> HashStable> for ::syntax::codemap::Spanned<$T> { #[inline] fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { self.node.hash_stable(hcx, hasher); self.span.hash_stable(hcx, hasher); diff --git a/src/librustc/mir/cache.rs b/src/librustc/mir/cache.rs index 799686ceca4a0..73c702fedb816 100644 --- a/src/librustc/mir/cache.rs +++ b/src/librustc/mir/cache.rs @@ -35,9 +35,9 @@ impl serialize::Decodable for Cache { } } -impl<'a, 'tcx> HashStable> for Cache { +impl<'a, 'gcx, 'tcx> HashStable> for Cache { fn hash_stable(&self, - _: &mut StableHashingContext<'a, 'tcx>, + _: &mut StableHashingContext<'a, 'gcx, 'tcx>, _: &mut StableHasher) { // do nothing } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 653021119aab7..afa2da3d561b7 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -465,9 +465,9 @@ impl<'tcx> Hash for TyS<'tcx> { } } -impl<'a, 'tcx> HashStable> for ty::TyS<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for ty::TyS<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::TyS { ref sty, @@ -1318,9 +1318,9 @@ impl<'tcx> serialize::UseSpecializedEncodable for &'tcx AdtDef { impl<'tcx> serialize::UseSpecializedDecodable for &'tcx AdtDef {} -impl<'a, 'tcx> HashStable> for AdtDef { +impl<'a, 'gcx, 'tcx> HashStable> for AdtDef { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let ty::AdtDef { did, diff --git a/src/librustc_incremental/calculate_svh/mod.rs b/src/librustc_incremental/calculate_svh/mod.rs index be4d610a89559..7831ae3092f4e 100644 --- a/src/librustc_incremental/calculate_svh/mod.rs +++ b/src/librustc_incremental/calculate_svh/mod.rs @@ -94,7 +94,7 @@ impl<'a> ::std::ops::Index<&'a DepNode> for IncrementalHashesMap { } struct ComputeItemHashesVisitor<'a, 'tcx: 'a> { - hcx: StableHashingContext<'a, 'tcx>, + hcx: StableHashingContext<'a, 'tcx, 'tcx>, hashes: IncrementalHashesMap, } @@ -103,7 +103,7 @@ impl<'a, 'tcx: 'a> ComputeItemHashesVisitor<'a, 'tcx> { dep_node: DepNode, hash_bodies: bool, item_like: T) - where T: HashStable> + where T: HashStable> { if !hash_bodies && !self.hcx.tcx().sess.opts.build_dep_graph() { // If we just need the hashes in order to compute the SVH, we don't diff --git a/src/librustc_metadata/isolated_encoder.rs b/src/librustc_metadata/isolated_encoder.rs index ed1680fbfaee8..c4116489357af 100644 --- a/src/librustc_metadata/isolated_encoder.rs +++ b/src/librustc_metadata/isolated_encoder.rs @@ -23,7 +23,7 @@ use rustc_serialize::Encodable; pub struct IsolatedEncoder<'a, 'b: 'a, 'tcx: 'b> { pub tcx: TyCtxt<'b, 'tcx, 'tcx>, ecx: &'a mut EncodeContext<'b, 'tcx>, - hcx: Option<(StableHashingContext<'b, 'tcx>, StableHasher)>, + hcx: Option<(StableHashingContext<'b, 'tcx, 'tcx>, StableHasher)>, } impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { @@ -61,7 +61,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { } pub fn lazy(&mut self, value: &T) -> Lazy - where T: Encodable + HashStable> + where T: Encodable + HashStable> { if let Some((ref mut hcx, ref mut hasher)) = self.hcx { value.hash_stable(hcx, hasher); @@ -72,7 +72,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { pub fn lazy_seq(&mut self, iter: I) -> LazySeq where I: IntoIterator, - T: Encodable + HashStable> + T: Encodable + HashStable> { if let Some((ref mut hcx, ref mut hasher)) = self.hcx { let iter = iter.into_iter(); @@ -111,7 +111,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { pub fn lazy_seq_ref<'x, I, T>(&mut self, iter: I) -> LazySeq where I: IntoIterator, - T: 'x + Encodable + HashStable> + T: 'x + Encodable + HashStable> { if let Some((ref mut hcx, ref mut hasher)) = self.hcx { let iter = iter.into_iter(); @@ -149,7 +149,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { } pub fn lazy_seq_from_slice(&mut self, slice: &[T]) -> LazySeq - where T: Encodable + HashStable> + where T: Encodable + HashStable> { if let Some((ref mut hcx, ref mut hasher)) = self.hcx { slice.hash_stable(hcx, hasher); @@ -159,7 +159,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { } pub fn lazy_seq_ref_from_slice(&mut self, slice: &[&T]) -> LazySeq - where T: Encodable + HashStable> + where T: Encodable + HashStable> { if let Some((ref mut hcx, ref mut hasher)) = self.hcx { slice.hash_stable(hcx, hasher); diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index 2ffe7cc02aaac..9180f9100ad71 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -221,11 +221,11 @@ impl Tracked { } } -impl<'a, 'tcx, T> HashStable> for Tracked - where T: HashStable> +impl<'a, 'gcx, 'tcx, T> HashStable> for Tracked + where T: HashStable> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let Tracked { ref state @@ -277,9 +277,9 @@ pub struct TraitImpls { pub impls: LazySeq, } -impl<'a, 'tcx> HashStable> for TraitImpls { +impl<'a, 'gcx, 'tcx> HashStable> for TraitImpls { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { let TraitImpls { trait_id: (krate, def_index), @@ -359,9 +359,9 @@ pub enum EntryKind<'tcx> { AssociatedConst(AssociatedContainer, u8), } -impl<'a, 'tcx> HashStable> for EntryKind<'tcx> { +impl<'a, 'gcx, 'tcx> HashStable> for EntryKind<'tcx> { fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'tcx>, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, hasher: &mut StableHasher) { mem::discriminant(self).hash_stable(hcx, hasher); match *self { From 7fc84907dc39bf36050ec0dfd57f82079f09d993 Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Fri, 2 Jun 2017 17:34:24 +0200 Subject: [PATCH 2/4] ICH: Add some HashStable implementations. --- src/librustc/ich/impls_hir.rs | 15 ++++++++++- src/librustc_data_structures/stable_hasher.rs | 26 +++++++++++++++++++ 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index 678ec797a86b1..7f7a545df9605 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -12,7 +12,7 @@ //! types in no particular order. use hir; -use hir::def_id::DefId; +use hir::def_id::{DefId, CrateNum, CRATE_DEF_INDEX}; use ich::{StableHashingContext, NodeIdHashingMode}; use std::mem; @@ -46,6 +46,19 @@ impl<'a, 'gcx, 'tcx> HashStable> for hir::H } } + +impl<'a, 'gcx, 'tcx> HashStable> for CrateNum { + #[inline] + fn hash_stable(&self, + hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, + hasher: &mut StableHasher) { + hcx.def_path_hash(DefId { + krate: *self, + index: CRATE_DEF_INDEX + }).hash_stable(hcx, hasher); + } +} + impl_stable_hash_for!(tuple_struct hir::ItemLocalId { index }); // The following implementations of HashStable for ItemId, TraitItemId, and diff --git a/src/librustc_data_structures/stable_hasher.rs b/src/librustc_data_structures/stable_hasher.rs index 635b95d861daf..634d3041bf4a7 100644 --- a/src/librustc_data_structures/stable_hasher.rs +++ b/src/librustc_data_structures/stable_hasher.rs @@ -244,6 +244,14 @@ impl HashStable for f64 { } } +impl, CTX> HashStable for (T1,) { + fn hash_stable(&self, + ctx: &mut CTX, + hasher: &mut StableHasher) { + self.0.hash_stable(ctx, hasher); + } +} + impl, T2: HashStable, CTX> HashStable for (T1, T2) { fn hash_stable(&self, ctx: &mut CTX, @@ -273,6 +281,24 @@ impl, CTX> HashStable for Vec { } } +impl, CTX> HashStable for ::std::rc::Rc { + #[inline] + fn hash_stable(&self, + ctx: &mut CTX, + hasher: &mut StableHasher) { + (**self).hash_stable(ctx, hasher); + } +} + +impl, CTX> HashStable for ::std::sync::Arc { + #[inline] + fn hash_stable(&self, + ctx: &mut CTX, + hasher: &mut StableHasher) { + (**self).hash_stable(ctx, hasher); + } +} + impl HashStable for str { #[inline] fn hash_stable(&self, From 12e5b699a493e3d67698a9a42c82f686684c32af Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Tue, 6 Jun 2017 15:09:21 +0200 Subject: [PATCH 3/4] incr.comp.: Make WorkProductId opaque so we don't accidentally rely on being able to reconstruct obj-file names from one. --- src/librustc/dep_graph/dep_node.rs | 17 ++++++++++++++--- src/librustc/dep_graph/graph.rs | 15 +++++++-------- src/librustc_incremental/persist/data.rs | 3 +-- src/librustc_incremental/persist/load.rs | 7 +++---- .../persist/work_product.rs | 3 +-- src/librustc_trans/partitioning.rs | 5 ++--- 6 files changed, 28 insertions(+), 22 deletions(-) diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 85a02953a9104..1a0f89a1e5361 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -9,8 +9,10 @@ // except according to those terms. use hir::def_id::CrateNum; +use ich::Fingerprint; +use rustc_data_structures::stable_hasher::StableHasher; use std::fmt::Debug; -use std::sync::Arc; +use std::hash::Hash; macro_rules! try_opt { ($e:expr) => ( @@ -56,7 +58,7 @@ pub enum DepNode { /// Represents some artifact that we save to disk. Note that these /// do not have a def-id as part of their identifier. - WorkProduct(Arc), + WorkProduct(WorkProductId), // Represents different phases in the compiler. RegionMaps(D), @@ -318,7 +320,16 @@ impl DepNode { /// the need to be mapped or unmapped. (This ensures we can serialize /// them even in the absence of a tcx.) #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] -pub struct WorkProductId(pub String); +pub struct WorkProductId(pub Fingerprint); + +impl WorkProductId { + pub fn from_cgu_name(cgu_name: &str) -> WorkProductId { + let mut hasher = StableHasher::new(); + cgu_name.len().hash(&mut hasher); + cgu_name.hash(&mut hasher); + WorkProductId(hasher.finish()) + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] pub enum GlobalMetaDataKind { diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs index 18eb4e5d0ad73..dc482b0d6ac85 100644 --- a/src/librustc/dep_graph/graph.rs +++ b/src/librustc/dep_graph/graph.rs @@ -13,7 +13,6 @@ use rustc_data_structures::fx::FxHashMap; use session::config::OutputType; use std::cell::{Ref, RefCell}; use std::rc::Rc; -use std::sync::Arc; use super::dep_node::{DepNode, WorkProductId}; use super::query::DepGraphQuery; @@ -35,10 +34,10 @@ struct DepGraphData { /// things available to us. If we find that they are not dirty, we /// load the path to the file storing those work-products here into /// this map. We can later look for and extract that data. - previous_work_products: RefCell, WorkProduct>>, + previous_work_products: RefCell>, /// Work-products that we generate in this run. - work_products: RefCell, WorkProduct>>, + work_products: RefCell>, } impl DepGraph { @@ -120,7 +119,7 @@ impl DepGraph { /// Indicates that a previous work product exists for `v`. This is /// invoked during initial start-up based on what nodes are clean /// (and what files exist in the incr. directory). - pub fn insert_previous_work_product(&self, v: &Arc, data: WorkProduct) { + pub fn insert_previous_work_product(&self, v: &WorkProductId, data: WorkProduct) { debug!("insert_previous_work_product({:?}, {:?})", v, data); self.data.previous_work_products.borrow_mut() .insert(v.clone(), data); @@ -129,7 +128,7 @@ impl DepGraph { /// Indicates that we created the given work-product in this run /// for `v`. This record will be preserved and loaded in the next /// run. - pub fn insert_work_product(&self, v: &Arc, data: WorkProduct) { + pub fn insert_work_product(&self, v: &WorkProductId, data: WorkProduct) { debug!("insert_work_product({:?}, {:?})", v, data); self.data.work_products.borrow_mut() .insert(v.clone(), data); @@ -137,7 +136,7 @@ impl DepGraph { /// Check whether a previous work product exists for `v` and, if /// so, return the path that leads to it. Used to skip doing work. - pub fn previous_work_product(&self, v: &Arc) -> Option { + pub fn previous_work_product(&self, v: &WorkProductId) -> Option { self.data.previous_work_products.borrow() .get(v) .cloned() @@ -145,13 +144,13 @@ impl DepGraph { /// Access the map of work-products created during this run. Only /// used during saving of the dep-graph. - pub fn work_products(&self) -> Ref, WorkProduct>> { + pub fn work_products(&self) -> Ref> { self.data.work_products.borrow() } /// Access the map of work-products created during the cached run. Only /// used during saving of the dep-graph. - pub fn previous_work_products(&self) -> Ref, WorkProduct>> { + pub fn previous_work_products(&self) -> Ref> { self.data.previous_work_products.borrow() } } diff --git a/src/librustc_incremental/persist/data.rs b/src/librustc_incremental/persist/data.rs index 682a7051a1e95..4669bb866d41b 100644 --- a/src/librustc_incremental/persist/data.rs +++ b/src/librustc_incremental/persist/data.rs @@ -15,7 +15,6 @@ use rustc::hir::def_id::DefIndex; use rustc::hir::map::DefPathHash; use rustc::ich::Fingerprint; use rustc::middle::cstore::EncodedMetadataHash; -use std::sync::Arc; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; @@ -98,7 +97,7 @@ pub struct SerializedHash { #[derive(Debug, RustcEncodable, RustcDecodable)] pub struct SerializedWorkProduct { /// node that produced the work-product - pub id: Arc, + pub id: WorkProductId, /// work-product data itself pub work_product: WorkProduct, diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index b30a1f4d3254f..f2ecf4c74e781 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -22,7 +22,6 @@ use rustc_serialize::Decodable as RustcDecodable; use rustc_serialize::opaque::Decoder; use std::default::Default; use std::path::{Path}; -use std::sync::Arc; use IncrementalHashesMap; use super::data::*; @@ -327,7 +326,7 @@ fn transitive_dirty_nodes(edge_map: &FxHashMap, Vec(tcx: TyCtxt<'a, 'tcx, 'tcx>, work_products: Vec, - clean_work_products: &FxHashSet>) { + clean_work_products: &FxHashSet) { debug!("reconcile_work_products({:?})", work_products); for swp in work_products { if !clean_work_products.contains(&swp.id) { @@ -424,8 +423,8 @@ fn process_edges<'a, 'tcx, 'edges>( target: &'edges DepNode, edges: &'edges FxHashMap, Vec>>, dirty_raw_nodes: &DirtyNodes, - clean_work_products: &mut FxHashSet>, - dirty_work_products: &mut FxHashSet>, + clean_work_products: &mut FxHashSet, + dirty_work_products: &mut FxHashSet, extra_edges: &mut Vec<(&'edges DepNode, &'edges DepNode)>) { // If the target is dirty, skip the edge. If this is an edge diff --git a/src/librustc_incremental/persist/work_product.rs b/src/librustc_incremental/persist/work_product.rs index 0e9f906154019..16ab10ab4bbbd 100644 --- a/src/librustc_incremental/persist/work_product.rs +++ b/src/librustc_incremental/persist/work_product.rs @@ -16,7 +16,6 @@ use rustc::session::Session; use rustc::session::config::OutputType; use rustc::util::fs::link_or_copy; use std::path::PathBuf; -use std::sync::Arc; use std::fs as std_fs; pub fn save_trans_partition(sess: &Session, @@ -30,7 +29,7 @@ pub fn save_trans_partition(sess: &Session, if sess.opts.incremental.is_none() { return; } - let work_product_id = Arc::new(WorkProductId(cgu_name.to_string())); + let work_product_id = WorkProductId::from_cgu_name(cgu_name); let saved_files: Option> = files.iter() diff --git a/src/librustc_trans/partitioning.rs b/src/librustc_trans/partitioning.rs index 2fe463e92a8aa..df8984e6d2479 100644 --- a/src/librustc_trans/partitioning.rs +++ b/src/librustc_trans/partitioning.rs @@ -114,7 +114,6 @@ use rustc::ty::{self, TyCtxt}; use rustc::ty::item_path::characteristic_def_id_of_type; use rustc_incremental::IchHasher; use std::hash::Hash; -use std::sync::Arc; use syntax::ast::NodeId; use syntax::symbol::{Symbol, InternedString}; use trans_item::{TransItem, InstantiationMode}; @@ -164,8 +163,8 @@ impl<'tcx> CodegenUnit<'tcx> { &self.items } - pub fn work_product_id(&self) -> Arc { - Arc::new(WorkProductId(self.name().to_string())) + pub fn work_product_id(&self) -> WorkProductId { + WorkProductId::from_cgu_name(self.name()) } pub fn work_product_dep_node(&self) -> DepNode { From 8b36d3308effcc013c9c4aea9d83fa1d8bd540c1 Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Wed, 7 Jun 2017 10:45:20 +0200 Subject: [PATCH 4/4] Allocate DefIndices for global crate metadata. This allows for treating global crate metadata the same as regular metadata with regard to incr. comp. --- src/librustc/dep_graph/dep_node.rs | 17 ---- src/librustc/dep_graph/mod.rs | 1 - src/librustc/hir/map/definitions.rs | 118 ++++++++++++++++++++--- src/librustc/middle/cstore.rs | 8 +- src/librustc/ty/item_path.rs | 3 +- src/librustc_incremental/persist/data.rs | 4 - src/librustc_incremental/persist/hash.rs | 37 ++----- src/librustc_incremental/persist/save.rs | 6 +- src/librustc_metadata/creader.rs | 8 +- src/librustc_metadata/cstore.rs | 11 +-- src/librustc_metadata/cstore_impl.rs | 4 +- src/librustc_metadata/decoder.rs | 19 ++-- src/librustc_metadata/encoder.rs | 40 +++++--- src/librustc_metadata/index_builder.rs | 2 +- 14 files changed, 159 insertions(+), 119 deletions(-) diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 1a0f89a1e5361..1571cf344ede1 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -53,9 +53,6 @@ pub enum DepNode { /// in an extern crate. MetaData(D), - /// Represents some piece of metadata global to its crate. - GlobalMetaData(D, GlobalMetaDataKind), - /// Represents some artifact that we save to disk. Note that these /// do not have a def-id as part of their identifier. WorkProduct(WorkProductId), @@ -309,7 +306,6 @@ impl DepNode { ItemBodyNestedBodies(ref d) => op(d).map(ItemBodyNestedBodies), ConstIsRvaluePromotableToStatic(ref d) => op(d).map(ConstIsRvaluePromotableToStatic), IsMirAvailable(ref d) => op(d).map(IsMirAvailable), - GlobalMetaData(ref d, kind) => op(d).map(|d| GlobalMetaData(d, kind)), } } } @@ -330,16 +326,3 @@ impl WorkProductId { WorkProductId(hasher.finish()) } } - -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] -pub enum GlobalMetaDataKind { - Krate, - CrateDeps, - DylibDependencyFormats, - LangItems, - LangItemsMissing, - NativeLibraries, - CodeMap, - Impls, - ExportedSymbols, -} diff --git a/src/librustc/dep_graph/mod.rs b/src/librustc/dep_graph/mod.rs index 822b61df7a489..809bed939f54c 100644 --- a/src/librustc/dep_graph/mod.rs +++ b/src/librustc/dep_graph/mod.rs @@ -22,7 +22,6 @@ mod thread; pub use self::dep_tracking_map::{DepTrackingMap, DepTrackingMapConfig}; pub use self::dep_node::DepNode; pub use self::dep_node::WorkProductId; -pub use self::dep_node::GlobalMetaDataKind; pub use self::graph::DepGraph; pub use self::graph::WorkProduct; pub use self::query::DepGraphQuery; diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index ced0f351c9eed..ae43035f3b2e6 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -15,7 +15,8 @@ //! expressions) that are mostly just leftovers. use hir; -use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace}; +use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, + CRATE_DEF_INDEX}; use ich::Fingerprint; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::IndexVec; @@ -396,6 +397,11 @@ pub enum DefPathData { ImplTrait, /// A `typeof` type node. Typeof, + + /// GlobalMetaData identifies a piece of crate metadata that is global to + /// a whole crate (as opposed to just one item). GlobalMetaData components + /// are only supposed to show up right below the crate root. + GlobalMetaData(Ident) } #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, @@ -427,8 +433,8 @@ impl Definitions { /// Get the number of definitions. pub fn def_index_counts_lo_hi(&self) -> (usize, usize) { - (self.def_index_to_node[DefIndexAddressSpace::Low.index()].len(), - self.def_index_to_node[DefIndexAddressSpace::High.index()].len()) + (self.table.index_to_key[DefIndexAddressSpace::Low.index()].len(), + self.table.index_to_key[DefIndexAddressSpace::High.index()].len()) } pub fn def_key(&self, index: DefIndex) -> DefKey { @@ -469,7 +475,12 @@ impl Definitions { if def_id.krate == LOCAL_CRATE { let space_index = def_id.index.address_space().index(); let array_index = def_id.index.as_array_index(); - Some(self.def_index_to_node[space_index][array_index]) + let node_id = self.def_index_to_node[space_index][array_index]; + if node_id != ast::DUMMY_NODE_ID { + Some(node_id) + } else { + None + } } else { None } @@ -498,12 +509,16 @@ impl Definitions { // Create the definition. let address_space = super::ITEM_LIKE_SPACE; - let index = self.table.allocate(key, def_path_hash, address_space); + let root_index = self.table.allocate(key, def_path_hash, address_space); + assert_eq!(root_index, CRATE_DEF_INDEX); assert!(self.def_index_to_node[address_space.index()].is_empty()); self.def_index_to_node[address_space.index()].push(ast::CRATE_NODE_ID); - self.node_to_def_index.insert(ast::CRATE_NODE_ID, index); + self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index); - index + // Allocate some other DefIndices that always must exist. + GlobalMetaDataKind::allocate_def_indices(self); + + root_index } /// Add a definition with a parent definition. @@ -550,13 +565,19 @@ impl Definitions { assert_eq!(index.as_array_index(), self.def_index_to_node[address_space.index()].len()); self.def_index_to_node[address_space.index()].push(node_id); + + // Some things for which we allocate DefIndices don't correspond to + // anything in the AST, so they don't have a NodeId. For these cases + // we don't need a mapping from NodeId to DefIndex. + if node_id != ast::DUMMY_NODE_ID { + debug!("create_def_with_parent: def_index_to_node[{:?} <-> {:?}", index, node_id); + self.node_to_def_index.insert(node_id, index); + } + if expansion.is_modern() { self.expansions.insert(index, expansion); } - debug!("create_def_with_parent: def_index_to_node[{:?} <-> {:?}", index, node_id); - self.node_to_def_index.insert(node_id, index); - index } @@ -594,7 +615,8 @@ impl DefPathData { LifetimeDef(ident) | EnumVariant(ident) | Binding(ident) | - Field(ident) => Some(ident), + Field(ident) | + GlobalMetaData(ident) => Some(ident), Impl | CrateRoot | @@ -622,7 +644,8 @@ impl DefPathData { LifetimeDef(ident) | EnumVariant(ident) | Binding(ident) | - Field(ident) => { + Field(ident) | + GlobalMetaData(ident) => { return ident.name.as_str(); } @@ -667,3 +690,74 @@ impl ::std::hash::Hash for DefPathData { } } } + + +// We define the GlobalMetaDataKind enum with this macro because we want to +// make sure that we exhaustively iterate over all variants when registering +// the corresponding DefIndices in the DefTable. +macro_rules! define_global_metadata_kind { + (pub enum GlobalMetaDataKind { + $($variant:ident),* + }) => ( + #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, + RustcEncodable, RustcDecodable)] + pub enum GlobalMetaDataKind { + $($variant),* + } + + impl GlobalMetaDataKind { + fn allocate_def_indices(definitions: &mut Definitions) { + $({ + let instance = GlobalMetaDataKind::$variant; + definitions.create_def_with_parent( + CRATE_DEF_INDEX, + ast::DUMMY_NODE_ID, + DefPathData::GlobalMetaData(instance.ident()), + DefIndexAddressSpace::High, + Mark::root() + ); + + // Make sure calling def_index does not crash. + instance.def_index(&definitions.table); + })* + } + + pub fn def_index(&self, def_path_table: &DefPathTable) -> DefIndex { + let def_key = DefKey { + parent: Some(CRATE_DEF_INDEX), + disambiguated_data: DisambiguatedDefPathData { + data: DefPathData::GlobalMetaData(self.ident()), + disambiguator: 0, + } + }; + + def_path_table.key_to_index[&def_key] + } + + fn ident(&self) -> Ident { + + let string = match *self { + $( + GlobalMetaDataKind::$variant => { + concat!("{{GlobalMetaData::", stringify!($variant), "}}") + } + )* + }; + + Ident::from_str(string) + } + } + ) +} + +define_global_metadata_kind!(pub enum GlobalMetaDataKind { + Krate, + CrateDeps, + DylibDependencyFormats, + LangItems, + LangItemsMissing, + NativeLibraries, + CodeMap, + Impls, + ExportedSymbols +}); diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index 71b066c6688b5..57b8c7f8c16b1 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -23,7 +23,6 @@ // probably get a better home if someone can find one. use hir::def; -use dep_graph::DepNode; use hir::def_id::{CrateNum, DefId, DefIndex}; use hir::map as hir_map; use hir::map::definitions::{Definitions, DefKey, DisambiguatedDefPathData, @@ -190,15 +189,14 @@ pub struct EncodedMetadataHash { /// upstream crate. #[derive(Debug, RustcEncodable, RustcDecodable, Clone)] pub struct EncodedMetadataHashes { - pub entry_hashes: Vec, - pub global_hashes: Vec<(DepNode<()>, ich::Fingerprint)>, + // Stable content hashes for things in crate metadata, indexed by DefIndex. + pub hashes: Vec, } impl EncodedMetadataHashes { pub fn new() -> EncodedMetadataHashes { EncodedMetadataHashes { - entry_hashes: Vec::new(), - global_hashes: Vec::new(), + hashes: Vec::new(), } } } diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index 78536b53ba879..503177e437bef 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -197,7 +197,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { data @ DefPathData::ClosureExpr | data @ DefPathData::Binding(..) | data @ DefPathData::ImplTrait | - data @ DefPathData::Typeof => { + data @ DefPathData::Typeof | + data @ DefPathData::GlobalMetaData(..) => { let parent_def_id = self.parent_def_id(def_id).unwrap(); self.push_item_path(buffer, parent_def_id); buffer.push(&data.as_interned_str()); diff --git a/src/librustc_incremental/persist/data.rs b/src/librustc_incremental/persist/data.rs index 4669bb866d41b..96b7de94daf65 100644 --- a/src/librustc_incremental/persist/data.rs +++ b/src/librustc_incremental/persist/data.rs @@ -126,10 +126,6 @@ pub struct SerializedMetadataHashes { /// (matching the one found in this structure). pub entry_hashes: Vec, - /// This map contains fingerprints that are not specific to some DefId but - /// describe something global to the whole crate. - pub global_hashes: Vec<(DepNode<()>, Fingerprint)>, - /// For each DefIndex (as it occurs in SerializedMetadataHash), this /// map stores the DefPathIndex (as it occurs in DefIdDirectory), so /// that we can find the new DefId for a SerializedMetadataHash in a diff --git a/src/librustc_incremental/persist/hash.rs b/src/librustc_incremental/persist/hash.rs index 6ab280be470dd..4a2dd274aae52 100644 --- a/src/librustc_incremental/persist/hash.rs +++ b/src/librustc_incremental/persist/hash.rs @@ -9,7 +9,7 @@ // except according to those terms. use rustc::dep_graph::DepNode; -use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, CRATE_DEF_INDEX}; +use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::hir::svh::Svh; use rustc::ich::Fingerprint; use rustc::ty::TyCtxt; @@ -29,9 +29,8 @@ use std::fmt::Debug; pub struct HashContext<'a, 'tcx: 'a> { pub tcx: TyCtxt<'a, 'tcx, 'tcx>, incremental_hashes_map: &'a IncrementalHashesMap, - item_metadata_hashes: FxHashMap, + metadata_hashes: FxHashMap, crate_hashes: FxHashMap, - global_metadata_hashes: FxHashMap, Fingerprint>, } impl<'a, 'tcx> HashContext<'a, 'tcx> { @@ -41,9 +40,8 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { HashContext { tcx: tcx, incremental_hashes_map: incremental_hashes_map, - item_metadata_hashes: FxHashMap(), + metadata_hashes: FxHashMap(), crate_hashes: FxHashMap(), - global_metadata_hashes: FxHashMap(), } } @@ -53,8 +51,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { DepNode::Hir(_) | DepNode::HirBody(_) => true, - DepNode::MetaData(def_id) | - DepNode::GlobalMetaData(def_id, _) => !def_id.is_local(), + DepNode::MetaData(def_id) => !def_id.is_local(), _ => false, } } @@ -83,13 +80,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { DepNode::MetaData(def_id) if !def_id.is_local() => { Some(self.metadata_hash(def_id, def_id.krate, - |this| &mut this.item_metadata_hashes)) - } - - DepNode::GlobalMetaData(def_id, kind) => { - Some(self.metadata_hash(DepNode::GlobalMetaData(def_id, kind), - def_id.krate, - |this| &mut this.global_metadata_hashes)) + |this| &mut this.metadata_hashes)) } _ => { @@ -217,27 +208,11 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { let def_id = DefId { krate: cnum, index: serialized_hash.def_index }; // record the hash for this dep-node - let old = self.item_metadata_hashes.insert(def_id, serialized_hash.hash); + let old = self.metadata_hashes.insert(def_id, serialized_hash.hash); debug!("load_from_data: def_id={:?} hash={}", def_id, serialized_hash.hash); assert!(old.is_none(), "already have hash for {:?}", def_id); } - for (dep_node, fingerprint) in serialized_hashes.global_hashes { - // Here we need to remap the CrateNum in the DepNode. - let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX }; - let dep_node = match dep_node { - DepNode::GlobalMetaData(_, kind) => DepNode::GlobalMetaData(def_id, kind), - other => { - bug!("unexpected DepNode variant: {:?}", other) - } - }; - - // record the hash for this dep-node - debug!("load_from_data: def_node={:?} hash={}", dep_node, fingerprint); - let old = self.global_metadata_hashes.insert(dep_node.clone(), fingerprint); - assert!(old.is_none(), "already have hash for {:?}", dep_node); - } - Ok(()) } } diff --git a/src/librustc_incremental/persist/save.rs b/src/librustc_incremental/persist/save.rs index 6d717d6f409d5..01db756f9de04 100644 --- a/src/librustc_incremental/persist/save.rs +++ b/src/librustc_incremental/persist/save.rs @@ -255,9 +255,11 @@ pub fn encode_metadata_hashes(tcx: TyCtxt, current_metadata_hashes: &mut FxHashMap, encoder: &mut Encoder) -> io::Result<()> { + assert_eq!(metadata_hashes.hashes.len(), + metadata_hashes.hashes.iter().map(|x| (x.def_index, ())).collect::>().len()); + let mut serialized_hashes = SerializedMetadataHashes { - entry_hashes: metadata_hashes.entry_hashes.to_vec(), - global_hashes: metadata_hashes.global_hashes.to_vec(), + entry_hashes: metadata_hashes.hashes.to_vec(), index_map: FxHashMap() }; diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 51f152991fdaf..c1b57a543a40d 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -14,8 +14,7 @@ use cstore::{self, CStore, CrateSource, MetadataBlob}; use locator::{self, CratePaths}; use schema::{CrateRoot, Tracked}; -use rustc::dep_graph::{DepNode, GlobalMetaDataKind}; -use rustc::hir::def_id::{DefId, CrateNum, DefIndex, CRATE_DEF_INDEX}; +use rustc::hir::def_id::{CrateNum, DefIndex}; use rustc::hir::svh::Svh; use rustc::middle::cstore::DepKind; use rustc::session::Session; @@ -516,14 +515,11 @@ impl<'a> CrateLoader<'a> { return cstore::CrateNumMap::new(); } - let dep_node = DepNode::GlobalMetaData(DefId { krate, index: CRATE_DEF_INDEX }, - GlobalMetaDataKind::CrateDeps); - // The map from crate numbers in the crate we're resolving to local crate numbers. // We map 0 and all other holes in the map to our parent crate. The "additional" // self-dependencies should be harmless. ::std::iter::once(krate).chain(crate_root.crate_deps - .get(&self.sess.dep_graph, dep_node) + .get_untracked() .decode(metadata) .map(|dep| { debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash); diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs index 5066b927c1152..ed67616e58f64 100644 --- a/src/librustc_metadata/cstore.rs +++ b/src/librustc_metadata/cstore.rs @@ -13,9 +13,9 @@ use schema::{self, Tracked}; -use rustc::dep_graph::{DepGraph, DepNode, GlobalMetaDataKind}; +use rustc::dep_graph::DepGraph; use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, CrateNum, DefIndex, DefId}; -use rustc::hir::map::definitions::DefPathTable; +use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind}; use rustc::hir::svh::Svh; use rustc::middle::cstore::{DepKind, ExternCrate, MetadataLoader}; use rustc_back::PanicStrategy; @@ -304,12 +304,7 @@ impl CrateMetadata { } pub fn panic_strategy(&self, dep_graph: &DepGraph) -> PanicStrategy { - let def_id = DefId { - krate: self.cnum, - index: CRATE_DEF_INDEX, - }; - let dep_node = DepNode::GlobalMetaData(def_id, GlobalMetaDataKind::Krate); - + let dep_node = self.metadata_dep_node(GlobalMetaDataKind::Krate); self.root .panic_strategy .get(dep_graph, dep_node) diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index dcc55846b53d8..60cc03f7b7929 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -23,9 +23,9 @@ use rustc::ty::{self, TyCtxt}; use rustc::ty::maps::Providers; use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}; -use rustc::dep_graph::{DepNode, GlobalMetaDataKind}; +use rustc::dep_graph::{DepNode}; use rustc::hir::map::{DefKey, DefPath, DisambiguatedDefPathData, DefPathHash}; -use rustc::hir::map::definitions::DefPathTable; +use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind}; use rustc::util::nodemap::{NodeSet, DefIdMap}; use rustc_back::PanicStrategy; diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 91470f238ecb1..a095fdd508417 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -13,8 +13,9 @@ use cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary}; use schema::*; -use rustc::dep_graph::{DepGraph, DepNode, GlobalMetaDataKind}; +use rustc::dep_graph::{DepGraph, DepNode}; use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash}; +use rustc::hir::map::definitions::GlobalMetaDataKind; use rustc::hir; use rustc::middle::cstore::LinkagePreference; @@ -993,12 +994,8 @@ impl<'a, 'tcx> CrateMetadata { pub fn get_dylib_dependency_formats(&self, dep_graph: &DepGraph) -> Vec<(CrateNum, LinkagePreference)> { - let def_id = DefId { - krate: self.cnum, - index: CRATE_DEF_INDEX, - }; - let dep_node = DepNode::GlobalMetaData(def_id, - GlobalMetaDataKind::DylibDependencyFormats); + let dep_node = + self.metadata_dep_node(GlobalMetaDataKind::DylibDependencyFormats); self.root .dylib_dependency_formats .get(dep_graph, dep_node) @@ -1198,11 +1195,7 @@ impl<'a, 'tcx> CrateMetadata { } pub fn metadata_dep_node(&self, kind: GlobalMetaDataKind) -> DepNode { - let def_id = DefId { - krate: self.cnum, - index: CRATE_DEF_INDEX, - }; - - DepNode::GlobalMetaData(def_id, kind) + let def_index = kind.def_index(&self.def_path_table); + DepNode::MetaData(self.local_def_id(def_index)) } } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index a02a82dfe69a6..2a504c4c07794 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -14,10 +14,10 @@ use isolated_encoder::IsolatedEncoder; use schema::*; use rustc::middle::cstore::{LinkMeta, LinkagePreference, NativeLibrary, - EncodedMetadata, EncodedMetadataHashes}; + EncodedMetadata, EncodedMetadataHashes, + EncodedMetadataHash}; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefIndex, DefId, LOCAL_CRATE}; -use rustc::hir::map::definitions::DefPathTable; -use rustc::dep_graph::{DepNode, GlobalMetaDataKind}; +use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind}; use rustc::ich::Fingerprint; use rustc::middle::dependency_format::Linkage; use rustc::middle::lang_items; @@ -244,7 +244,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encodes something that corresponds to a single DepNode::GlobalMetaData // and registers the Fingerprint in the `metadata_hashes` map. pub fn tracked<'x, DATA, R>(&'x mut self, - dep_node: DepNode<()>, + def_index: DefIndex, op: fn(&mut IsolatedEncoder<'x, 'a, 'tcx>, DATA) -> R, data: DATA) -> Tracked { @@ -253,7 +253,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { let (fingerprint, this) = entry_builder.finish(); if let Some(fingerprint) = fingerprint { - this.metadata_hashes.global_hashes.push((dep_node, fingerprint)); + this.metadata_hashes.hashes.push(EncodedMetadataHash { + def_index, + hash: fingerprint, + }) } Tracked::new(ret) @@ -322,12 +325,17 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { fn encode_crate_root(&mut self) -> Lazy { let mut i = self.position(); + let tcx = self.tcx; + let global_metadata_def_index = move |kind: GlobalMetaDataKind| { + kind.def_index(tcx.hir.definitions().def_path_table()) + }; + let crate_deps = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::CrateDeps), + global_metadata_def_index(GlobalMetaDataKind::CrateDeps), IsolatedEncoder::encode_crate_deps, ()); let dylib_dependency_formats = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::DylibDependencyFormats), + global_metadata_def_index(GlobalMetaDataKind::DylibDependencyFormats), IsolatedEncoder::encode_dylib_dependency_formats, ()); let dep_bytes = self.position() - i; @@ -335,12 +343,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the language items. i = self.position(); let lang_items = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::LangItems), + global_metadata_def_index(GlobalMetaDataKind::LangItems), IsolatedEncoder::encode_lang_items, ()); let lang_items_missing = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::LangItemsMissing), + global_metadata_def_index(GlobalMetaDataKind::LangItemsMissing), IsolatedEncoder::encode_lang_items_missing, ()); let lang_item_bytes = self.position() - i; @@ -348,7 +356,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the native libraries used i = self.position(); let native_libraries = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::NativeLibraries), + global_metadata_def_index(GlobalMetaDataKind::NativeLibraries), IsolatedEncoder::encode_native_libraries, ()); let native_lib_bytes = self.position() - i; @@ -366,7 +374,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the def IDs of impls, for coherence checking. i = self.position(); let impls = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::Impls), + global_metadata_def_index(GlobalMetaDataKind::Impls), IsolatedEncoder::encode_impls, ()); let impl_bytes = self.position() - i; @@ -374,7 +382,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode exported symbols info. i = self.position(); let exported_symbols = self.tracked( - DepNode::GlobalMetaData((), GlobalMetaDataKind::ExportedSymbols), + global_metadata_def_index(GlobalMetaDataKind::ExportedSymbols), IsolatedEncoder::encode_exported_symbols, self.exported_symbols); let exported_symbols_bytes = self.position() - i; @@ -422,10 +430,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { let total_bytes = self.position(); - self.metadata_hashes.global_hashes.push(( - DepNode::GlobalMetaData((), GlobalMetaDataKind::Krate), - Fingerprint::from_smaller_hash(link_meta.crate_hash.as_u64()) - )); + self.metadata_hashes.hashes.push(EncodedMetadataHash { + def_index: global_metadata_def_index(GlobalMetaDataKind::Krate), + hash: Fingerprint::from_smaller_hash(link_meta.crate_hash.as_u64()) + }); if self.tcx.sess.meta_stats() { let mut zero_bytes = 0; diff --git a/src/librustc_metadata/index_builder.rs b/src/librustc_metadata/index_builder.rs index 478202aeba444..2db9c6a4ff811 100644 --- a/src/librustc_metadata/index_builder.rs +++ b/src/librustc_metadata/index_builder.rs @@ -135,7 +135,7 @@ impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> { let (fingerprint, ecx) = entry_builder.finish(); if let Some(hash) = fingerprint { - ecx.metadata_hashes.entry_hashes.push(EncodedMetadataHash { + ecx.metadata_hashes.hashes.push(EncodedMetadataHash { def_index: id.index, hash: hash, });