ImplItem(DefId, &'a hir::ImplItem)
}
-#[derive(Copy, Clone)]
-pub struct ChildItem {
- pub def: Def,
- pub name: ast::Name,
- pub vis: ty::Visibility,
-}
-
#[derive(Copy, Clone, Debug)]
pub struct ExternCrate {
/// def_id of an `extern crate` in the current crate that caused
/// can be accessed.
pub trait CrateStore<'tcx> {
// item info
+ fn describe_def(&self, def: DefId) -> Option<Def>;
fn stability(&self, def: DefId) -> Option<attr::Stability>;
fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>;
fn visibility(&self, def: DefId) -> ty::Visibility;
fn relative_def_path(&self, def: DefId) -> Option<hir_map::DefPath>;
fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>;
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
- fn item_children(&self, did: DefId) -> Vec<ChildItem>;
+ fn item_children(&self, did: DefId) -> Vec<def::Export>;
// misc. metadata
fn maybe_get_item_ast<'a>(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
#[allow(unused_variables)]
impl<'tcx> CrateStore<'tcx> for DummyCrateStore {
// item info
+ fn describe_def(&self, def: DefId) -> Option<Def> { bug!("describe_def") }
fn stability(&self, def: DefId) -> Option<attr::Stability> { bug!("stability") }
fn deprecation(&self, def: DefId) -> Option<attr::Deprecation> { bug!("deprecation") }
fn visibility(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
{ bug!("struct_ctor_def_id") }
fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { bug!("struct_field_names") }
- fn item_children(&self, did: DefId) -> Vec<ChildItem> { bug!("item_children") }
+ fn item_children(&self, did: DefId) -> Vec<def::Export> { bug!("item_children") }
// misc. metadata
fn maybe_get_item_ast<'a>(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
use encoder;
use loader;
-use rustc::middle::cstore::{InlinedItem, CrateStore, CrateSource, ChildItem, ExternCrate};
+use rustc::middle::cstore::{InlinedItem, CrateStore, CrateSource, ExternCrate};
use rustc::middle::cstore::{NativeLibraryKind, LinkMeta, LinkagePreference};
-use rustc::hir::def;
+use rustc::hir::def::{self, Def};
use rustc::middle::lang_items;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX};
use rustc::hir;
impl<'tcx> CrateStore<'tcx> for cstore::CStore {
+ fn describe_def(&self, def: DefId) -> Option<Def> {
+ self.dep_graph.read(DepNode::MetaData(def));
+ self.get_crate_data(def.krate).get_def(def.index)
+ }
+
fn stability(&self, def: DefId) -> Option<attr::Stability> {
self.dep_graph.read(DepNode::MetaData(def));
self.get_crate_data(def.krate).get_stability(def.index)
fn impl_or_trait_items(&self, def_id: DefId) -> Vec<DefId> {
self.dep_graph.read(DepNode::MetaData(def_id));
let mut result = vec![];
- let get_crate_data = &mut |cnum| self.get_crate_data(cnum);
self.get_crate_data(def_id.krate)
- .each_child_of_item(def_id.index, get_crate_data,
- &mut |def, _, _| result.push(def.def_id()));
+ .each_child_of_item(def_id.index, |child| result.push(child.def_id));
result
}
self.get_crate_data(def.krate).get_struct_field_names(def.index)
}
- fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
+ fn item_children(&self, def_id: DefId) -> Vec<def::Export>
{
self.dep_graph.read(DepNode::MetaData(def_id));
let mut result = vec![];
- let get_crate_data = &mut |cnum| self.get_crate_data(cnum);
self.get_crate_data(def_id.krate)
- .each_child_of_item(def_id.index, get_crate_data,
- &mut |def, name, vis| {
- result.push(ChildItem {
- def: def,
- name: name,
- vis: vis
- });
- });
+ .each_child_of_item(def_id.index, |child| result.push(child));
result
}
let mut visible_parent_map = self.visible_parent_map.borrow_mut();
if !visible_parent_map.is_empty() { return visible_parent_map; }
- use rustc::middle::cstore::ChildItem;
use std::collections::vec_deque::VecDeque;
use std::collections::hash_map::Entry;
for cnum in (1 .. self.next_crate_num().as_usize()).map(CrateNum::new) {
}
let mut bfs_queue = &mut VecDeque::new();
- let mut add_child = |bfs_queue: &mut VecDeque<_>, child: ChildItem, parent: DefId| {
- let child = if child.vis == ty::Visibility::Public {
- child.def.def_id()
- } else {
+ let mut add_child = |bfs_queue: &mut VecDeque<_>, child: def::Export, parent: DefId| {
+ let child = child.def_id;
+
+ if self.visibility(child) != ty::Visibility::Public {
return;
- };
+ }
match visible_parent_map.entry(child) {
Entry::Occupied(mut entry) => {
use rustc::hir::intravisit::IdRange;
use rustc::middle::cstore::{InlinedItem, LinkagePreference};
-use rustc::hir::def::Def;
+use rustc::hir::def::{self, Def};
use rustc::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
use rustc::middle::lang_items;
use rustc::ty::{ImplContainer, TraitContainer};
self.maybe_get(doc, item_tag::ty).map(|dcx| dcx.typed(tcx).decode())
}
+ pub fn get_def(&self, index: DefIndex) -> Option<Def> {
+ self.item_family(self.entry(index)).to_def(self.local_def_id(index))
+ }
+
pub fn get_trait_def(&self,
item_id: DefIndex,
tcx: TyCtxt<'a, 'tcx, 'tcx>) -> ty::TraitDef<'tcx> {
}
/// Iterates over each child of the given item.
- pub fn each_child_of_item<F, G>(&self, id: DefIndex,
- mut get_crate_data: &mut G,
- mut callback: &mut F)
- where F: FnMut(Def, ast::Name, ty::Visibility),
- G: FnMut(CrateNum) -> Rc<CrateMetadata>,
+ pub fn each_child_of_item<F>(&self, id: DefIndex, mut callback: F)
+ where F: FnMut(def::Export)
{
// Find the item.
let item_doc = match self.maybe_entry(id) {
};
// Iterate over all children.
- for child_index in dcx.seq::<DefIndex>() {
+ for child_index in dcx.seq() {
// Get the item.
if let Some(child) = self.maybe_entry(child_index) {
// Hand off the item to the callback.
- let family = self.item_family(child);
- if let Family::ForeignMod = family {
- self.each_child_of_item(child_index, get_crate_data, callback);
- } else if let Some(def) = family.to_def(self.local_def_id(child_index)) {
- callback(def, self.item_name(child), self.item_visibility(child));
+ match self.item_family(child) {
+ // FIXME(eddyb) Don't encode these in children.
+ Family::ForeignMod => {
+ for child_index in self.get(child, item_tag::children).seq() {
+ callback(def::Export {
+ def_id: self.local_def_id(child_index),
+ name: self.item_name(self.entry(child_index))
+ });
+ }
+ continue;
+ }
+ Family::Impl | Family::DefaultImpl => continue,
+
+ _ => {}
+ }
+
+ if let Some(name) = self.maybe_item_name(child) {
+ callback(def::Export {
+ def_id: self.local_def_id(child_index),
+ name: name
+ });
}
}
}
_ => return
};
for exp in reexports {
- // This reexport may be in yet another crate.
- let crate_data = if exp.def_id.krate == self.cnum {
- None
- } else {
- Some(get_crate_data(exp.def_id.krate))
- };
- let crate_data = match crate_data {
- Some(ref cdata) => &**cdata,
- None => self
- };
-
- // Get the item.
- if let Some(child) = crate_data.maybe_entry(exp.def_id.index) {
- // Hand off the item to the callback.
- if let Some(def) = self.item_family(child).to_def(exp.def_id) {
- // These items have a public visibility because they're part of
- // a public re-export.
- callback(def, exp.name, ty::Visibility::Public);
- }
- }
+ callback(exp);
}
}
fn encode_struct_ctor(&mut self, ctor_def_id: DefId) {
self.encode_def_key(ctor_def_id);
self.encode_family(Family::Struct);
+ self.encode_visibility(ty::Visibility::Public);
self.encode_bounds_and_type_for_item(ctor_def_id);
self.encode_stability(ctor_def_id);
use Resolver;
use {resolve_error, resolve_struct_error, ResolutionError};
-use rustc::middle::cstore::ChildItem;
use rustc::hir::def::*;
use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
use rustc::hir::map::DefPathData;
}
/// Builds the reduced graph for a single item in an external crate.
- fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'b>, child: ChildItem) {
- let def = child.def;
+ fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'b>,
+ child: Export) {
+ let def_id = child.def_id;
let name = child.name;
- let vis = if parent.is_trait() { ty::Visibility::Public } else { child.vis };
+
+ let def = if let Some(def) = self.session.cstore.describe_def(def_id) {
+ def
+ } else {
+ return;
+ };
+
+ let vis = if parent.is_trait() {
+ ty::Visibility::Public
+ } else {
+ self.session.cstore.visibility(def_id)
+ };
match def {
Def::Mod(_) | Def::Enum(..) => {
name);
let _ = self.try_define(parent, name, ValueNS, (def, DUMMY_SP, vis));
}
- Def::Trait(def_id) => {
+ Def::Trait(_) => {
debug!("(building reduced graph for external crate) building type {}", name);
// If this is a trait, add all the trait item names to the trait
debug!("(building reduced graph for external crate) building type {}", name);
let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
}
- Def::Struct(def_id)
+ Def::Struct(_)
if self.session.cstore.def_key(def_id).disambiguated_data.data !=
DefPathData::StructCtor
=> {
let fields = self.session.cstore.struct_field_names(def_id);
self.structs.insert(def_id, fields);
}
- Def::Union(def_id) => {
+ Def::Union(_) => {
let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
// Record the def ID and fields of this union.
fn handle_external_def(ccx: &CrateCtxt,
traits: &mut AllTraitsVec,
external_mods: &mut FnvHashSet<DefId>,
- def: Def) {
- match def {
- Def::Trait(did) => {
- traits.push(TraitInfo::new(did));
+ def_id: DefId) {
+ match ccx.tcx.sess.cstore.describe_def(def_id) {
+ Some(Def::Trait(_)) => {
+ traits.push(TraitInfo::new(def_id));
}
- Def::Mod(did) => {
- if !external_mods.insert(did) {
+ Some(Def::Mod(_)) => {
+ if !external_mods.insert(def_id) {
return;
}
- for child in ccx.tcx.sess.cstore.item_children(did) {
- handle_external_def(ccx, traits, external_mods, child.def)
+ for child in ccx.tcx.sess.cstore.item_children(def_id) {
+ handle_external_def(ccx, traits, external_mods, child.def_id)
}
}
_ => {}
}
}
for cnum in ccx.tcx.sess.cstore.crates() {
- handle_external_def(ccx, &mut traits, &mut external_mods, Def::Mod(DefId {
+ handle_external_def(ccx, &mut traits, &mut external_mods, DefId {
krate: cnum,
index: CRATE_DEF_INDEX
- }));
+ });
}
*ccx.all_traits.borrow_mut() = Some(traits);
// visit each node at most once.
let mut visited = FnvHashSet();
for item in tcx.sess.cstore.item_children(did) {
- if item.vis == ty::Visibility::Public {
- if !visited.insert(item.def) { continue }
- if let Some(i) = try_inline_def(cx, tcx, item.def) {
- items.extend(i)
+ if tcx.sess.cstore.visibility(item.def_id) == ty::Visibility::Public {
+ if !visited.insert(item.def_id) { continue }
+ if let Some(def) = tcx.sess.cstore.describe_def(item.def_id) {
+ if let Some(i) = try_inline_def(cx, tcx, def) {
+ items.extend(i)
+ }
}
}
}
let root = DefId { krate: self.0, index: CRATE_DEF_INDEX };
cx.tcx_opt().map(|tcx| {
for item in tcx.sess.cstore.item_children(root) {
- let did = match item.def {
- Def::Mod(did) => did,
- _ => continue
- };
- let attrs = inline::load_attrs(cx, tcx, did);
+ let attrs = inline::load_attrs(cx, tcx, item.def_id);
PrimitiveType::find(&attrs).map(|prim| primitives.push(prim));
}
});
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc::middle::cstore::{CrateStore, ChildItem};
+use rustc::middle::cstore::CrateStore;
use rustc::middle::privacy::{AccessLevels, AccessLevel};
use rustc::hir::def::Def;
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
}
}
- pub fn visit_mod(&mut self, did: DefId) {
- for item in self.cstore.item_children(did) {
- match item.def {
- Def::Mod(did) |
- Def::Trait(did) |
- Def::Struct(did) |
- Def::Union(did) |
- Def::Enum(did) |
- Def::TyAlias(did) |
- Def::Fn(did) |
- Def::Method(did) |
- Def::Static(did, _) |
- Def::Const(did) => self.visit_item(did, item),
- _ => {}
- }
+ pub fn visit_mod(&mut self, def_id: DefId) {
+ for item in self.cstore.item_children(def_id) {
+ self.visit_item(item.def_id);
}
}
- fn visit_item(&mut self, did: DefId, item: ChildItem) {
- let inherited_item_level = if item.vis == Visibility::Public {
+ fn visit_item(&mut self, def_id: DefId) {
+ let vis = self.cstore.visibility(def_id);
+ let inherited_item_level = if vis == Visibility::Public {
self.prev_level
} else {
None
};
- let item_level = self.update(did, inherited_item_level);
+ let item_level = self.update(def_id, inherited_item_level);
- if let Def::Mod(did) = item.def {
+ if let Some(Def::Mod(_)) = self.cstore.describe_def(def_id) {
let orig_level = self.prev_level;
self.prev_level = item_level;
- self.visit_mod(did);
+ self.visit_mod(def_id);
self.prev_level = orig_level;
}
}
projects / rust.git / commitdiff