Peform def id assignment during expansion.

2 files changed, 48 insertions, 11 deletions

diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index fb9819b72ab..467967a4f33 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -42,7 +42,7 @@ use self::RibKind::*;
 use self::UseLexicalScopeFlag::*;
 use self::ModulePrefixResult::*;
 
-use rustc::hir::map::Definitions;
+use rustc::hir::map::{Definitions, DefCollector};
 use rustc::hir::{self, PrimTy, TyBool, TyChar, TyFloat, TyInt, TyUint, TyStr};
 use rustc::middle::cstore::CrateLoader;
 use rustc::session::Session;
@@ -1188,13 +1188,16 @@ impl<'a> Resolver<'a> {
         let mut module_map = NodeMap();
         module_map.insert(CRATE_NODE_ID, graph_root);
 
+        let mut definitions = Definitions::new();
+        DefCollector::new(&mut definitions).collect_root();
+
         let mut expansion_data = FnvHashMap();
-        expansion_data.insert(0, macros::ExpansionData::default()); // Crate root expansion
+        expansion_data.insert(0, macros::ExpansionData::root()); // Crate root expansion
 
         Resolver {
             session: session,
 
-            definitions: Definitions::new(),
+            definitions: definitions,
             macros_at_scope: FnvHashMap(),
 
             // The outermost module has def ID 0; this is not reflected in the
@@ -1264,6 +1267,13 @@ impl<'a> Resolver<'a> {
 
     /// Entry point to crate resolution.
     pub fn resolve_crate(&mut self, krate: &Crate) {
+        // Collect `DefId`s for exported macro defs.
+        for def in &krate.exported_macros {
+            DefCollector::new(&mut self.definitions).with_parent(CRATE_DEF_INDEX, |collector| {
+                collector.visit_macro_def(def)
+            })
+        }
+
         self.current_module = self.graph_root;
         visit::walk_crate(self, krate);
 
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 3a9fb845190..ebfdc32fabd 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 use Resolver;
+use rustc::hir::def_id::{CRATE_DEF_INDEX, DefIndex};
+use rustc::hir::map::DefCollector;
 use rustc::middle::cstore::LoadedMacro;
 use rustc::util::nodemap::FnvHashMap;
 use std::cell::RefCell;
@@ -27,9 +29,19 @@ use syntax::util::lev_distance::find_best_match_for_name;
 use syntax::visit::{self, Visitor};
 use syntax_pos::Span;
 
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct ExpansionData {
     module: Rc<ModuleData>,
+    def_index: DefIndex,
+}
+
+impl ExpansionData {
+    pub fn root() -> Self {
+        ExpansionData {
+            module: Default::default(),
+            def_index: CRATE_DEF_INDEX,
+        }
+    }
 }
 
 // FIXME(jseyfried): merge with `::ModuleS`.
@@ -46,10 +58,10 @@ impl<'a> base::Resolver for Resolver<'a> {
     }
 
     fn visit_expansion(&mut self, mark: Mark, expansion: &Expansion) {
-        expansion.visit_with(&mut ExpansionVisitor {
-            current_module: self.expansion_data[&mark.as_u32()].module.clone(),
-            resolver: self,
-        });
+        let module = self.expansion_data[&mark.as_u32()].module.clone();
+        let mut visitor = ExpansionVisitor { current_module: module, resolver: self };
+        visitor.collect_def_ids(mark, expansion);
+        expansion.visit_with(&mut visitor);
     }
 
     fn add_macro(&mut self, scope: Mark, mut def: ast::MacroDef) {
@@ -166,9 +178,8 @@ struct ExpansionVisitor<'b, 'a: 'b> {
 
 impl<'a, 'b> ExpansionVisitor<'a, 'b> {
     fn visit_invoc(&mut self, id: ast::NodeId) {
-        self.resolver.expansion_data.insert(id.as_u32(), ExpansionData {
-            module: self.current_module.clone(),
-        });
+        self.resolver.expansion_data.get_mut(&id.as_u32()).unwrap().module =
+            self.current_module.clone();
     }
 
     // does this attribute list contain "macro_use"?
@@ -195,6 +206,22 @@ impl<'a, 'b> ExpansionVisitor<'a, 'b> {
 
         false
     }
+
+    fn collect_def_ids(&mut self, mark: Mark, expansion: &Expansion) {
+        let expansion_data = &mut self.resolver.expansion_data;
+        let module = &self.current_module;
+        let def_index = expansion_data[&mark.as_u32()].def_index;
+        let visit_macro_invoc = &mut |id: ast::NodeId, def_index| {
+            expansion_data.insert(id.as_u32(), ExpansionData {
+                def_index: def_index,
+                module: module.clone(),
+            });
+        };
+
+        let mut def_collector = DefCollector::new(&mut self.resolver.definitions);
+        def_collector.visit_macro_invoc = Some(visit_macro_invoc);
+        def_collector.with_parent(def_index, |def_collector| expansion.visit_with(def_collector));
+    }
 }
 
 macro_rules! method {