refactoring

Author: Nick Cameron

src/librustc/hir/map/collector.rs

@@ -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));
+        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));
+                    }
                 }
-            }
-            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));
+                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 {
-                        self.insert(t.trait_ref.ref_id, NodeItem(i));
+                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 {
-                            self.insert(path.node.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) {

src/librustc/hir/map/def_collector.rs

@@ -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);
-
-        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));
+        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));
+
+                        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));
     }