From 9f6d7e7dad3b59fb8939a077c577019852aad33f Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Thu, 20 May 2021 20:17:45 +0200 Subject: [PATCH] Correct comments about untracked accesses. --- compiler/rustc_metadata/src/rmeta/encoder.rs | 6 ++--- compiler/rustc_middle/src/hir/map/mod.rs | 26 +++++++++++--------- compiler/rustc_middle/src/ty/context.rs | 10 ++++---- compiler/rustc_query_impl/src/stats.rs | 2 +- 4 files changed, 23 insertions(+), 21 deletions(-) diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 2478d15e554..0e924d64435 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -445,7 +445,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { } fn encode_def_path_table(&mut self) { - let table = self.tcx.hir().definitions().def_path_table(); + let table = self.tcx.resolutions(()).definitions.def_path_table(); if self.is_proc_macro { for def_index in std::iter::once(CRATE_DEF_INDEX) .chain(self.tcx.hir().krate().proc_macros.iter().map(|p| p.owner.local_def_index)) @@ -1062,7 +1062,7 @@ impl EncodeContext<'a, 'tcx> { let data = ModData { reexports, - expansion: tcx.hir().definitions().expansion_that_defined(local_def_id), + expansion: tcx.resolutions(()).definitions.expansion_that_defined(local_def_id), }; record!(self.tables.kind[def_id] <- EntryKind::Mod(self.lazy(data))); @@ -1759,7 +1759,7 @@ impl EncodeContext<'a, 'tcx> { .map(|(trait_def_id, mut impls)| { // Bring everything into deterministic order for hashing impls.sort_by_cached_key(|&(index, _)| { - tcx.hir().definitions().def_path_hash(LocalDefId { local_def_index: index }) + tcx.hir().def_path_hash(LocalDefId { local_def_index: index }) }); TraitImpls { diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index c901f101d94..6f799ea940b 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -9,7 +9,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::svh::Svh; use rustc_hir::def::{DefKind, Res}; use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; -use rustc_hir::definitions::{DefKey, DefPath, Definitions}; +use rustc_hir::definitions::{DefKey, DefPath, DefPathHash}; use rustc_hir::intravisit; use rustc_hir::intravisit::Visitor; use rustc_hir::itemlikevisit::ItemLikeVisitor; @@ -154,14 +154,8 @@ impl<'hir> Map<'hir> { self.tcx.hir_crate(()) } - #[inline] - pub fn definitions(&self) -> &'hir Definitions { - // Accessing the definitions is ok, since all its contents are tracked by the query system. - &self.tcx.untracked_resolutions.definitions - } - pub fn def_key(&self, def_id: LocalDefId) -> DefKey { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Accessing the DefKey is ok, since it is part of DefPathHash. self.tcx.untracked_resolutions.definitions.def_key(def_id) } @@ -170,10 +164,16 @@ impl<'hir> Map<'hir> { } pub fn def_path(&self, def_id: LocalDefId) -> DefPath { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Accessing the DefPath is ok, since it is part of DefPathHash. self.tcx.untracked_resolutions.definitions.def_path(def_id) } + #[inline] + pub fn def_path_hash(self, def_id: LocalDefId) -> DefPathHash { + // Accessing the DefPathHash is ok, it is incr. comp. stable. + self.tcx.untracked_resolutions.definitions.def_path_hash(def_id) + } + #[inline] pub fn local_def_id(&self, hir_id: HirId) -> LocalDefId { self.opt_local_def_id(hir_id).unwrap_or_else(|| { @@ -187,18 +187,20 @@ impl<'hir> Map<'hir> { #[inline] pub fn opt_local_def_id(&self, hir_id: HirId) -> Option { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // FIXME(#85914) is this access safe for incr. comp.? self.tcx.untracked_resolutions.definitions.opt_hir_id_to_local_def_id(hir_id) } #[inline] pub fn local_def_id_to_hir_id(&self, def_id: LocalDefId) -> HirId { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // FIXME(#85914) is this access safe for incr. comp.? self.tcx.untracked_resolutions.definitions.local_def_id_to_hir_id(def_id) } pub fn iter_local_def_id(&self) -> impl Iterator + '_ { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Create a dependency to the crate to be sure we reexcute this when the amount of + // definitions change. + self.tcx.ensure().hir_crate(()); self.tcx.untracked_resolutions.definitions.iter_local_def_id() } diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 25fd02bc29c..1afeb4a138f 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -1240,9 +1240,9 @@ impl<'tcx> TyCtxt<'tcx> { } pub fn def_key(self, id: DefId) -> rustc_hir::definitions::DefKey { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Accessing the DefKey is ok, since it is part of DefPathHash. if let Some(id) = id.as_local() { - self.hir().def_key(id) + self.untracked_resolutions.definitions.def_key(id) } else { self.untracked_resolutions.cstore.def_key(id) } @@ -1254,9 +1254,9 @@ impl<'tcx> TyCtxt<'tcx> { /// Note that if `id` is not local to this crate, the result will /// be a non-local `DefPath`. pub fn def_path(self, id: DefId) -> rustc_hir::definitions::DefPath { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Accessing the DefPath is ok, since it is part of DefPathHash. if let Some(id) = id.as_local() { - self.hir().def_path(id) + self.untracked_resolutions.definitions.def_path(id) } else { self.untracked_resolutions.cstore.def_path(id) } @@ -1264,7 +1264,7 @@ impl<'tcx> TyCtxt<'tcx> { #[inline] pub fn def_path_hash(self, def_id: DefId) -> rustc_hir::definitions::DefPathHash { - // Accessing the definitions is ok, since all its contents are tracked by the query system. + // Accessing the DefPathHash is ok, it is incr. comp. stable. if let Some(def_id) = def_id.as_local() { self.untracked_resolutions.definitions.def_path_hash(def_id) } else { diff --git a/compiler/rustc_query_impl/src/stats.rs b/compiler/rustc_query_impl/src/stats.rs index e877034bd7b..fa48df3ed45 100644 --- a/compiler/rustc_query_impl/src/stats.rs +++ b/compiler/rustc_query_impl/src/stats.rs @@ -108,7 +108,7 @@ pub fn print_stats(tcx: TyCtxt<'_>) { queries.iter().filter(|q| q.local_def_id_keys.is_some()).collect(); def_id_density.sort_by_key(|q| q.local_def_id_keys.unwrap()); eprintln!("\nLocal DefId density:"); - let total = tcx.hir().definitions().def_index_count() as f64; + let total = tcx.resolutions(()).definitions.def_index_count() as f64; for q in def_id_density.iter().rev() { let local = q.local_def_id_keys.unwrap(); eprintln!(" {} - {} = ({}%)", q.name, local, (local as f64 * 100.0) / total);