user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove the Forest type

Browse source
This commit is contained in:
John Kåre Alsaker 2020-02-06 13:41:37 +01:00
parent 20ce2f6038
commit 623dcb02db
8 changed files with 50 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/arena.rs
View file

@ -127,7 +127,7 @@ macro_rules! arena_types {
[] tys: rustc::ty::TyS<$tcx>,
// HIR types
[few] hir_forest: rustc::hir::map::Forest<$tcx>,
[few] hir_krate: rustc_hir::Crate<$tcx>,
[] arm: rustc_hir::Arm<$tcx>,
[] attribute: syntax::ast::Attribute,
[] block: rustc_hir::Block<$tcx>,

2
src/librustc/hir/map/hir_id_validator.rs
View file

@ -12,7 +12,7 @@ pub fn check_crate(hir_map: &Map<'_>) {
let errors = Lock::new(Vec::new());
par_iter(&hir_map.forest.krate.modules).for_each(|(module_id, _)| {
par_iter(&hir_map.krate.modules).for_each(|(module_id, _)| {
let local_def_id = hir_map.local_def_id(*module_id);
hir_map.visit_item_likes_in_module(
local_def_id,

87
src/librustc/hir/map/mod.rs
View file

@ -129,25 +129,6 @@ impl<'hir> Entry<'hir> {
}
}
/// Stores a crate and any number of inlined items from other crates.
pub struct Forest<'hir> {
krate: Crate<'hir>,
pub dep_graph: DepGraph,
}
impl Forest<'hir> {
pub fn new(krate: Crate<'hir>, dep_graph: &DepGraph) -> Forest<'hir> {
Forest { krate, dep_graph: dep_graph.clone() }
}
/// This is used internally in the dependency tracking system.
/// Use the `krate` method to ensure your dependency on the
/// crate is tracked.
pub fn untracked_krate(&self) -> &Crate<'hir> {
&self.krate
}
}
/// This type is effectively a `HashMap<HirId, Entry<'hir>>`,
/// but it is implemented as 2 layers of arrays.
/// - first we have `A = IndexVec<DefIndex, B>` mapping `DefIndex`s to an inner value
@ -157,11 +138,8 @@ pub(super) type HirEntryMap<'hir> = IndexVec<DefIndex, IndexVec<ItemLocalId, Opt
/// Represents a mapping from `NodeId`s to AST elements and their parent `NodeId`s.
#[derive(Clone)]
pub struct Map<'hir> {
/// The backing storage for all the AST nodes.
pub forest: &'hir Forest<'hir>,
pub krate: &'hir Crate<'hir>,
/// Same as the dep_graph in forest, just available with one fewer
/// deref. This is a gratuitous micro-optimization.
pub dep_graph: DepGraph,
/// The SVH of the local crate.
@ -212,6 +190,13 @@ impl<'hir> Iterator for ParentHirIterator<'_, 'hir> {
}
impl<'hir> Map<'hir> {
/// This is used internally in the dependency tracking system.
/// Use the `krate` method to ensure your dependency on the
/// crate is tracked.
pub fn untracked_krate(&self) -> &Crate<'hir> {
&self.krate
}
#[inline]
fn lookup(&self, id: HirId) -> Option<&Entry<'hir>> {
let local_map = self.map.get(id.owner)?;
@ -399,33 +384,33 @@ impl<'hir> Map<'hir> {
pub fn item(&self, id: HirId) -> &'hir Item<'hir> {
self.read(id);
// N.B., intentionally bypass `self.forest.krate()` so that we
// N.B., intentionally bypass `self.krate()` so that we
// do not trigger a read of the whole krate here
self.forest.krate.item(id)
self.krate.item(id)
}
pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> {
self.read(id.hir_id);
// N.B., intentionally bypass `self.forest.krate()` so that we
// N.B., intentionally bypass `self.krate()` so that we
// do not trigger a read of the whole krate here
self.forest.krate.trait_item(id)
self.krate.trait_item(id)
}
pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir> {
self.read(id.hir_id);
// N.B., intentionally bypass `self.forest.krate()` so that we
// N.B., intentionally bypass `self.krate()` so that we
// do not trigger a read of the whole krate here
self.forest.krate.impl_item(id)
self.krate.impl_item(id)
}
pub fn body(&self, id: BodyId) -> &'hir Body<'hir> {
self.read(id.hir_id);
// N.B., intentionally bypass `self.forest.krate()` so that we
// N.B., intentionally bypass `self.krate()` so that we
// do not trigger a read of the whole krate here
self.forest.krate.body(id)
self.krate.body(id)
}
pub fn fn_decl_by_hir_id(&self, hir_id: HirId) -> Option<&'hir FnDecl<'hir>> {
@ -521,9 +506,9 @@ impl<'hir> Map<'hir> {
pub fn trait_impls(&self, trait_did: DefId) -> &'hir [HirId] {
self.dep_graph.read(DepNode::new_no_params(DepKind::AllLocalTraitImpls));
// N.B., intentionally bypass `self.forest.krate()` so that we
// N.B., intentionally bypass `self.krate()` so that we
// do not trigger a read of the whole krate here
self.forest.krate.trait_impls.get(&trait_did).map_or(&[], |xs| &xs[..])
self.krate.trait_impls.get(&trait_did).map_or(&[], |xs| &xs[..])
}
/// Gets the attributes on the crate. This is preferable to
@ -533,7 +518,7 @@ impl<'hir> Map<'hir> {
let def_path_hash = self.definitions.def_path_hash(CRATE_DEF_INDEX);
self.dep_graph.read(def_path_hash.to_dep_node(DepKind::Hir));
&self.forest.krate.attrs
&self.krate.attrs
}
pub fn get_module(&self, module: DefId) -> (&'hir Mod<'hir>, Span, HirId) {
@ -541,7 +526,7 @@ impl<'hir> Map<'hir> {
self.read(hir_id);
match self.find_entry(hir_id).unwrap().node {
Node::Item(&Item { span, kind: ItemKind::Mod(ref m), .. }) => (m, span, hir_id),
Node::Crate => (&self.forest.krate.module, self.forest.krate.span, hir_id),
Node::Crate => (&self.krate.module, self.krate.span, hir_id),
node => panic!("not a module: {:?}", node),
}
}
@ -558,7 +543,7 @@ impl<'hir> Map<'hir> {
// in the expect_* calls the loops below
self.read(hir_id);
let module = &self.forest.krate.modules[&hir_id];
let module = &self.krate.modules[&hir_id];
for id in &module.items {
visitor.visit_item(self.expect_item(*id));
@ -975,7 +960,7 @@ impl<'hir> Map<'hir> {
// Unit/tuple structs/variants take the attributes straight from
// the struct/variant definition.
Some(Node::Ctor(..)) => return self.attrs(self.get_parent_item(id)),
Some(Node::Crate) => Some(&self.forest.krate.attrs[..]),
Some(Node::Crate) => Some(&self.krate.attrs[..]),
_ => None,
};
attrs.unwrap_or(&[])
@ -1054,7 +1039,7 @@ impl<'hir> Map<'hir> {
Some(Node::Visibility(v)) => bug!("unexpected Visibility {:?}", v),
Some(Node::Local(local)) => local.span,
Some(Node::MacroDef(macro_def)) => macro_def.span,
Some(Node::Crate) => self.forest.krate.span,
Some(Node::Crate) => self.krate.span,
None => bug!("hir::map::Map::span: id not in map: {:?}", hir_id),
}
}
@ -1222,7 +1207,8 @@ impl Named for ImplItem<'_> {
pub fn map_crate<'hir>(
sess: &rustc_session::Session,
cstore: &CrateStoreDyn,
forest: &'hir Forest<'hir>,
krate: &'hir Crate<'hir>,
dep_graph: DepGraph,
definitions: Definitions,
) -> Map<'hir> {
let _prof_timer = sess.prof.generic_activity("build_hir_map");
@ -1235,31 +1221,18 @@ pub fn map_crate<'hir>(
.collect();
let (map, crate_hash) = {
let hcx = crate::ich::StableHashingContext::new(sess, &forest.krate, &definitions, cstore);
let hcx = crate::ich::StableHashingContext::new(sess, krate, &definitions, cstore);
let mut collector = NodeCollector::root(
sess,
&forest.krate,
&forest.dep_graph,
&definitions,
&hir_to_node_id,
hcx,
);
intravisit::walk_crate(&mut collector, &forest.krate);
let mut collector =
NodeCollector::root(sess, krate, &dep_graph, &definitions, &hir_to_node_id, hcx);
intravisit::walk_crate(&mut collector, krate);
let crate_disambiguator = sess.local_crate_disambiguator();
let cmdline_args = sess.opts.dep_tracking_hash();
collector.finalize_and_compute_crate_hash(crate_disambiguator, cstore, cmdline_args)
};
let map = Map {
forest,
dep_graph: forest.dep_graph.clone(),
crate_hash,
map,
hir_to_node_id,
definitions,
};
let map = Map { krate, dep_graph, crate_hash, map, hir_to_node_id, definitions };
sess.time("validate_HIR_map", || {
hir_id_validator::check_crate(&map);

2
src/librustc/hir/mod.rs
View file

@ -49,6 +49,6 @@ impl<'tcx> TyCtxt<'tcx> {
}
pub fn provide(providers: &mut Providers<'_>) {
providers.hir_crate = |tcx, _| tcx.hir_map.forest.untracked_krate();
providers.hir_crate = |tcx, _| tcx.hir_map.untracked_krate();
map::provide(providers);
}

2
src/librustc/ty/context.rs
View file

@ -1323,7 +1323,7 @@ impl<'tcx> TyCtxt<'tcx> {
#[inline(always)]
pub fn create_stable_hashing_context(self) -> StableHashingContext<'tcx> {
let krate = self.gcx.hir_map.forest.untracked_krate();
let krate = self.gcx.hir_map.untracked_krate();
StableHashingContext::new(self.sess, krate, self.hir().definitions(), &*self.cstore)
}

12
src/librustc_interface/passes.rs
View file

@ -25,6 +25,7 @@ use rustc_data_structures::{box_region_allow_access, declare_box_region_type, pa
use rustc_errors::PResult;
use rustc_expand::base::ExtCtxt;
use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
use rustc_hir::Crate;
use rustc_lint::LintStore;
use rustc_mir as mir;
use rustc_mir_build as mir_build;
@ -422,7 +423,7 @@ pub fn lower_to_hir<'res, 'tcx>(
dep_graph: &'res DepGraph,
krate: &'res ast::Crate,
arena: &'tcx Arena<'tcx>,
) -> Result<map::Forest<'tcx>> {
) -> Crate<'tcx> {
// Lower AST to HIR.
let hir_crate = rustc_ast_lowering::lower_crate(
sess,
@ -437,8 +438,6 @@ pub fn lower_to_hir<'res, 'tcx>(
hir_stats::print_hir_stats(&hir_crate);
}
let hir_forest = map::Forest::new(hir_crate, &dep_graph);
sess.time("early_lint_checks", || {
rustc_lint::check_ast_crate(
sess,
@ -455,7 +454,7 @@ pub fn lower_to_hir<'res, 'tcx>(
rustc_span::hygiene::clear_syntax_context_map();
}
Ok(hir_forest)
hir_crate
}
// Returns all the paths that correspond to generated files.
@ -705,7 +704,8 @@ impl<'tcx> QueryContext<'tcx> {
pub fn create_global_ctxt<'tcx>(
compiler: &'tcx Compiler,
lint_store: Lrc<LintStore>,
hir_forest: &'tcx map::Forest<'tcx>,
krate: &'tcx Crate<'tcx>,
dep_graph: DepGraph,
mut resolver_outputs: ResolverOutputs,
outputs: OutputFilenames,
crate_name: &str,
@ -716,7 +716,7 @@ pub fn create_global_ctxt<'tcx>(
let defs = mem::take(&mut resolver_outputs.definitions);
// Construct the HIR map.
let hir_map = map::map_crate(sess, &*resolver_outputs.cstore, &hir_forest, defs);
let hir_map = map::map_crate(sess, &*resolver_outputs.cstore, krate, dep_graph, defs);
let query_result_on_disk_cache = rustc_incremental::load_query_result_cache(sess);

18
src/librustc_interface/queries.rs
View file

@ -3,7 +3,6 @@ use crate::passes::{self, BoxedResolver, QueryContext};
use rustc::arena::Arena;
use rustc::dep_graph::DepGraph;
use rustc::hir::map;
use rustc::session::config::{OutputFilenames, OutputType};
use rustc::session::Session;
use rustc::ty::steal::Steal;
@ -12,6 +11,7 @@ use rustc::util::common::ErrorReported;
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use rustc_data_structures::sync::{Lrc, Once, WorkerLocal};
use rustc_hir::def_id::LOCAL_CRATE;
use rustc_hir::Crate;
use rustc_incremental::DepGraphFuture;
use rustc_lint::LintStore;
use std::any::Any;
@ -74,7 +74,7 @@ pub struct Queries<'tcx> {
register_plugins: Query<(ast::Crate, Lrc<LintStore>)>,
expansion: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>,
dep_graph: Query<DepGraph>,
lower_to_hir: Query<(&'tcx map::Forest<'tcx>, Steal<ResolverOutputs>)>,
lower_to_hir: Query<(&'tcx Crate<'tcx>, Steal<ResolverOutputs>)>,
prepare_outputs: Query<OutputFilenames>,
global_ctxt: Query<QueryContext<'tcx>>,
ongoing_codegen: Query<Box<dyn Any>>,
@ -207,9 +207,7 @@ impl<'tcx> Queries<'tcx> {
})
}
pub fn lower_to_hir(
&'tcx self,
) -> Result<&Query<(&'tcx map::Forest<'tcx>, Steal<ResolverOutputs>)>> {
pub fn lower_to_hir(&'tcx self) -> Result<&Query<(&'tcx Crate<'tcx>, Steal<ResolverOutputs>)>> {
self.lower_to_hir.compute(|| {
let expansion_result = self.expansion()?;
let peeked = expansion_result.peek();
@ -217,14 +215,14 @@ impl<'tcx> Queries<'tcx> {
let resolver = peeked.1.steal();
let lint_store = &peeked.2;
let hir = resolver.borrow_mut().access(|resolver| {
passes::lower_to_hir(
Ok(passes::lower_to_hir(
self.session(),
lint_store,
resolver,
&*self.dep_graph()?.peek(),
&krate,
&self.arena,
)
))
})?;
let hir = self.arena.alloc(hir);
Ok((hir, Steal::new(BoxedResolver::to_resolver_outputs(resolver))))
@ -253,12 +251,14 @@ impl<'tcx> Queries<'tcx> {
let outputs = self.prepare_outputs()?.peek().clone();
let lint_store = self.expansion()?.peek().2.clone();
let hir = self.lower_to_hir()?.peek();
let (ref hir_forest, ref resolver_outputs) = &*hir;
let dep_graph = self.dep_graph()?.peek().clone();
let (ref krate, ref resolver_outputs) = &*hir;
let _timer = self.session().timer("create_global_ctxt");
Ok(passes::create_global_ctxt(
self.compiler,
lint_store,
hir_forest,
krate,
dep_graph,
resolver_outputs.steal(),
outputs,
&crate_name,

2
src/librustdoc/test.rs
View file

@ -87,7 +87,7 @@ pub fn run(options: Options) -> i32 {
compiler.enter(|queries| {
let lower_to_hir = queries.lower_to_hir()?;
let mut opts = scrape_test_config(lower_to_hir.peek().0.untracked_krate());
let mut opts = scrape_test_config(lower_to_hir.peek().0);
opts.display_warnings |= options.display_warnings;
let enable_per_target_ignores = options.enable_per_target_ignores;
let mut collector = Collector::new(