def_collector and crate reader operate on AST instead of HIR

And move extern crate reading earlier in the driver

Author: Nick Cameron

src/librustc/hir/map/def_collector.rs

@@ -10,10 +10,10 @@
 
 use super::*;
 
-use hir::*;
-use hir::intravisit::Visitor;
 use hir::def_id::{CRATE_DEF_INDEX, DefId, DefIndex};
-use syntax::ast::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
+
+use syntax::ast::*;
+use syntax::visit;
 
 /// Creates def ids for nodes in the HIR.
 pub struct DefCollector<'ast> {
@@ -80,31 +80,23 @@ impl<'ast> DefCollector<'ast> {
     }
 }
 
-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))
-    }
-
+impl<'ast> visit::Visitor<'ast> for DefCollector<'ast> {
     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(..) =>
+            ItemKind::DefaultImpl(..) | ItemKind::Impl(..) =>
                 DefPathData::Impl,
-            ItemEnum(..) | ItemStruct(..) | ItemTrait(..) |
-            ItemExternCrate(..) | ItemMod(..) | ItemForeignMod(..) |
-            ItemTy(..) =>
-                DefPathData::TypeNs(i.name),
-            ItemStatic(..) | ItemConst(..) | ItemFn(..) =>
-                DefPathData::ValueNs(i.name),
-            ItemUse(..) =>
-                DefPathData::Misc,
+            ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Trait(..) |
+            ItemKind::ExternCrate(..) | ItemKind::Mod(..) | ItemKind::ForeignMod(..) |
+            ItemKind::Ty(..) =>
+                DefPathData::TypeNs(i.ident.name),
+            ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) =>
+                DefPathData::ValueNs(i.ident.name),
+            ItemKind::Mac(..) => DefPathData::MacroDef(i.ident.name),
+            ItemKind::Use(..) => DefPathData::Misc,
         };
 
         let def = self.create_def(i.id, def_data);
@@ -113,59 +105,63 @@ impl<'ast> Visitor<'ast> for DefCollector<'ast> {
         self.parent_def = Some(def);
 
         match i.node {
-            ItemEnum(ref enum_definition, _) => {
+            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));
+                                        DefPathData::EnumVariant(v.node.name.name));
 
                     for field in v.node.data.fields() {
-                        self.create_def_with_parent(
-                            Some(variant_def_index),
-                            field.id,
-                            DefPathData::Field(field.name));
+                        if let Some(ident) = field.ident {
+                            self.create_def_with_parent(Some(variant_def_index),
+                                                        field.id,
+                                                        DefPathData::Field(ident.name));
+                        }
                     }
                 }
             }
-            ItemStruct(ref struct_def, _) => {
+            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);
                 }
 
                 for field in struct_def.fields() {
-                    self.create_def(field.id, DefPathData::Field(field.name));
+                    if let Some(ident) = field.ident {
+                        self.create_def(field.id, DefPathData::Field(ident.name));
+                    }
                 }
             }
             _ => {}
         }
-        intravisit::walk_item(self, i);
+        visit::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 def = self.create_def(foreign_item.id, DefPathData::ValueNs(foreign_item.ident.name));
 
         let parent_def = self.parent_def;
         self.parent_def = Some(def);
-        intravisit::walk_foreign_item(self, foreign_item);
+        visit::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));
+                            DefPathData::TypeParam(ty_param.ident.name));
         }
 
-        intravisit::walk_generics(self, generics);
+        visit::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),
+            TraitItemKind::Method(..) | TraitItemKind::Const(..) =>
+                DefPathData::ValueNs(ti.ident.name),
+            TraitItemKind::Type(..) => DefPathData::TypeNs(ti.ident.name),
         };
 
         let def = self.create_def(ti.id, def_data);
@@ -174,21 +170,23 @@ impl<'ast> Visitor<'ast> for DefCollector<'ast> {
         self.parent_def = Some(def);
 
         match ti.node {
-            ConstTraitItem(_, Some(ref expr)) => {
+            TraitItemKind::Const(_, Some(ref expr)) => {
                 self.create_def(expr.id, DefPathData::Initializer);
             }
             _ => { }
         }
 
-        intravisit::walk_trait_item(self, ti);
+        visit::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),
+            ImplItemKind::Method(..) | ImplItemKind::Const(..) =>
+                DefPathData::ValueNs(ii.ident.name),
+            ImplItemKind::Type(..) => DefPathData::TypeNs(ii.ident.name),
+            ImplItemKind::Macro(..) => DefPathData::MacroDef(ii.ident.name),
         };
 
         let def = self.create_def(ii.id, def_data);
@@ -203,7 +201,7 @@ impl<'ast> Visitor<'ast> for DefCollector<'ast> {
             _ => { }
         }
 
-        intravisit::walk_impl_item(self, ii);
+        visit::walk_impl_item(self, ii);
 
         self.parent_def = parent_def;
     }
@@ -220,35 +218,35 @@ impl<'ast> Visitor<'ast> for DefCollector<'ast> {
             self.parent_def = Some(def);
         }
 
-        intravisit::walk_pat(self, pat);
+        visit::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 {
+        if let ExprKind::Closure(..) = expr.node {
             let def = self.create_def(expr.id, DefPathData::ClosureExpr);
             self.parent_def = Some(def);
         }
 
-        intravisit::walk_expr(self, expr);
+        visit::walk_expr(self, expr);
         self.parent_def = parent_def;
     }
 
     fn visit_stmt(&mut self, stmt: &'ast Stmt) {
-        intravisit::walk_stmt(self, stmt);
+        visit::walk_stmt(self, stmt);
     }
 
     fn visit_block(&mut self, block: &'ast Block) {
-        intravisit::walk_block(self, 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));
     }
 
     fn visit_macro_def(&mut self, macro_def: &'ast MacroDef) {
-        self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.name));
+        self.create_def(macro_def.id, DefPathData::MacroDef(macro_def.ident.name));
     }
 }

src/librustc/hir/map/mod.rs

@@ -22,9 +22,10 @@ use middle::cstore::InlinedItem as II;
 use hir::def_id::{CRATE_DEF_INDEX, DefId};
 
 use syntax::abi::Abi;
-use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID};
+use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID, };
 use syntax::attr::ThinAttributesExt;
 use syntax::codemap::{Span, Spanned};
+use syntax::visit;
 
 use hir::*;
 use hir::fold::Folder;
@@ -782,10 +783,10 @@ impl<F: FoldOps> Folder for IdAndSpanUpdater<F> {
     }
 }
 
-pub fn collect_definitions<'ast>(forest: &'ast mut Forest) -> Definitions {
-    let mut def_collector = DefCollector::root(&forest.krate);
-    intravisit::walk_crate(&mut def_collector, &forest.krate);
-    def_collector.definitions    
+pub fn collect_definitions<'ast>(krate: &'ast ast::Crate) -> Definitions {
+    let mut def_collector = DefCollector::root(krate);
+    visit::walk_crate(&mut def_collector, krate);
+    def_collector.definitions
 }
 
 pub fn map_crate<'ast>(forest: &'ast mut Forest, definitions: Definitions) -> Map<'ast> {
@@ -842,14 +843,15 @@ pub fn map_decoded_item<'ast, F: FoldOps>(map: &Map<'ast>,
     let ii = map.forest.inlined_items.alloc(ii);
     let ii_parent_id = fld.new_id(DUMMY_NODE_ID);
 
-    let defs = mem::replace(&mut *map.definitions.borrow_mut(), Definitions::new());
-    let mut def_collector = DefCollector::extend(map.krate(),
-                                                 ii_parent_id,
-                                                 parent_def_path.clone(),
-                                                 parent_def_id,
-                                                 defs);
-    ii.visit(&mut def_collector);
-    *map.definitions.borrow_mut() = def_collector.definitions;
+    // 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,
+    //                                              parent_def_path.clone(),
+    //                                              parent_def_id,
+    //                                              defs);
+    // ii.visit(&mut def_collector);
+    // *map.definitions.borrow_mut() = def_collector.definitions;
 
     let mut collector = NodeCollector::extend(map.krate(),
                                               ii,

src/librustc_driver/driver.rs

@@ -122,32 +122,22 @@ pub fn compile_input(sess: &Session,
         let expanded_crate = assign_node_ids(sess, expanded_crate);
         let dep_graph = DepGraph::new(sess.opts.build_dep_graph);
 
-        // TODO
-        // time(sess.time_passes(),
-        //      "external crate/lib resolution",
-        //      || LocalCrateReader::new(sess, &cstore, &defs, &id).read_crates());
-
-        // TODO
-        panic!();
-
-        // TODO CrateMap result
-        // let resolve::CrateMap {
-        //     def_map,
-        //     freevars,
-        //     export_map,
-        //     trait_map,
-        //     glob_map,
-        // } = time(sess.time_passes(),
-        //          "name resolution",
-        //          || resolve::resolve_crate(sess, &hir_map, control.make_glob_map));
+        // Collect defintions for def ids.
+        let defs = time(sess.time_passes(),
+                        "collecting defs",
+                        || hir_map::collect_definitions(&expanded_crate));
+
+        time(sess.time_passes(),
+             "external crate/lib resolution",
+             || LocalCrateReader::new(sess, &cstore, &defs, &expanded_crate, &id)
+                    .read_crates(&dep_graph));
 
         // Lower ast -> hir.
         let lcx = LoweringContext::new(sess, Some(&expanded_crate));
-        let dep_graph = DepGraph::new(sess.opts.build_dep_graph());
-        let mut hir_forest = time(sess.time_passes(),
-                                  "lowering ast -> hir",
-                                  || hir_map::Forest::new(lower_crate(&lcx, &expanded_crate),
-                                                          dep_graph));
+        let hir_forest = &mut time(sess.time_passes(),
+                                   "lowering ast -> hir",
+                                   || hir_map::Forest::new(lower_crate(&lcx, &expanded_crate),
+                                                           dep_graph));
 
         // Discard MTWT tables that aren't required past lowering to HIR.
         if !sess.opts.debugging_opts.keep_mtwt_tables &&
@@ -156,10 +146,6 @@ pub fn compile_input(sess: &Session,
         }
 
         let arenas = ty::CtxtArenas::new();
-        // Collect defintions for def ids.
-        let defs = time(sess.time_passes(),
-                        "collecting defs",
-                        move || hir_map::collect_defs(hir_forest));
 
         // Construct the HIR map
         let hir_map = time(sess.time_passes(),
@@ -201,10 +187,10 @@ pub fn compile_input(sess: &Session,
         };
 
         phase_3_run_analysis_passes(sess,
-                                    &cstore,
                                     hir_map,
                                     &arenas,
                                     &id,
+                                    control.make_glob_map,
                                     |tcx, mir_map, analysis, result| {
             {
                 // Eventually, we will want to track plugins.
@@ -759,10 +745,10 @@ pub fn assign_node_ids(sess: &Session, krate: ast::Crate) -> ast::Crate {
 /// miscellaneous analysis passes on the crate. Return various
 /// structures carrying the results of the analysis.
 pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
-                                               cstore: &CStore,
                                                hir_map: hir_map::Map<'tcx>,
                                                arenas: &'tcx ty::CtxtArenas<'tcx>,
                                                name: &str,
+                                               make_glob_map: resolve::MakeGlobMap,
                                                f: F)
                                                -> Result<R, usize>
     where F: FnOnce(&TyCtxt<'tcx>, Option<MirMap<'tcx>>, ty::CrateAnalysis, CompileResult) -> R
@@ -787,6 +773,16 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
         })
     })?;
 
+    let resolve::CrateMap {
+        def_map,
+        freevars,
+        export_map,
+        trait_map,
+        glob_map,
+    } = time(sess.time_passes(),
+             "name resolution",
+             || resolve::resolve_crate(sess, &hir_map, make_glob_map));
+
     let mut analysis = ty::CrateAnalysis {
         export_map: export_map,
         access_levels: AccessLevels::default(),