use hir::def_id::{CrateNum, DefId};
use hir::map::DefPathHash;
+use hir::HirId;
use ich::Fingerprint;
use ty::{TyCtxt, Instance, InstanceDef};
[] ExternCrate(DefId),
[] LintLevels,
[] Specializes { impl1: DefId, impl2: DefId },
+ [] InScopeTraits(HirId),
+ [] ModuleExports(HirId),
);
trait DepNodeParams<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> : fmt::Debug {
// corresponding entry in the `trait_map` we need to hash that.
// Make sure we don't ignore too much by checking that there is
// no entry in a debug_assert!().
- debug_assert!(hcx.tcx.trait_map.get(self).is_none());
+ let hir_id = hcx.tcx.hir.node_to_hir_id(*self);
+ debug_assert!(hcx.tcx.in_scope_traits(hir_id).is_none());
}
NodeIdHashingMode::HashDefPath => {
hcx.tcx.hir.definitions().node_to_hir_id(*self).hash_stable(hcx, hasher);
}
NodeIdHashingMode::HashTraitsInScope => {
- if let Some(traits) = hcx.tcx.trait_map.get(self) {
+ let hir_id = hcx.tcx.hir.node_to_hir_id(*self);
+ if let Some(traits) = hcx.tcx.in_scope_traits(hir_id) {
// The ordering of the candidates is not fixed. So we hash
// the def-ids and then sort them and hash the collection.
let mut candidates: AccumulateVec<[_; 8]> =
use errors::DiagnosticBuilder;
use session::Session;
use middle;
-use hir::{TraitMap};
-use hir::def::{Def, ExportMap};
+use hir::{TraitCandidate, HirId};
+use hir::def::{Def, Export};
use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use hir::map as hir_map;
use hir::map::DefPathHash;
/// Map indicating what traits are in scope for places where this
/// is relevant; generated by resolve.
- pub trait_map: TraitMap,
+ trait_map: FxHashMap<HirId, Rc<Vec<TraitCandidate>>>,
/// Export map produced by name resolution.
- pub export_map: ExportMap,
+ export_map: FxHashMap<HirId, Rc<Vec<Export>>>,
pub named_region_map: resolve_lifetime::NamedRegionMap,
dep_graph: dep_graph.clone(),
types: common_types,
named_region_map,
- trait_map: resolutions.trait_map,
- export_map: resolutions.export_map,
+ trait_map: resolutions.trait_map.into_iter().map(|(k, v)| {
+ (hir.node_to_hir_id(k), Rc::new(v))
+ }).collect(),
+ export_map: resolutions.export_map.into_iter().map(|(k, v)| {
+ (hir.node_to_hir_id(k), Rc::new(v))
+ }).collect(),
hir,
def_path_hash_to_def_id,
maps: maps::Maps::new(providers),
Ok(f(&iter.collect::<Result<AccumulateVec<[_; 8]>, _>>()?))
}
}
+
+fn in_scope_traits<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: HirId)
+ -> Option<Rc<Vec<TraitCandidate>>>
+{
+ tcx.gcx.trait_map.get(&id).cloned()
+}
+
+fn module_exports<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: HirId)
+ -> Option<Rc<Vec<Export>>>
+{
+ tcx.gcx.export_map.get(&id).cloned()
+}
+
+pub fn provide(providers: &mut ty::maps::Providers) {
+ providers.in_scope_traits = in_scope_traits;
+ providers.module_exports = module_exports;
+}
use dep_graph::{DepConstructor, DepNode, DepNodeIndex};
use errors::{Diagnostic, DiagnosticBuilder};
use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
-use hir::def::Def;
-use hir;
+use hir::def::{Def, Export};
+use hir::{self, TraitCandidate, HirId};
use lint;
use middle::const_val;
use middle::cstore::{ExternCrate, LinkagePreference};
}
}
+impl Key for HirId {
+ fn map_crate(&self) -> CrateNum {
+ LOCAL_CRATE
+ }
+ fn default_span(&self, _tcx: TyCtxt) -> Span {
+ DUMMY_SP
+ }
+}
+
impl Key for DefId {
fn map_crate(&self) -> CrateNum {
self.krate
}
}
+impl<'tcx> QueryDescription for queries::in_scope_traits<'tcx> {
+ fn describe(_tcx: TyCtxt, _: HirId) -> String {
+ format!("fetching the traits in scope at a particular ast node")
+ }
+}
+
+impl<'tcx> QueryDescription for queries::module_exports<'tcx> {
+ fn describe(_tcx: TyCtxt, _: HirId) -> String {
+ format!("fetching the exported items for a module")
+ }
+}
+
// If enabled, send a message to the profile-queries thread
macro_rules! profq_msg {
($tcx:expr, $msg:expr) => {
[] lint_levels: lint_levels(CrateNum) -> Rc<lint::LintLevelMap>,
[] specializes: specializes_node((DefId, DefId)) -> bool,
+ [] in_scope_traits: InScopeTraits(HirId) -> Option<Rc<Vec<TraitCandidate>>>,
+ [] module_exports: ModuleExports(HirId) -> Option<Rc<Vec<Export>>>,
}
fn type_param_predicates<'tcx>((item_id, param_id): (DefId, DefId)) -> DepConstructor<'tcx> {
pub fn provide(providers: &mut ty::maps::Providers) {
util::provide(providers);
+ context::provide(providers);
*providers = ty::maps::Providers {
associated_item,
associated_item_def_ids,
&hir::Visibility)>)
-> Entry<'tcx> {
let tcx = self.tcx;
+ let hir_id = tcx.hir.node_to_hir_id(id);
let def_id = tcx.hir.local_def_id(id);
debug!("IsolatedEncoder::encode_info_for_mod({:?})", def_id);
let data = ModData {
- reexports: match tcx.export_map.get(&id) {
- Some(exports) if *vis == hir::Public => {
+ reexports: match tcx.module_exports(hir_id) {
+ Some(ref exports) if *vis == hir::Public => {
self.lazy_seq_from_slice(exports.as_slice())
}
_ => LazySeq::empty(),
// This code is here instead of in visit_item so that the
// crate module gets processed as well.
if self.prev_level.is_some() {
- if let Some(exports) = self.tcx.export_map.get(&id) {
- for export in exports {
+ let hir_id = self.tcx.hir.node_to_hir_id(id);
+ if let Some(exports) = self.tcx.module_exports(hir_id) {
+ for export in exports.iter() {
if let Some(node_id) = self.tcx.hir.as_local_node_id(export.def.def_id()) {
self.update(node_id, Some(AccessLevel::Exported));
}
fn assemble_extension_candidates_for_traits_in_scope(&mut self,
expr_id: ast::NodeId)
-> Result<(), MethodError<'tcx>> {
+ if expr_id == ast::DUMMY_NODE_ID {
+ return Ok(())
+ }
let mut duplicates = FxHashSet();
- let opt_applicable_traits = self.tcx.trait_map.get(&expr_id);
+ let expr_hir_id = self.tcx.hir.node_to_hir_id(expr_id);
+ let opt_applicable_traits = self.tcx.in_scope_traits(expr_hir_id);
if let Some(applicable_traits) = opt_applicable_traits {
- for trait_candidate in applicable_traits {
+ for trait_candidate in applicable_traits.iter() {
let trait_did = trait_candidate.def_id;
if duplicates.insert(trait_did) {
let import_id = trait_candidate.import_id;
self.visit_item(item, None, &mut om);
}
self.inside_public_path = orig_inside_public_path;
- if let Some(exports) = self.cx.tcx.export_map.get(&id) {
- for export in exports {
+ let hir_id = self.cx.tcx.hir.node_to_hir_id(id);
+ if let Some(exports) = self.cx.tcx.module_exports(hir_id) {
+ for export in exports.iter() {
if let Def::Macro(def_id, ..) = export.def {
if def_id.krate == LOCAL_CRATE || self.reexported_macros.contains(&def_id) {
continue // These are `krate.exported_macros`, handled in `self.visit()`.