resolve: Refactor away record_exports, fixing #4953

src/librustc_privacy/lib.rs

@@ -329,9 +329,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
         // This code is here instead of in visit_item so that the
         // crate module gets processed as well.
         if self.prev_level.is_some() {
-            for export in self.export_map.get(&id).expect("module isn't found in export map") {
-                if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) {
-                    self.update(node_id, Some(AccessLevel::Exported));
+            if let Some(exports) = self.export_map.get(&id) {
+                for export in exports {
+                    if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) {
+                        self.update(node_id, Some(AccessLevel::Exported));
+                    }
                 }
             }
         }

src/librustc_resolve/lib.rs

@@ -101,7 +101,6 @@ use resolve_imports::Shadowable;
 pub mod diagnostics;
 
 mod check_unused;
-mod record_exports;
 mod build_reduced_graph;
 mod resolve_imports;
 
@@ -4014,9 +4013,6 @@ pub fn create_resolver<'a, 'tcx>(session: &'a Session,
     resolve_imports::resolve_imports(&mut resolver);
     session.abort_if_errors();
 
-    record_exports::record(&mut resolver);
-    session.abort_if_errors();
-
     resolver
 }
 

src/librustc_resolve/resolve_imports.rs

@@ -688,6 +688,8 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                             id: directive.id,
                             is_public: directive.is_public
                         };
+
+                        self.add_export(module_, target, &import_resolution[namespace]);
                         *used_public = name_binding.is_public();
                     }
                     UnboundResult => {
@@ -827,6 +829,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                         dest_import_resolution[ns] = ImportResolution {
                             id: id, is_public: is_public, target: Some(target.clone())
                         };
+                        self.add_export(module_, *name, &dest_import_resolution[ns]);
                     }
                     _ => {}
                 }
@@ -919,6 +922,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                             id: id,
                             is_public: is_public
                         };
+                        self.add_export(module_, name, &dest_import_resolution[namespace]);
                     }
                 } else {
                     // FIXME #30159: This is required for backwards compatability.
@@ -935,6 +939,19 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                                                            name);
     }
 
+    fn add_export(&mut self, module: Module<'b>, name: Name, resolution: &ImportResolution<'b>) {
+        if !resolution.is_public { return }
+        let node_id = match module.def_id() {
+            Some(def_id) => self.resolver.ast_map.as_local_node_id(def_id).unwrap(),
+            None => return,
+        };
+        let export = match resolution.target.as_ref().unwrap().binding.def() {
+            Some(def) => Export { name: name, def_id: def.def_id() },
+            None => return,
+        };
+        self.resolver.export_map.entry(node_id).or_insert(Vec::new()).push(export);
+    }
+
     /// Checks that imported names and items don't have the same name.
     fn check_for_conflicting_import(&mut self,
                                     import_resolution: &ImportResolutionPerNamespace,