Skip to content

Commit

Permalink
Move DefCollector to its own module.
Browse files Browse the repository at this point in the history
  • Loading branch information
@nrc
nrc committed Apr 19, 2016
1 parent f61b404 commit d6bcc04
Show file tree
Hide file tree
Showing 4 changed files with 267 additions and 248 deletions.
248 changes: 3 additions & 245 deletions src/librustc/hir/map/collector.rs
View file
@@ -1,4 +1,4 @@
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// Copyright 2015-2016 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
Expand All @@ -13,10 +13,10 @@ use super::MapEntry::*;

use hir::*;
use hir::intravisit::Visitor;
use hir::def_id::{CRATE_DEF_INDEX, DefId, DefIndex};
use hir::def_id::DefId;
use middle::cstore::InlinedItem;
use std::iter::repeat;
use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
use syntax::ast::{NodeId, CRATE_NODE_ID};
use syntax::codemap::Span;

/// A Visitor that walks over the HIR and collects Node's into a HIR map.
Expand All @@ -26,248 +26,6 @@ pub struct NodeCollector<'ast> {
pub parent_node: NodeId,
}

pub struct DefCollector<'ast> {
pub krate: &'ast Crate,
pub map: &'ast [MapEntry<'ast>],
pub definitions: Definitions,
pub parent_def: Option<DefIndex>,
}

impl<'ast> DefCollector<'ast> {
pub fn root(krate: &'ast Crate, map: &'ast [MapEntry<'ast>]) -> DefCollector<'ast> {
let mut collector = DefCollector {
krate: krate,
map: map,
definitions: Definitions::new(),
parent_def: None,
};
let result = collector.create_def_with_parent(None, CRATE_NODE_ID, DefPathData::CrateRoot);
assert_eq!(result, CRATE_DEF_INDEX);

collector.create_def_with_parent(Some(CRATE_DEF_INDEX), DUMMY_NODE_ID, DefPathData::Misc);

collector
}

pub fn extend(krate: &'ast Crate,
parent_node: NodeId,
parent_def_path: DefPath,
parent_def_id: DefId,
map: &'ast [MapEntry<'ast>],
definitions: Definitions)
-> DefCollector<'ast> {
let mut collector = DefCollector {
krate: krate,
map: map,
parent_def: None,
definitions: definitions,
};

assert_eq!(parent_def_path.krate, parent_def_id.krate);
let root_path = Box::new(InlinedRootPath {
data: parent_def_path.data,
def_id: parent_def_id,
});

let def = collector.create_def(parent_node, DefPathData::InlinedRoot(root_path));
collector.parent_def = Some(def);

collector
}

fn parent_def(&self) -> Option<DefIndex> {
self.parent_def
}

fn create_def(&mut self, node_id: NodeId, data: DefPathData) -> DefIndex {
let parent_def = self.parent_def();
debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def);
self.definitions.create_def_with_parent(parent_def, node_id, data)
}

fn create_def_with_parent(&mut self,
parent: Option<DefIndex>,
node_id: NodeId,
data: DefPathData)
-> DefIndex {
self.definitions.create_def_with_parent(parent, node_id, data)
}
}

impl<'ast> Visitor<'ast> for DefCollector<'ast> {
/// Because we want to track parent items and so forth, enable
/// deep walking so that we walk nested items in the context of
/// their outer items.
fn visit_nested_item(&mut self, item: ItemId) {
debug!("visit_nested_item: {:?}", item);
self.visit_item(self.krate.item(item.id))
}

fn visit_item(&mut self, i: &'ast Item) {
debug!("visit_item: {:?}", i);

// Pick the def data. This need not be unique, but the more
// information we encapsulate into
let def_data = match i.node {
ItemDefaultImpl(..) | ItemImpl(..) =>
DefPathData::Impl,
ItemEnum(..) | ItemStruct(..) | ItemTrait(..) |
ItemExternCrate(..) | ItemForeignMod(..) | ItemTy(..) =>
DefPathData::TypeNs(i.name),
ItemMod(..) =>
DefPathData::Module(i.name),
ItemStatic(..) | ItemConst(..) | ItemFn(..) =>
DefPathData::ValueNs(i.name),
ItemUse(..) =>
DefPathData::Misc,
};

let def = self.create_def(i.id, def_data);

let parent_def = self.parent_def;
self.parent_def = Some(def);

match i.node {
ItemEnum(ref enum_definition, _) => {
for v in &enum_definition.variants {
let variant_def_index =
self.create_def(v.node.data.id(),
DefPathData::EnumVariant(v.node.name));

for field in v.node.data.fields() {
self.create_def_with_parent(
Some(variant_def_index),
field.id,
DefPathData::Field(field.name));
}
}
}
ItemStruct(ref struct_def, _) => {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
self.create_def(struct_def.id(),
DefPathData::StructCtor);
}

for field in struct_def.fields() {
self.create_def(field.id, DefPathData::Field(field.name));
}
}
_ => {}
}
intravisit::walk_item(self, i);
self.parent_def = parent_def;
}

fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {
let def = self.create_def(foreign_item.id, DefPathData::ValueNs(foreign_item.name));

let parent_def = self.parent_def;
self.parent_def = Some(def);
intravisit::walk_foreign_item(self, foreign_item);
self.parent_def = parent_def;
}

fn visit_generics(&mut self, generics: &'ast Generics) {
for ty_param in generics.ty_params.iter() {
self.create_def(ty_param.id,
DefPathData::TypeParam(ty_param.name));
}

intravisit::walk_generics(self, generics);
}

fn visit_trait_item(&mut self, ti: &'ast TraitItem) {
let def_data = match ti.node {
MethodTraitItem(..) | ConstTraitItem(..) => DefPathData::ValueNs(ti.name),
TypeTraitItem(..) => DefPathData::TypeNs(ti.name),
};

let def = self.create_def(ti.id, def_data);

let parent_def = self.parent_def;
self.parent_def = Some(def);

match ti.node {
ConstTraitItem(_, Some(ref expr)) => {
self.create_def(expr.id, DefPathData::Initializer);
}
_ => { }
}

intravisit::walk_trait_item(self, ti);

self.parent_def = parent_def;
}

fn visit_impl_item(&mut self, ii: &'ast ImplItem) {
let def_data = match ii.node {
ImplItemKind::Method(..) | ImplItemKind::Const(..) => DefPathData::ValueNs(ii.name),
ImplItemKind::Type(..) => DefPathData::TypeNs(ii.name),
};

let def = self.create_def(ii.id, def_data);

let parent_def = self.parent_def;
self.parent_def = Some(def);

match ii.node {
ImplItemKind::Const(_, ref expr) => {
self.create_def(expr.id, DefPathData::Initializer);
}
_ => { }
}

intravisit::walk_impl_item(self, ii);

self.parent_def = parent_def;
}

fn visit_pat(&mut self, pat: &'ast Pat) {
let maybe_binding = match pat.node {
PatKind::Ident(_, id, _) => Some(id.node),
_ => None
};

let parent_def = self.parent_def;
if let Some(id) = maybe_binding {
let def = self.create_def(pat.id, DefPathData::Binding(id.name));
self.parent_def = Some(def);
}

intravisit::walk_pat(self, pat);
self.parent_def = parent_def;
}

fn visit_expr(&mut self, expr: &'ast Expr) {
let parent_def = self.parent_def;

if let ExprClosure(..) = expr.node {
let def = self.create_def(expr.id, DefPathData::ClosureExpr);
self.parent_def = Some(def);
}

intravisit::walk_expr(self, expr);
self.parent_def = parent_def;
}

fn visit_stmt(&mut self, stmt: &'ast Stmt) {
intravisit::walk_stmt(self, stmt);
}

fn visit_block(&mut self, block: &'ast Block) {
intravisit::walk_block(self, block);
}

fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) {
self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name));
}

fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) {
self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.name));
}
}

impl<'ast> NodeCollector<'ast> {
pub fn root(krate: &'ast Crate) -> NodeCollector<'ast> {
let mut collector = NodeCollector {
Expand Down

0 comments on commit d6bcc04

Please sign in to comment.