mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactoring

Browse Source
This commit is contained in:
Nick Cameron 2016-04-14 17:24:30 +12:00
parent 84c3f898f9
commit 0c37d4bb1d
3 changed files with 112 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
src/librustc/hir/map/collector.rs
View File

@ -70,6 +70,13 @@ impl<'ast> NodeCollector<'ast> {
let entry = MapEntry::from_node(self.parent_node, node);
self.insert_entry(id, entry);
}
fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_id: NodeId, f: F) {
let parent_node = self.parent_node;
self.parent_node = parent_id;
f(self);
self.parent_node = parent_node;
}
}
impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
@ -86,51 +93,48 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
self.insert(i.id, NodeItem(i));
let parent_node = self.parent_node;
self.parent_node = i.id;
match i.node {
ItemEnum(ref enum_definition, _) => {
for v in &enum_definition.variants {
self.insert(v.node.data.id(), NodeVariant(v));
}
}
ItemStruct(ref struct_def, _) => {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
self.insert(struct_def.id(), NodeStructCtor(struct_def));
}
}
ItemTrait(_, _, ref bounds, _) => {
for b in bounds.iter() {
if let TraitTyParamBound(ref t, TraitBoundModifier::None) = *b {
self.insert(t.trait_ref.ref_id, NodeItem(i));
self.with_parent(i.id, |this| {
match i.node {
ItemEnum(ref enum_definition, _) => {
for v in &enum_definition.variants {
this.insert(v.node.data.id(), NodeVariant(v));
}
}
}
ItemUse(ref view_path) => {
match view_path.node {
ViewPathList(_, ref paths) => {
for path in paths {
self.insert(path.node.id(), NodeItem(i));
ItemStruct(ref struct_def, _) => {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
this.insert(struct_def.id(), NodeStructCtor(struct_def));
}
}
ItemTrait(_, _, ref bounds, _) => {
for b in bounds.iter() {
if let TraitTyParamBound(ref t, TraitBoundModifier::None) = *b {
this.insert(t.trait_ref.ref_id, NodeItem(i));
}
}
_ => ()
}
ItemUse(ref view_path) => {
match view_path.node {
ViewPathList(_, ref paths) => {
for path in paths {
this.insert(path.node.id(), NodeItem(i));
}
}
_ => ()
}
}
_ => {}
}
_ => {}
}
intravisit::walk_item(self, i);
self.parent_node = parent_node;
intravisit::walk_item(this, i);
});
}
fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {
self.insert(foreign_item.id, NodeForeignItem(foreign_item));
let parent_node = self.parent_node;
self.parent_node = foreign_item.id;
intravisit::walk_foreign_item(self, foreign_item);
self.parent_node = parent_node;
self.with_parent(foreign_item.id, |this| {
intravisit::walk_foreign_item(this, foreign_item);
});
}
fn visit_generics(&mut self, generics: &'ast Generics) {
@ -144,50 +148,42 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
fn visit_trait_item(&mut self, ti: &'ast TraitItem) {
self.insert(ti.id, NodeTraitItem(ti));
let parent_node = self.parent_node;
self.parent_node = ti.id;
intravisit::walk_trait_item(self, ti);
self.parent_node = parent_node;
self.with_parent(ti.id, |this| {
intravisit::walk_trait_item(this, ti);
});
}
fn visit_impl_item(&mut self, ii: &'ast ImplItem) {
self.insert(ii.id, NodeImplItem(ii));
let parent_node = self.parent_node;
self.parent_node = ii.id;
intravisit::walk_impl_item(self, ii);
self.parent_node = parent_node;
self.with_parent(ii.id, |this| {
intravisit::walk_impl_item(this, ii);
});
}
fn visit_pat(&mut self, pat: &'ast Pat) {
self.insert(pat.id, NodeLocal(pat));
let parent_node = self.parent_node;
self.parent_node = pat.id;
intravisit::walk_pat(self, pat);
self.parent_node = parent_node;
self.with_parent(pat.id, |this| {
intravisit::walk_pat(this, pat);
});
}
fn visit_expr(&mut self, expr: &'ast Expr) {
self.insert(expr.id, NodeExpr(expr));
let parent_node = self.parent_node;
self.parent_node = expr.id;
intravisit::walk_expr(self, expr);
self.parent_node = parent_node;
self.with_parent(expr.id, |this| {
intravisit::walk_expr(this, expr);
});
}
fn visit_stmt(&mut self, stmt: &'ast Stmt) {
let id = stmt.node.id();
self.insert(id, NodeStmt(stmt));
let parent_node = self.parent_node;
self.parent_node = id;
intravisit::walk_stmt(self, stmt);
self.parent_node = parent_node;
self.with_parent(id, |this| {
intravisit::walk_stmt(this, stmt);
});
}
fn visit_fn(&mut self, fk: intravisit::FnKind<'ast>, fd: &'ast FnDecl,
@ -198,10 +194,9 @@ impl<'ast> Visitor<'ast> for NodeCollector<'ast> {
fn visit_block(&mut self, block: &'ast Block) {
self.insert(block.id, NodeBlock(block));
let parent_node = self.parent_node;
self.parent_node = block.id;
intravisit::walk_block(self, block);
self.parent_node = parent_node;
self.with_parent(block.id, |this| {
intravisit::walk_block(this, block);
});
}
fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) {

130
src/librustc/hir/map/def_collector.rs
View File

@ -16,16 +16,14 @@ use syntax::ast::*;
use syntax::visit;
/// Creates def ids for nodes in the HIR.
pub struct DefCollector<'ast> {
pub krate: &'ast Crate,
pub struct DefCollector {
pub definitions: Definitions,
pub parent_def: Option<DefIndex>,
}
impl<'ast> DefCollector<'ast> {
pub fn root(krate: &'ast Crate) -> DefCollector<'ast> {
impl DefCollector {
pub fn root() -> DefCollector {
let mut collector = DefCollector {
krate: krate,
definitions: Definitions::new(),
parent_def: None,
};
@ -37,14 +35,12 @@ impl<'ast> DefCollector<'ast> {
collector
}
pub fn extend(krate: &'ast Crate,
parent_node: NodeId,
pub fn extend(parent_node: NodeId,
parent_def_path: DefPath,
parent_def_id: DefId,
definitions: Definitions)
-> DefCollector<'ast> {
-> DefCollector {
let mut collector = DefCollector {
krate: krate,
parent_def: None,
definitions: definitions,
};
@ -78,9 +74,16 @@ impl<'ast> DefCollector<'ast> {
-> DefIndex {
self.definitions.create_def_with_parent(parent, node_id, data)
}
fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: DefIndex, f: F) {
let parent = self.parent_def;
self.parent_def = Some(parent_def);
f(self);
self.parent_def = parent;
}
}
impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
impl<'ast> visit::Visitor<'ast> for DefCollector {
fn visit_item(&mut self, i: &'ast Item) {
debug!("visit_item: {:?}", i);
@ -98,60 +101,55 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
ItemKind::Mac(..) => DefPathData::MacroDef(i.ident.name),
ItemKind::Use(..) => DefPathData::Misc,
};
let def = self.create_def(i.id, def_data);
let parent_def = self.parent_def;
self.parent_def = Some(def);
self.with_parent(def, |this| {
match i.node {
ItemKind::Enum(ref enum_definition, _) => {
for v in &enum_definition.variants {
let variant_def_index =
this.create_def(v.node.data.id(),
DefPathData::EnumVariant(v.node.name.name));
match i.node {
ItemKind::Enum(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.name));
for field in v.node.data.fields() {
if let Some(ident) = field.ident {
self.create_def_with_parent(Some(variant_def_index),
field.id,
DefPathData::Field(ident.name));
for field in v.node.data.fields() {
if let Some(ident) = field.ident {
this.create_def_with_parent(Some(variant_def_index),
field.id,
DefPathData::Field(ident.name));
}
}
}
}
}
ItemKind::Struct(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);
}
ItemKind::Struct(ref struct_def, _) => {
// If this is a tuple-like struct, register the constructor.
if !struct_def.is_struct() {
this.create_def(struct_def.id(),
DefPathData::StructCtor);
}
for field in struct_def.fields() {
if let Some(ident) = field.ident {
self.create_def(field.id, DefPathData::Field(ident.name));
for field in struct_def.fields() {
if let Some(ident) = field.ident {
this.create_def(field.id, DefPathData::Field(ident.name));
}
}
}
_ => {}
}
_ => {}
}
visit::walk_item(self, i);
self.parent_def = parent_def;
visit::walk_item(this, i);
});
}
fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {
let def = self.create_def(foreign_item.id, DefPathData::ValueNs(foreign_item.ident.name));
let parent_def = self.parent_def;
self.parent_def = Some(def);
visit::walk_foreign_item(self, foreign_item);
self.parent_def = parent_def;
self.with_parent(def, |this| {
visit::walk_foreign_item(this, foreign_item);
});
}
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.ident.name));
self.create_def(ty_param.id, DefPathData::TypeParam(ty_param.ident.name));
}
visit::walk_generics(self, generics);
@ -165,20 +163,13 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
};
let def = self.create_def(ti.id, def_data);
let parent_def = self.parent_def;
self.parent_def = Some(def);
match ti.node {
TraitItemKind::Const(_, Some(ref expr)) => {
self.create_def(expr.id, DefPathData::Initializer);
self.with_parent(def, |this| {
if let TraitItemKind::Const(_, Some(ref expr)) = ti.node {
this.create_def(expr.id, DefPathData::Initializer);
}
_ => { }
}
visit::walk_trait_item(self, ti);
self.parent_def = parent_def;
visit::walk_trait_item(this, ti);
});
}
fn visit_impl_item(&mut self, ii: &'ast ImplItem) {
@ -190,20 +181,13 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
};
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);
self.with_parent(def, |this| {
if let ImplItemKind::Const(_, ref expr) = ii.node {
this.create_def(expr.id, DefPathData::Initializer);
}
_ => { }
}
visit::walk_impl_item(self, ii);
self.parent_def = parent_def;
visit::walk_impl_item(this, ii);
});
}
fn visit_pat(&mut self, pat: &'ast Pat) {
@ -234,14 +218,6 @@ impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
self.parent_def = parent_def;
}
fn visit_stmt(&mut self, stmt: &'ast Stmt) {
visit::walk_stmt(self, stmt);
}
fn visit_block(&mut self, block: &'ast Block) {
visit::walk_block(self, block);
}
fn visit_lifetime_def(&mut self, def: &'ast LifetimeDef) {
self.create_def(def.lifetime.id, DefPathData::LifetimeDef(def.lifetime.name));
}

5
src/librustc/hir/map/mod.rs
View File

@ -784,7 +784,7 @@ impl<F: FoldOps> Folder for IdAndSpanUpdater<F> {
}
pub fn collect_definitions<'ast>(krate: &'ast ast::Crate) -> Definitions {
let mut def_collector = DefCollector::root(krate);
let mut def_collector = DefCollector::root();
visit::walk_crate(&mut def_collector, krate);
def_collector.definitions
}
@ -845,8 +845,7 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
// TODO need to save defs in metadata :-(
// let defs = mem::replace(&mut *map.definitions.borrow_mut(), Definitions::new());
// let mut def_collector = DefCollector::extend(map.krate(),
// ii_parent_id,
// let mut def_collector = DefCollector::extend(ii_parent_id,
// parent_def_path.clone(),
// parent_def_id,
// defs);