// method of a private type is used, but the type itself is never
// called directly.
if let Some(impl_list) =
- self.tcx.inherent_impls.borrow().get(&self.tcx.hir.local_def_id(id)) {
+ self.tcx.maps.inherent_impls.borrow().get(&self.tcx.hir.local_def_id(id)) {
for &impl_did in impl_list.iter() {
for &item_did in &self.tcx.associated_item_def_ids(impl_did)[..] {
if let Some(item_node_id) = self.tcx.hir.as_local_node_id(item_did) {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
hooks: &mut [Box<for<'s> MirPassHook<'s>>])
{
- let def_ids = tcx.mir_map.borrow().keys();
+ let def_ids = tcx.maps.mir.borrow().keys();
for def_id in def_ids {
if !def_id.is_local() {
continue;
}
let _task = tcx.dep_graph.in_task(DepNode::Mir(def_id));
- let mir = &mut tcx.mir_map.borrow()[&def_id].borrow_mut();
+ let mir = &mut tcx.maps.mir.borrow()[&def_id].borrow_mut();
tcx.dep_graph.write(DepNode::Mir(def_id));
let id = tcx.hir.as_local_node_id(def_id).unwrap();
-> Option<Vec<PredicateObligation<'tcx>>> {
if let ty::TyAnon(def_id, substs) = self.predicate.skip_binder().self_ty().sty {
let ty = if def_id.is_local() {
- tcx.item_types.borrow().get(&def_id).cloned()
+ tcx.maps.types.borrow().get(&def_id).cloned()
} else {
Some(tcx.item_type(def_id))
};
//! type context book-keeping
-use dep_graph::{DepGraph, DepTrackingMap};
+use dep_graph::DepGraph;
use session::Session;
use lint;
use middle;
// borrowck. (They are not used during trans, and hence are not
// serialized or needed for cross-crate fns.)
free_region_maps: RefCell<NodeMap<FreeRegionMap>>,
- // FIXME: jroesch make this a refcell
-
- pub tables: RefCell<DepTrackingMap<maps::TypeckTables<'tcx>>>,
-
- /// Maps from a trait item to the trait item "descriptor"
- pub associated_items: RefCell<DepTrackingMap<maps::AssociatedItems<'tcx>>>,
-
- /// Maps from an impl/trait def-id to a list of the def-ids of its items
- pub associated_item_def_ids: RefCell<DepTrackingMap<maps::AssociatedItemDefIds<'tcx>>>,
-
- pub impl_trait_refs: RefCell<DepTrackingMap<maps::ImplTraitRefs<'tcx>>>,
- pub trait_defs: RefCell<DepTrackingMap<maps::TraitDefs<'tcx>>>,
- pub adt_defs: RefCell<DepTrackingMap<maps::AdtDefs<'tcx>>>,
- pub adt_sized_constraint: RefCell<DepTrackingMap<maps::AdtSizedConstraint<'tcx>>>,
-
- /// Maps from the def-id of an item (trait/struct/enum/fn) to its
- /// associated generics and predicates.
- pub generics: RefCell<DepTrackingMap<maps::Generics<'tcx>>>,
- pub predicates: RefCell<DepTrackingMap<maps::Predicates<'tcx>>>,
-
- /// Maps from the def-id of a trait to the list of
- /// super-predicates. This is a subset of the full list of
- /// predicates. We store these in a separate map because we must
- /// evaluate them even during type conversion, often before the
- /// full predicates are available (note that supertraits have
- /// additional acyclicity requirements).
- pub super_predicates: RefCell<DepTrackingMap<maps::Predicates<'tcx>>>,
pub hir: hir_map::Map<'tcx>,
-
- /// Maps from the def-id of a function/method or const/static
- /// to its MIR. Mutation is done at an item granularity to
- /// allow MIR optimization passes to function and still
- /// access cross-crate MIR (e.g. inlining or const eval).
- ///
- /// Note that cross-crate MIR appears to be always borrowed
- /// (in the `RefCell` sense) to prevent accidental mutation.
- pub mir_map: RefCell<DepTrackingMap<maps::Mir<'tcx>>>,
+ pub maps: maps::Maps<'tcx>,
// Records the free variables refrenced by every closure
// expression. Do not track deps for this, just recompute it from
pub maybe_unused_trait_imports: NodeSet,
- // Records the type of every item.
- pub item_types: RefCell<DepTrackingMap<maps::Types<'tcx>>>,
-
// Internal cache for metadata decoding. No need to track deps on this.
pub rcache: RefCell<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
pub lang_items: middle::lang_items::LanguageItems,
- /// Maps from def-id of a type or region parameter to its
- /// (inferred) variance.
- pub item_variance_map: RefCell<DepTrackingMap<maps::ItemVariances<'tcx>>>,
-
/// True if the variance has been computed yet; false otherwise.
pub variance_computed: Cell<bool>,
- /// Maps a DefId of a type to a list of its inherent impls.
- /// Contains implementations of methods that are inherent to a type.
- /// Methods in these implementations don't need to be exported.
- pub inherent_impls: RefCell<DepTrackingMap<maps::InherentImpls<'tcx>>>,
-
/// Set of used unsafe nodes (functions or blocks). Unsafe nodes not
/// present in this set can be warned about.
pub used_unsafe: RefCell<NodeSet>,
/// about.
pub used_mut_nodes: RefCell<NodeSet>,
- /// Set of trait imports actually used in the method resolution.
- /// This is used for warning unused imports.
- pub used_trait_imports: RefCell<DepTrackingMap<maps::UsedTraitImports<'tcx>>>,
-
/// The set of external nominal types whose implementations have been read.
/// This is used for lazy resolution of methods.
pub populated_external_types: RefCell<DefIdSet>,
/// FIXME(arielb1): why is this separate from populated_external_types?
pub populated_external_primitive_impls: RefCell<DefIdSet>,
- /// Results of evaluating monomorphic constants embedded in
- /// other items, such as enum variant explicit discriminants.
- pub monomorphic_const_eval: RefCell<DepTrackingMap<maps::MonomorphicConstEval<'tcx>>>,
-
/// Maps any item's def-id to its stability index.
pub stability: RefCell<stability::Index<'tcx>>,
/// (i.e., no type or lifetime parameters).
pub fulfilled_predicates: RefCell<traits::GlobalFulfilledPredicates<'tcx>>,
- /// Caches the representation hints for struct definitions.
- repr_hint_cache: RefCell<DepTrackingMap<maps::ReprHints<'tcx>>>,
-
/// Maps Expr NodeId's to `true` iff `&expr` can have 'static lifetime.
pub rvalue_promotable_to_static: RefCell<NodeMap<bool>>,
- /// Caches CoerceUnsized kinds for impls on custom types.
- pub custom_coerce_unsized_kinds: RefCell<DefIdMap<ty::adjustment::CustomCoerceUnsized>>,
-
- /// Records the type of each closure. The def ID is the ID of the
- /// expression defining the closure.
- pub closure_tys: RefCell<DepTrackingMap<maps::ClosureTypes<'tcx>>>,
-
- /// Records the type of each closure. The def ID is the ID of the
- /// expression defining the closure.
- pub closure_kinds: RefCell<DepTrackingMap<maps::ClosureKinds<'tcx>>>,
-
/// Maps Fn items to a collection of fragment infos.
///
/// The main goal is to identify data (each of which may be moved
named_region_map: named_region_map,
region_maps: region_maps,
free_region_maps: RefCell::new(FxHashMap()),
- item_variance_map: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
variance_computed: Cell::new(false),
sess: s,
trait_map: resolutions.trait_map,
- tables: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- impl_trait_refs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- trait_defs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- adt_defs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- adt_sized_constraint: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- generics: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- predicates: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- super_predicates: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
fulfilled_predicates: RefCell::new(fulfilled_predicates),
hir: hir,
- mir_map: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
+ maps: maps::Maps::new(dep_graph),
freevars: RefCell::new(resolutions.freevars),
maybe_unused_trait_imports: resolutions.maybe_unused_trait_imports,
- item_types: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
rcache: RefCell::new(FxHashMap()),
tc_cache: RefCell::new(FxHashMap()),
- associated_items: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- associated_item_def_ids: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
normalized_cache: RefCell::new(FxHashMap()),
inhabitedness_cache: RefCell::new(FxHashMap()),
lang_items: lang_items,
- inherent_impls: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
used_unsafe: RefCell::new(NodeSet()),
used_mut_nodes: RefCell::new(NodeSet()),
- used_trait_imports: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
populated_external_types: RefCell::new(DefIdSet()),
populated_external_primitive_impls: RefCell::new(DefIdSet()),
- monomorphic_const_eval: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
stability: RefCell::new(stability),
selection_cache: traits::SelectionCache::new(),
evaluation_cache: traits::EvaluationCache::new(),
- repr_hint_cache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
rvalue_promotable_to_static: RefCell::new(NodeMap()),
- custom_coerce_unsized_kinds: RefCell::new(DefIdMap()),
- closure_tys: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- closure_kinds: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
fragment_infos: RefCell::new(DefIdMap()),
crate_name: Symbol::intern(crate_name),
data_layout: data_layout,
/// Obtain the representation annotation for a struct definition.
pub fn lookup_repr_hints(self, did: DefId) -> Rc<Vec<attr::ReprAttr>> {
- self.repr_hint_cache.memoize(did, || {
+ self.maps.repr_hints.memoize(did, || {
Rc::new(self.get_attrs(did).iter().flat_map(|meta| {
attr::find_repr_attrs(self.sess.diagnostic(), meta).into_iter()
}).collect())
} else {
// for local crates, check whether type info is
// available; typeck might not have completed yet
- self.impl_trait_refs.borrow().contains_key(&impl_def_id)
+ self.maps.impl_trait_refs.borrow().contains_key(&impl_def_id)
};
if !use_types {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use dep_graph::{DepNode, DepTrackingMapConfig};
+use dep_graph::{DepGraph, DepNode, DepTrackingMap, DepTrackingMapConfig};
use hir::def_id::DefId;
use middle::const_val::ConstVal;
-use mir;
use ty::{self, Ty};
use util::nodemap::DefIdSet;
use std::rc::Rc;
use syntax::attr;
-macro_rules! dep_map_ty {
- ($ty_name:ident : $node_name:ident ($key:ty) -> $value:ty) => {
- pub struct $ty_name<'tcx> {
+macro_rules! define_maps {
+ ($($(#[$attr:meta])* pub $field:ident: $node_name:ident($key:ty) -> $value:ty),*) => {
+ pub struct Maps<'tcx> {
+ $($(#[$attr])* pub $field: RefCell<DepTrackingMap<$field<'tcx>>>),*
+ }
+
+ impl<'tcx> Maps<'tcx> {
+ pub fn new(dep_graph: DepGraph) -> Self {
+ Maps {
+ $($field: RefCell::new(DepTrackingMap::new(dep_graph.clone()))),*
+ }
+ }
+ }
+
+ $(#[allow(bad_style)]
+ pub struct $field<'tcx> {
data: PhantomData<&'tcx ()>
}
- impl<'tcx> DepTrackingMapConfig for $ty_name<'tcx> {
+ impl<'tcx> DepTrackingMapConfig for $field<'tcx> {
type Key = $key;
type Value = $value;
fn to_dep_node(key: &$key) -> DepNode<DefId> { DepNode::$node_name(*key) }
- }
+ })*
}
}
-dep_map_ty! { AssociatedItems: AssociatedItems(DefId) -> ty::AssociatedItem }
-dep_map_ty! { Types: ItemSignature(DefId) -> Ty<'tcx> }
-dep_map_ty! { Generics: ItemSignature(DefId) -> &'tcx ty::Generics }
-dep_map_ty! { Predicates: ItemSignature(DefId) -> ty::GenericPredicates<'tcx> }
-dep_map_ty! { SuperPredicates: ItemSignature(DefId) -> ty::GenericPredicates<'tcx> }
-dep_map_ty! { AssociatedItemDefIds: AssociatedItemDefIds(DefId) -> Rc<Vec<DefId>> }
-dep_map_ty! { ImplTraitRefs: ItemSignature(DefId) -> Option<ty::TraitRef<'tcx>> }
-dep_map_ty! { TraitDefs: ItemSignature(DefId) -> &'tcx ty::TraitDef }
-dep_map_ty! { AdtDefs: ItemSignature(DefId) -> &'tcx ty::AdtDef }
-dep_map_ty! { AdtSizedConstraint: SizedConstraint(DefId) -> Ty<'tcx> }
-dep_map_ty! { ItemVariances: ItemSignature(DefId) -> Rc<Vec<ty::Variance>> }
-dep_map_ty! { InherentImpls: InherentImpls(DefId) -> Vec<DefId> }
-dep_map_ty! { ReprHints: ReprHints(DefId) -> Rc<Vec<attr::ReprAttr>> }
-dep_map_ty! { Mir: Mir(DefId) -> &'tcx RefCell<mir::Mir<'tcx>> }
-dep_map_ty! { ClosureKinds: ItemSignature(DefId) -> ty::ClosureKind }
-dep_map_ty! { ClosureTypes: ItemSignature(DefId) -> ty::ClosureTy<'tcx> }
-dep_map_ty! { TypeckTables: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx> }
-dep_map_ty! { UsedTraitImports: UsedTraitImports(DefId) -> DefIdSet }
-dep_map_ty! { MonomorphicConstEval: MonomorphicConstEval(DefId) -> Result<ConstVal, ()> }
+define_maps! {
+ /// Maps from a trait item to the trait item "descriptor"
+ pub associated_items: AssociatedItems(DefId) -> ty::AssociatedItem,
+
+ /// Records the type of every item.
+ pub types: ItemSignature(DefId) -> Ty<'tcx>,
+
+ /// Maps from the def-id of an item (trait/struct/enum/fn) to its
+ /// associated generics and predicates.
+ pub generics: ItemSignature(DefId) -> &'tcx ty::Generics,
+ pub predicates: ItemSignature(DefId) -> ty::GenericPredicates<'tcx>,
+
+ /// Maps from the def-id of a trait to the list of
+ /// super-predicates. This is a subset of the full list of
+ /// predicates. We store these in a separate map because we must
+ /// evaluate them even during type conversion, often before the
+ /// full predicates are available (note that supertraits have
+ /// additional acyclicity requirements).
+ pub super_predicates: ItemSignature(DefId) -> ty::GenericPredicates<'tcx>,
+
+ /// Maps from an impl/trait def-id to a list of the def-ids of its items
+ pub associated_item_def_ids: AssociatedItemDefIds(DefId) -> Rc<Vec<DefId>>,
+
+ pub impl_trait_refs: ItemSignature(DefId) -> Option<ty::TraitRef<'tcx>>,
+ pub trait_defs: ItemSignature(DefId) -> &'tcx ty::TraitDef,
+ pub adt_defs: ItemSignature(DefId) -> &'tcx ty::AdtDef,
+ pub adt_sized_constraint: SizedConstraint(DefId) -> Ty<'tcx>,
+
+ /// Maps from def-id of a type or region parameter to its
+ /// (inferred) variance.
+ pub variances: ItemSignature(DefId) -> Rc<Vec<ty::Variance>>,
+
+ /// Maps a DefId of a type to a list of its inherent impls.
+ /// Contains implementations of methods that are inherent to a type.
+ /// Methods in these implementations don't need to be exported.
+ pub inherent_impls: InherentImpls(DefId) -> Vec<DefId>,
+
+ /// Caches the representation hints for struct definitions.
+ pub repr_hints: ReprHints(DefId) -> Rc<Vec<attr::ReprAttr>>,
+
+ /// Maps from the def-id of a function/method or const/static
+ /// to its MIR. Mutation is done at an item granularity to
+ /// allow MIR optimization passes to function and still
+ /// access cross-crate MIR (e.g. inlining or const eval).
+ ///
+ /// Note that cross-crate MIR appears to be always borrowed
+ /// (in the `RefCell` sense) to prevent accidental mutation.
+ pub mir: Mir(DefId) -> &'tcx RefCell<::mir::Mir<'tcx>>,
+
+ /// Records the type of each closure. The def ID is the ID of the
+ /// expression defining the closure.
+ pub closure_kinds: ItemSignature(DefId) -> ty::ClosureKind,
+
+ /// Records the type of each closure. The def ID is the ID of the
+ /// expression defining the closure.
+ pub closure_types: ItemSignature(DefId) -> ty::ClosureTy<'tcx>,
+
+ /// Caches CoerceUnsized kinds for impls on custom types.
+ pub custom_coerce_unsized_kinds: ItemSignature(DefId)
+ -> ty::adjustment::CustomCoerceUnsized,
+
+ pub typeck_tables: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
+
+ /// Set of trait imports actually used in the method resolution.
+ /// This is used for warning unused imports.
+ pub used_trait_imports: UsedTraitImports(DefId) -> DefIdSet,
+
+ /// Results of evaluating monomorphic constants embedded in
+ /// other items, such as enum variant explicit discriminants.
+ pub monomorphic_const_eval: MonomorphicConstEval(DefId) -> Result<ConstVal, ()>
+}
self.variants.iter().map(move |v| {
let mut discr = prev_discr.map_or(initial, |d| d.wrap_incr());
if let VariantDiscr::Explicit(expr_did) = v.discr {
- match tcx.monomorphic_const_eval.borrow()[&expr_did] {
+ match tcx.maps.monomorphic_const_eval.borrow()[&expr_did] {
Ok(ConstVal::Integral(v)) => {
discr = v;
}
stack: &mut Vec<DefId>)
-> Ty<'tcx>
{
- if let Some(ty) = tcx.adt_sized_constraint.borrow().get(&self.did) {
+ if let Some(ty) = tcx.maps.adt_sized_constraint.borrow().get(&self.did) {
return ty;
}
//
// Consider the type as Sized in the meanwhile to avoid
// further errors.
- tcx.adt_sized_constraint.borrow_mut().insert(self.did, tcx.types.err);
+ tcx.maps.adt_sized_constraint.borrow_mut().insert(self.did, tcx.types.err);
return tcx.types.err;
}
_ => tcx.intern_tup(&tys[..], false)
};
- let old = tcx.adt_sized_constraint.borrow().get(&self.did).cloned();
+ let old = tcx.maps.adt_sized_constraint.borrow().get(&self.did).cloned();
match old {
Some(old_ty) => {
debug!("calculate_sized_constraint: {:?} recurred", self);
}
None => {
debug!("calculate_sized_constraint: {:?} => {:?}", self, ty);
- tcx.adt_sized_constraint.borrow_mut().insert(self.did, ty);
+ tcx.maps.adt_sized_constraint.borrow_mut().insert(self.did, ty);
ty
}
}
}
pub fn item_tables(self, def_id: DefId) -> &'gcx TypeckTables<'gcx> {
- self.tables.memoize(def_id, || {
+ self.maps.typeck_tables.memoize(def_id, || {
if def_id.is_local() {
// Closures' tables come from their outermost function,
// as they are part of the same "inference environment".
// Cross-crate side-tables only exist alongside serialized HIR.
self.sess.cstore.maybe_get_item_body(self.global_tcx(), def_id).map(|_| {
- self.tables.borrow()[&def_id]
+ self.maps.typeck_tables.borrow()[&def_id]
}).unwrap_or_else(|| {
bug!("tcx.item_tables({:?}): missing from metadata", def_id)
})
}
pub fn custom_coerce_unsized_kind(self, did: DefId) -> adjustment::CustomCoerceUnsized {
- self.custom_coerce_unsized_kinds.memoize(did, || {
+ self.maps.custom_coerce_unsized_kinds.memoize(did, || {
let (kind, src) = if did.krate != LOCAL_CRATE {
(self.sess.cstore.custom_coerce_unsized_kind(did), "external")
} else {
}
pub fn associated_item(self, def_id: DefId) -> AssociatedItem {
- self.associated_items.memoize(def_id, || {
+ self.maps.associated_items.memoize(def_id, || {
if !def_id.is_local() {
return self.sess.cstore.associated_item(def_id)
.expect("missing AssociatedItem in metadata");
self.associated_item_from_impl_item_ref(parent_def_id,
impl_trait_ref.is_some(),
impl_item_ref);
- self.associated_items.borrow_mut().insert(assoc_item.def_id, assoc_item);
+ self.maps.associated_items.borrow_mut()
+ .insert(assoc_item.def_id, assoc_item);
}
}
for trait_item_ref in trait_item_refs {
let assoc_item =
self.associated_item_from_trait_item_ref(parent_def_id, trait_item_ref);
- self.associated_items.borrow_mut().insert(assoc_item.def_id, assoc_item);
+ self.maps.associated_items.borrow_mut()
+ .insert(assoc_item.def_id, assoc_item);
}
}
// memoize wants us to return something, so return
// the one we generated for this def-id
- *self.associated_items.borrow().get(&def_id).unwrap()
+ *self.maps.associated_items.borrow().get(&def_id).unwrap()
})
}
}
pub fn associated_item_def_ids(self, def_id: DefId) -> Rc<Vec<DefId>> {
- self.associated_item_def_ids.memoize(def_id, || {
+ self.maps.associated_item_def_ids.memoize(def_id, || {
if !def_id.is_local() {
return Rc::new(self.sess.cstore.associated_item_def_ids(def_id));
}
/// an inherent impl.
pub fn impl_trait_ref(self, id: DefId) -> Option<TraitRef<'gcx>> {
lookup_locally_or_in_crate_store(
- "impl_trait_refs", id, &self.impl_trait_refs,
+ "impl_trait_refs", id, &self.maps.impl_trait_refs,
|| self.sess.cstore.impl_trait_ref(self.global_tcx(), id))
}
// the type cache. Returns the type parameters and type.
pub fn item_type(self, did: DefId) -> Ty<'gcx> {
lookup_locally_or_in_crate_store(
- "item_types", did, &self.item_types,
+ "item_types", did, &self.maps.types,
|| self.sess.cstore.item_type(self.global_tcx(), did))
}
/// Given the did of a trait, returns its canonical trait ref.
pub fn lookup_trait_def(self, did: DefId) -> &'gcx TraitDef {
lookup_locally_or_in_crate_store(
- "trait_defs", did, &self.trait_defs,
+ "trait_defs", did, &self.maps.trait_defs,
|| self.alloc_trait_def(self.sess.cstore.trait_def(self.global_tcx(), did))
)
}
/// Given the did of an ADT, return a reference to its definition.
pub fn lookup_adt_def(self, did: DefId) -> &'gcx AdtDef {
lookup_locally_or_in_crate_store(
- "adt_defs", did, &self.adt_defs,
+ "adt_defs", did, &self.maps.adt_defs,
|| self.sess.cstore.adt_def(self.global_tcx(), did))
}
/// Given the did of an item, returns its generics.
pub fn item_generics(self, did: DefId) -> &'gcx Generics {
lookup_locally_or_in_crate_store(
- "generics", did, &self.generics,
+ "generics", did, &self.maps.generics,
|| self.alloc_generics(self.sess.cstore.item_generics(did)))
}
/// Given the did of an item, returns its full set of predicates.
pub fn item_predicates(self, did: DefId) -> GenericPredicates<'gcx> {
lookup_locally_or_in_crate_store(
- "predicates", did, &self.predicates,
+ "predicates", did, &self.maps.predicates,
|| self.sess.cstore.item_predicates(self.global_tcx(), did))
}
/// Given the did of a trait, returns its superpredicates.
pub fn item_super_predicates(self, did: DefId) -> GenericPredicates<'gcx> {
lookup_locally_or_in_crate_store(
- "super_predicates", did, &self.super_predicates,
+ "super_predicates", did, &self.maps.super_predicates,
|| self.sess.cstore.item_super_predicates(self.global_tcx(), did))
}
/// Given the did of an item, returns its MIR, borrowed immutably.
pub fn item_mir(self, did: DefId) -> Ref<'gcx, Mir<'gcx>> {
- lookup_locally_or_in_crate_store("mir_map", did, &self.mir_map, || {
+ lookup_locally_or_in_crate_store("mir_map", did, &self.maps.mir, || {
let mir = self.sess.cstore.get_item_mir(self.global_tcx(), did);
let mir = self.alloc_mir(mir);
pub fn item_variances(self, item_id: DefId) -> Rc<Vec<ty::Variance>> {
lookup_locally_or_in_crate_store(
- "item_variance_map", item_id, &self.item_variance_map,
+ "item_variance_map", item_id, &self.maps.variances,
|| Rc::new(self.sess.cstore.item_variances(item_id)))
}
let inherent_impls = self.sess.cstore.inherent_implementations_for_type(type_id);
- self.inherent_impls.borrow_mut().insert(type_id, inherent_impls);
+ self.maps.inherent_impls.borrow_mut().insert(type_id, inherent_impls);
self.populated_external_types.borrow_mut().insert(type_id);
}
// If this is a local def-id, it should be inserted into the
// tables by typeck; else, it will be retreived from
// the external crate metadata.
- if let Some(&kind) = self.closure_kinds.borrow().get(&def_id) {
+ if let Some(&kind) = self.maps.closure_kinds.borrow().get(&def_id) {
return kind;
}
let kind = self.sess.cstore.closure_kind(def_id);
- self.closure_kinds.borrow_mut().insert(def_id, kind);
+ self.maps.closure_kinds.borrow_mut().insert(def_id, kind);
kind
}
// If this is a local def-id, it should be inserted into the
// tables by typeck; else, it will be retreived from
// the external crate metadata.
- if let Some(ty) = self.closure_tys.borrow().get(&def_id) {
+ if let Some(ty) = self.maps.closure_types.borrow().get(&def_id) {
return ty.subst(self, substs.substs);
}
let ty = self.sess.cstore.closure_ty(self.global_tcx(), def_id);
- self.closure_tys.borrow_mut().insert(def_id, ty.clone());
+ self.maps.closure_types.borrow_mut().insert(def_id, ty.clone());
ty.subst(self, substs.substs)
}
}
});
}
- match self.associated_items.borrow().get(&def_id).cloned() {
+ match self.maps.associated_items.borrow().get(&def_id).cloned() {
Some(trait_item) => {
match trait_item.container {
TraitContainer(_) => None,
if def_id.krate != LOCAL_CRATE {
return self.sess.cstore.trait_of_item(def_id);
}
- match self.associated_items.borrow().get(&def_id) {
+ match self.maps.associated_items.borrow().get(&def_id) {
Some(associated_item) => {
match associated_item.container {
TraitContainer(def_id) => Some(def_id),
TyAdt(def, substs) => {
ty::tls::with(|tcx| {
if def.did.is_local() &&
- !tcx.item_types.borrow().contains_key(&def.did) {
+ !tcx.maps.types.borrow().contains_key(&def.did) {
write!(f, "{}<..>", tcx.item_path_str(def.did))
} else {
parameterized(f, substs, def.did, &[])
return variant.node.disr_expr.map(|e| {
let def_id = tcx.hir.body_owner_def_id(e);
(&tcx.hir.body(e).value,
- tcx.tables.borrow().get(&def_id).cloned())
+ tcx.maps.typeck_tables.borrow().get(&def_id).cloned())
});
}
}
node: hir::ImplItemKind::Const(ref ty, body), ..
})) => {
Some((&tcx.hir.body(body).value,
- tcx.tables.borrow().get(&def_id).cloned(),
+ tcx.maps.typeck_tables.borrow().get(&def_id).cloned(),
tcx.ast_ty_to_prim_ty(ty)))
}
Some(hir_map::NodeTraitItem(ti)) => match ti.node {
let trait_id = tcx.hir.local_def_id(trait_id);
let default_value = default.map(|body| {
(&tcx.hir.body(body).value,
- tcx.tables.borrow().get(&def_id).cloned(),
+ tcx.maps.typeck_tables.borrow().get(&def_id).cloned(),
tcx.ast_ty_to_prim_ty(ty))
});
resolve_trait_associated_const(tcx, def_id, default_value, trait_id, substs)
FnLikeNode::from_node(tcx.hir.get(node_id)).and_then(|fn_like| {
if fn_like.constness() == hir::Constness::Const {
Some((tcx.hir.body(fn_like.body()),
- tcx.tables.borrow().get(&def_id).cloned()))
+ tcx.maps.typeck_tables.borrow().get(&def_id).cloned()))
} else {
None
}
let def_id = tcx.hir.body_owner_def_id(body);
ConstContext {
tcx: tcx,
- tables: tcx.tables.borrow().get(&def_id).cloned(),
+ tables: tcx.maps.typeck_tables.borrow().get(&def_id).cloned(),
fn_args: None
}
}
} else {
match ppm {
PpmMir => {
- write_mir_pretty(tcx, tcx.mir_map.borrow().keys().into_iter(), &mut out)
+ write_mir_pretty(tcx,
+ tcx.maps.mir.borrow().keys().into_iter(),
+ &mut out)
}
PpmMirCFG => {
write_mir_graphviz(tcx,
- tcx.mir_map.borrow().keys().into_iter(),
+ tcx.maps.mir.borrow().keys().into_iter(),
&mut out)
}
_ => unreachable!(),
pub fn method_context(cx: &LateContext, id: ast::NodeId, span: Span) -> MethodLateContext {
let def_id = cx.tcx.hir.local_def_id(id);
- match cx.tcx.associated_items.borrow().get(&def_id) {
+ match cx.tcx.maps.associated_items.borrow().get(&def_id) {
None => span_bug!(span, "missing method descriptor?!"),
Some(item) => {
match item.container {
if let ty::VariantDiscr::Explicit(def_id) = data.discr {
let result = data.evaluated_discr.map_or(Err(()), Ok);
- tcx.monomorphic_const_eval.borrow_mut().insert(def_id, result);
+ tcx.maps.monomorphic_const_eval.borrow_mut().insert(def_id, result);
}
(ty::VariantDef {
let adt = tcx.alloc_adt_def(did, kind, variants, repr);
if let Some(ctor_index) = ctor_index {
// Make adt definition available through constructor id as well.
- tcx.adt_defs.borrow_mut().insert(self.local_def_id(ctor_index), adt);
+ tcx.maps.adt_defs.borrow_mut().insert(self.local_def_id(ctor_index), adt);
}
adt
let ast = ast.decode(self);
let tables = ast.tables.decode((self, tcx));
- tcx.tables.borrow_mut().insert(def_id, tcx.alloc_tables(tables));
+ tcx.maps.typeck_tables.borrow_mut().insert(def_id, tcx.alloc_tables(tables));
let body = ast.body.decode((self, tcx));
tcx.hir.intern_inlined_body(def_id, body)
discr: variant.discr,
evaluated_discr: match variant.discr {
ty::VariantDiscr::Explicit(def_id) => {
- tcx.monomorphic_const_eval.borrow()[&def_id].clone().ok()
+ tcx.maps.monomorphic_const_eval.borrow()[&def_id].clone().ok()
}
ty::VariantDiscr::Relative(_) => None
},
}
fn encode_mir(&mut self, def_id: DefId) -> Option<Lazy<mir::Mir<'tcx>>> {
- self.tcx.mir_map.borrow().get(&def_id).map(|mir| self.lazy(&*mir.borrow()))
+ self.tcx.maps.mir.borrow().get(&def_id).map(|mir| self.lazy(&*mir.borrow()))
}
// Encodes the inherent implementations of a structure, enumeration, or trait.
fn encode_inherent_implementations(&mut self, def_id: DefId) -> LazySeq<DefIndex> {
- match self.tcx.inherent_impls.borrow().get(&def_id) {
+ match self.tcx.maps.inherent_impls.borrow().get(&def_id) {
None => LazySeq::empty(),
Some(implementations) => {
self.lazy_seq(implementations.iter().map(|&def_id| {
let data = ImplData {
polarity: polarity,
parent_impl: parent,
- coerce_unsized_kind: tcx.custom_coerce_unsized_kinds
+ coerce_unsized_kind: tcx.maps.custom_coerce_unsized_kinds
.borrow()
.get(&def_id)
.cloned(),
let data = ClosureData {
kind: tcx.closure_kind(def_id),
- ty: self.lazy(&tcx.closure_tys.borrow()[&def_id]),
+ ty: self.lazy(&tcx.maps.closure_types.borrow()[&def_id]),
};
Entry {
let mir = tcx.alloc_mir(mir);
let def_id = tcx.hir.local_def_id(src.item_id());
- tcx.mir_map.borrow_mut().insert(def_id, mir);
+ tcx.maps.mir.borrow_mut().insert(def_id, mir);
});
let body = self.tcx.hir.body(body_id);
// For debugging instrumentation like this, we don't need to worry
// about maintaining the dep graph.
let _ignore = tcx.dep_graph.in_ignore();
- let mir_map = tcx.mir_map.borrow();
+ let mir_map = tcx.maps.mir.borrow();
for def_id in mir_map.keys() {
let mir = mir_map.get(&def_id).unwrap();
collector.visit_mir(&mir.borrow());
where F: FnOnce(&mut DumpVisitor<'l, 'tcx, 'll, D>)
{
let item_def_id = self.tcx.hir.local_def_id(item_id);
- match self.tcx.tables.borrow().get(&item_def_id) {
+ match self.tcx.maps.typeck_tables.borrow().get(&item_def_id) {
Some(tables) => {
let old_tables = self.save_ctxt.tables;
self.save_ctxt.tables = tables;
explicit_index -= distance;
}
ty::VariantDiscr::Explicit(expr_did) => {
- match tcx.monomorphic_const_eval.borrow()[&expr_did] {
+ match tcx.maps.monomorphic_const_eval.borrow()[&expr_did] {
Ok(ConstVal::Integral(v)) => {
explicit_value = Disr::from(v);
break;
ast_ty.span);
let predicates = bounds.predicates(tcx, ty);
let predicates = tcx.lift_to_global(&predicates).unwrap();
- tcx.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
+ tcx.maps.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
parent: None,
predicates: predicates
});
// metadata if necessary.
self.tcx.populate_inherent_implementations_for_type_if_necessary(def_id);
- if let Some(impl_infos) = self.tcx.inherent_impls.borrow().get(&def_id) {
+ if let Some(impl_infos) = self.tcx.maps.inherent_impls.borrow().get(&def_id) {
for &impl_def_id in impl_infos.iter() {
self.assemble_inherent_impl_probe(impl_def_id);
}
wbcx.visit_lints();
let tables = self.tcx.alloc_tables(wbcx.tables);
- self.tcx.tables.borrow_mut().insert(item_def_id, tables);
+ self.tcx.maps.typeck_tables.borrow_mut().insert(item_def_id, tables);
let used_trait_imports = mem::replace(&mut *self.used_trait_imports.borrow_mut(),
DefIdSet());
debug!("used_trait_imports({:?}) = {:?}", item_def_id, used_trait_imports);
- self.tcx.used_trait_imports.borrow_mut().insert(item_def_id, used_trait_imports);
+ self.tcx.maps.used_trait_imports.borrow_mut().insert(item_def_id, used_trait_imports);
}
}
for (&id, closure_ty) in self.fcx.tables.borrow().closure_tys.iter() {
let closure_ty = self.resolve(closure_ty, ResolvingClosure(id));
let def_id = self.tcx().hir.local_def_id(id);
- self.tcx().closure_tys.borrow_mut().insert(def_id, closure_ty);
+ self.tcx().maps.closure_types.borrow_mut().insert(def_id, closure_ty);
}
for (&id, &closure_kind) in self.fcx.tables.borrow().closure_kinds.iter() {
let def_id = self.tcx().hir.local_def_id(id);
- self.tcx().closure_kinds.borrow_mut().insert(def_id, closure_kind);
+ self.tcx().maps.closure_kinds.borrow_mut().insert(def_id, closure_kind);
}
}
}
});
- gcx.item_types.borrow_mut().insert(def_id, outside_ty);
+ gcx.maps.types.borrow_mut().insert(def_id, outside_ty);
}
}
let item_def_id = tcx.hir.local_def_id(item_id);
// this will have been written by the main typeck pass
- if let Some(imports) = tcx.used_trait_imports.borrow().get(&item_def_id) {
+ if let Some(imports) = tcx.maps.used_trait_imports.borrow().get(&item_def_id) {
debug!("GatherVisitor: item_def_id={:?} with imports {:#?}", item_def_id, imports);
used_trait_imports.extend(imports);
} else {
infcx.resolve_regions_and_report_errors(&free_regions, impl_node_id);
if let Some(kind) = kind {
- tcx.custom_coerce_unsized_kinds.borrow_mut().insert(impl_did, kind);
+ tcx.maps.custom_coerce_unsized_kinds.borrow_mut().insert(impl_did, kind);
}
});
}
struct CoherenceCollect<'a, 'tcx: 'a> {
tcx: TyCtxt<'a, 'tcx, 'tcx>,
- inherent_impls: RefMut<'a, DepTrackingMap<maps::InherentImpls<'tcx>>>,
+ inherent_impls: RefMut<'a, DepTrackingMap<maps::inherent_impls<'tcx>>>,
}
impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CoherenceCollect<'a, 'tcx> {
impl<'a, 'tcx> CoherenceCollect<'a, 'tcx> {
fn check(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- let inherent_impls = tcx.inherent_impls.borrow_mut();
+ let inherent_impls = tcx.maps.inherent_impls.borrow_mut();
let mut this = &mut CoherenceCollect { tcx, inherent_impls };
// Check implementations and traits. This populates the tables
fn check_for_overlapping_inherent_impls(&self, ty_def_id: DefId) {
let _task = self.tcx.dep_graph.in_task(DepNode::CoherenceOverlapInherentCheck(ty_def_id));
- let inherent_impls = self.tcx.inherent_impls.borrow();
+ let inherent_impls = self.tcx.maps.inherent_impls.borrow();
let impls = match inherent_impls.get(&ty_def_id) {
Some(impls) => impls,
None => return,
{
generics_of_def_id(ccx, ty_f.did);
let tt = ccx.icx(ty_f.did).to_ty(&field.ty);
- ccx.tcx.item_types.borrow_mut().insert(ty_f.did, tt);
- ccx.tcx.predicates.borrow_mut().insert(ty_f.did, ty::GenericPredicates {
+ ccx.tcx.maps.types.borrow_mut().insert(ty_f.did, tt);
+ ccx.tcx.maps.predicates.borrow_mut().insert(ty_f.did, ty::GenericPredicates {
parent: Some(ccx.tcx.hir.get_parent_did(field.id)),
predicates: vec![]
});
let fty = AstConv::ty_of_fn(&ccx.icx(def_id), sig.unsafety, sig.abi, &sig.decl);
let substs = mk_item_substs(ccx, def_id);
let fty = ccx.tcx.mk_fn_def(def_id, substs, fty);
- ccx.tcx.item_types.borrow_mut().insert(def_id, fty);
+ ccx.tcx.maps.types.borrow_mut().insert(def_id, fty);
ty_generic_predicates(ccx, def_id, &sig.generics);
}
predicates: vec![]
};
let def_id = ccx.tcx.hir.local_def_id(id);
- ccx.tcx.predicates.borrow_mut().insert(def_id, predicates);
- ccx.tcx.item_types.borrow_mut().insert(def_id, ty);
+ ccx.tcx.maps.predicates.borrow_mut().insert(def_id, predicates);
+ ccx.tcx.maps.types.borrow_mut().insert(def_id, ty);
}
fn convert_associated_type<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>,
predicates: vec![]
};
let def_id = ccx.tcx.hir.local_def_id(id);
- ccx.tcx.predicates.borrow_mut().insert(def_id, predicates);
+ ccx.tcx.maps.predicates.borrow_mut().insert(def_id, predicates);
if let Some(ty) = ty {
- ccx.tcx.item_types.borrow_mut().insert(def_id, ty);
+ ccx.tcx.maps.types.borrow_mut().insert(def_id, ty);
}
}
tcx.record_trait_has_default_impl(trait_ref.def_id);
- tcx.impl_trait_refs.borrow_mut().insert(ccx.tcx.hir.local_def_id(it.id),
- Some(trait_ref));
+ tcx.maps.impl_trait_refs.borrow_mut().insert(ccx.tcx.hir.local_def_id(it.id),
+ Some(trait_ref));
}
hir::ItemImpl(.., ref opt_trait_ref, _, _) => {
generics_of_def_id(ccx, def_id);
let trait_ref = opt_trait_ref.as_ref().map(|ast_trait_ref| {
AstConv::instantiate_mono_trait_ref(&icx, ast_trait_ref, selfty)
});
- tcx.impl_trait_refs.borrow_mut().insert(def_id, trait_ref);
+ tcx.maps.impl_trait_refs.borrow_mut().insert(def_id, trait_ref);
predicates_of_item(ccx, it);
},
}))
}
};
- tcx.item_types.borrow_mut().insert(def_id, ctor_ty);
- tcx.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
+ tcx.maps.types.borrow_mut().insert(def_id, ctor_ty);
+ tcx.maps.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
parent: Some(ccx.tcx.hir.get_parent_did(ctor_id)),
predicates: vec![]
});
let result = evaluate_disr_expr(ccx, repr_type, e);
let expr_did = tcx.hir.local_def_id(e.node_id);
- tcx.monomorphic_const_eval.borrow_mut()
+ tcx.maps.monomorphic_const_eval.borrow_mut()
.insert(expr_did, result.map(ConstVal::Integral));
result.ok()
ReprOptions::new(&ccx.tcx, did));
if let Some(ctor_id) = ctor_id {
// Make adt definition available through constructor id as well.
- ccx.tcx.adt_defs.borrow_mut().insert(ctor_id, adt);
+ ccx.tcx.maps.adt_defs.borrow_mut().insert(ctor_id, adt);
}
- ccx.tcx.adt_defs.borrow_mut().insert(did, adt);
+ ccx.tcx.maps.adt_defs.borrow_mut().insert(did, adt);
adt
}
ty::VariantDiscr::Relative(0), def)];
let adt = ccx.tcx.alloc_adt_def(did, AdtKind::Union, variants, ReprOptions::new(&ccx.tcx, did));
- ccx.tcx.adt_defs.borrow_mut().insert(did, adt);
+ ccx.tcx.maps.adt_defs.borrow_mut().insert(did, adt);
adt
}
let did = tcx.hir.local_def_id(it.id);
let adt = tcx.alloc_adt_def(did, AdtKind::Enum, variants, ReprOptions::new(&ccx.tcx, did));
- tcx.adt_defs.borrow_mut().insert(did, adt);
+ tcx.maps.adt_defs.borrow_mut().insert(did, adt);
adt
}
return Vec::new();
};
- let superpredicates = tcx.super_predicates.borrow().get(&trait_def_id).cloned();
+ let superpredicates = tcx.maps.super_predicates.borrow().get(&trait_def_id).cloned();
let superpredicates = superpredicates.unwrap_or_else(|| {
let item = match ccx.tcx.hir.get(trait_node_id) {
hir_map::NodeItem(item) => item,
tcx.hir.local_def_id(item.id),
superpredicates);
- tcx.super_predicates.borrow_mut().insert(trait_def_id, superpredicates.clone());
+ tcx.maps.super_predicates.borrow_mut().insert(trait_def_id, superpredicates.clone());
superpredicates
});
let tcx = ccx.tcx;
let def_id = tcx.hir.local_def_id(it.id);
- tcx.trait_defs.memoize(def_id, || {
+ tcx.maps.trait_defs.memoize(def_id, || {
let unsafety = match it.node {
hir::ItemTrait(unsafety, ..) => unsafety,
_ => span_bug!(it.span, "trait_def_of_item invoked on non-trait"),
} else {
return tcx.item_generics(def_id);
};
- tcx.generics.memoize(def_id, || {
+ tcx.maps.generics.memoize(def_id, || {
use rustc::hir::map::*;
use rustc::hir::*;
} else {
return ccx.tcx.item_type(def_id);
};
- ccx.tcx.item_types.memoize(def_id, || {
+ ccx.tcx.maps.types.memoize(def_id, || {
use rustc::hir::map::*;
use rustc::hir::*;
&mut ctp::parameters_for_impl(self_ty, trait_ref));
}
- tcx.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
+ tcx.maps.predicates.borrow_mut().insert(def_id, ty::GenericPredicates {
parent: generics.parent,
predicates: predicates
});
//! The second pass over the AST determines the set of constraints.
//! We walk the set of items and, for each member, generate new constraints.
-use dep_graph::DepTrackingMapConfig;
use hir::def_id::DefId;
use middle::resolve_lifetime as rl;
use rustc::ty::subst::Substs;
use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::maps::ItemVariances;
use rustc::hir::map as hir_map;
use syntax::ast;
use rustc::hir;
use super::terms::VarianceTerm::*;
use super::xform::*;
+use dep_graph::DepNode::ItemSignature as VarianceDepNode;
+
pub struct ConstraintContext<'a, 'tcx: 'a> {
pub terms_cx: TermsContext<'a, 'tcx>,
};
// See README.md for a discussion on dep-graph management.
- tcx.visit_all_item_likes_in_krate(|def_id| ItemVariances::to_dep_node(&def_id),
- &mut constraint_cx);
+ tcx.visit_all_item_likes_in_krate(VarianceDepNode, &mut constraint_cx);
constraint_cx
}
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));
+ self.tcx().dep_graph.read(VarianceDepNode(trait_ref.def_id));
self.add_constraints_from_substs(generics,
trait_ref.def_id,
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&def.did));
+ self.tcx().dep_graph.read(VarianceDepNode(def.did));
self.add_constraints_from_substs(generics,
def.did,
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));
+ self.tcx().dep_graph.read(VarianceDepNode(trait_ref.def_id));
self.add_constraints_from_substs(generics,
trait_ref.def_id,
item_variances);
}
- tcx.item_variance_map
+ tcx.maps.variances
.borrow_mut()
.insert(item_def_id, Rc::new(item_variances));
}
// a variable.
use arena::TypedArena;
-use dep_graph::DepTrackingMapConfig;
use rustc::ty::{self, TyCtxt};
-use rustc::ty::maps::ItemVariances;
use std::fmt;
use std::rc::Rc;
use syntax::ast;
pub type VarianceTermPtr<'a> = &'a VarianceTerm<'a>;
+use dep_graph::DepNode::ItemSignature as VarianceDepNode;
+
#[derive(Copy, Clone, Debug)]
pub struct InferredIndex(pub usize);
};
// See README.md for a discussion on dep-graph management.
- tcx.visit_all_item_likes_in_krate(|def_id| ItemVariances::to_dep_node(&def_id), &mut terms_cx);
+ tcx.visit_all_item_likes_in_krate(|def_id| VarianceDepNode(def_id), &mut terms_cx);
terms_cx
}
// parameters".
if self.num_inferred() == inferreds_on_entry {
let item_def_id = self.tcx.hir.local_def_id(item_id);
- self.tcx
- .item_variance_map
+ self.tcx.maps.variances
.borrow_mut()
.insert(item_def_id, self.empty_variances.clone());
}
tcx.populate_inherent_implementations_for_type_if_necessary(did);
let mut impls = Vec::new();
- if let Some(i) = tcx.inherent_impls.borrow().get(&did) {
+ if let Some(i) = tcx.maps.inherent_impls.borrow().get(&did) {
for &did in i.iter() {
build_impl(cx, did, &mut impls);
}