}
}
-/// 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
/// 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.
}
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)?;
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>> {
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
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) {
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),
}
}
// 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));
// 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(&[])
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),
}
}
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");
.collect();
let (map, crate_hash) = {
- let hcx = crate::ich::StableHashingContext::new(sess, &forest.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 hcx = crate::ich::StableHashingContext::new(sess, krate, &definitions, cstore);
+
+ 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);
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;
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,
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,
rustc_span::hygiene::clear_syntax_context_map();
}
- Ok(hir_forest)
+ hir_crate
}
// Returns all the paths that correspond to generated files.
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,
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);
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;
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;
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>>,
})
}
- 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();
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))))
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,
projects / rust.git / commitdiff