//! There are also some rather random cases (like const initializer
//! expressions) that are mostly just leftovers.
-
-
use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::StableHasher;
pub fn contains_key(&self, key: &DefKey) -> bool {
self.key_to_index.contains_key(key)
}
+
+ pub fn retrace_path(&self,
+ path_data: &[DisambiguatedDefPathData])
+ -> Option<DefIndex> {
+ let root_key = DefKey {
+ parent: None,
+ disambiguated_data: DisambiguatedDefPathData {
+ data: DefPathData::CrateRoot,
+ disambiguator: 0,
+ },
+ };
+
+ let root_index = self.key_to_index
+ .get(&root_key)
+ .expect("no root key?")
+ .clone();
+
+ debug!("retrace_path: root_index={:?}", root_index);
+
+ let mut index = root_index;
+ for data in path_data {
+ let key = DefKey { parent: Some(index), disambiguated_data: data.clone() };
+ debug!("retrace_path: key={:?}", key);
+ match self.key_to_index.get(&key) {
+ Some(&i) => index = i,
+ None => return None,
+ }
+ }
+
+ Some(index)
+ }
}
use hir::def::{self, Def};
use hir::def_id::{CrateNum, DefId, DefIndex};
use hir::map as hir_map;
-use hir::map::definitions::{Definitions, DefKey};
+use hir::map::definitions::{Definitions, DefKey, DisambiguatedDefPathData};
use hir::svh::Svh;
use middle::lang_items;
use ty::{self, Ty, TyCtxt};
fn is_no_builtins(&self, cnum: CrateNum) -> bool;
// resolve
- fn def_index_for_def_key(&self,
- cnum: CrateNum,
- def: DefKey)
- -> Option<DefIndex>;
- fn def_key(&self, def: DefId) -> hir_map::DefKey;
+ fn retrace_path(&self,
+ cnum: CrateNum,
+ path_data: &[DisambiguatedDefPathData])
+ -> Option<DefId>;
+ fn def_key(&self, def: DefId) -> DefKey;
fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath>;
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
fn item_children(&self, did: DefId) -> Vec<def::Export>;
// trait info
fn implementations_of_trait(&self, filter: Option<DefId>) -> Vec<DefId> { vec![] }
- fn def_index_for_def_key(&self,
- cnum: CrateNum,
- def: DefKey)
- -> Option<DefIndex> {
- None
- }
// impl info
fn associated_item_def_ids(&self, def_id: DefId) -> Vec<DefId>
fn is_no_builtins(&self, cnum: CrateNum) -> bool { bug!("is_no_builtins") }
// resolve
- fn def_key(&self, def: DefId) -> hir_map::DefKey { bug!("def_key") }
+ fn retrace_path(&self,
+ cnum: CrateNum,
+ path_data: &[DisambiguatedDefPathData])
+ -> Option<DefId> {
+ None
+ }
+
+ fn def_key(&self, def: DefId) -> DefKey { bug!("def_key") }
fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath> {
bug!("relative_def_path")
}
use middle;
use hir::TraitMap;
use hir::def::Def;
-use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
+use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use hir::map as ast_map;
-use hir::map::{DefKey, DefPathData, DisambiguatedDefPathData};
+use hir::map::DisambiguatedDefPathData;
use middle::free_region::FreeRegionMap;
use middle::region::RegionMaps;
use middle::resolve_lifetime;
}
}
- /// Given a def-key `key` and a crate `krate`, finds the def-index
- /// that `krate` assigned to `key`. This `DefIndex` will always be
- /// relative to `krate`.
- ///
- /// Returns `None` if there is no `DefIndex` with that key.
- pub fn def_index_for_def_key(self, krate: CrateNum, key: DefKey)
- -> Option<DefIndex> {
- if krate == LOCAL_CRATE {
- self.map.def_index_for_def_key(key)
- } else {
- self.sess.cstore.def_index_for_def_key(krate, key)
- }
- }
-
pub fn retrace_path(self,
krate: CrateNum,
path_data: &[DisambiguatedDefPathData])
-> Option<DefId> {
debug!("retrace_path(path={:?}, krate={:?})", path_data, self.crate_name(krate));
- let root_key = DefKey {
- parent: None,
- disambiguated_data: DisambiguatedDefPathData {
- data: DefPathData::CrateRoot,
- disambiguator: 0,
- },
- };
-
- let root_index = self.def_index_for_def_key(krate, root_key)
- .expect("no root key?");
-
- debug!("retrace_path: root_index={:?}", root_index);
-
- let mut index = root_index;
- for data in path_data {
- let key = DefKey { parent: Some(index), disambiguated_data: data.clone() };
- debug!("retrace_path: key={:?}", key);
- match self.def_index_for_def_key(krate, key) {
- Some(i) => index = i,
- None => return None,
- }
+ if krate == LOCAL_CRATE {
+ self.map
+ .definitions()
+ .def_path_table()
+ .retrace_path(path_data)
+ .map(|def_index| DefId { krate: krate, index: def_index })
+ } else {
+ self.sess.cstore.retrace_path(krate, path_data)
}
-
- Some(DefId { krate: krate, index: index })
}
pub fn type_parameter_def(self,
use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc::dep_graph::DepNode;
-use rustc::hir::map as hir_map;
-use rustc::hir::map::DefKey;
+use rustc::hir::map::{DefKey, DefPath, DisambiguatedDefPathData};
use rustc::mir::Mir;
use rustc::util::nodemap::{NodeSet, DefIdMap};
use rustc_back::PanicStrategy;
self.get_crate_data(cnum).is_no_builtins()
}
- fn def_index_for_def_key(&self,
- cnum: CrateNum,
- def: DefKey)
- -> Option<DefIndex> {
+ fn retrace_path(&self,
+ cnum: CrateNum,
+ path: &[DisambiguatedDefPathData])
+ -> Option<DefId> {
let cdata = self.get_crate_data(cnum);
- cdata.def_path_table.def_index_for_def_key(&def)
+ cdata.def_path_table
+ .retrace_path(&path)
+ .map(|index| DefId { krate: cnum, index: index })
}
/// Returns the `DefKey` for a given `DefId`. This indicates the
/// parent `DefId` as well as some idea of what kind of data the
/// `DefId` refers to.
- fn def_key(&self, def: DefId) -> hir_map::DefKey {
+ fn def_key(&self, def: DefId) -> DefKey {
// Note: loading the def-key (or def-path) for a def-id is not
// a *read* of its metadata. This is because the def-id is
// really just an interned shorthand for a def-path, which is the
self.get_crate_data(def.krate).def_key(def.index)
}
- fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath> {
+ fn relative_def_path(&self, def: DefId) -> Option<DefPath> {
// See `Note` above in `def_key()` for why this read is
// commented out:
//
projects / rust.git / commitdiff