---

yaml
---
r: 274743
b: refs/heads/stable
c: d7734ae
h: refs/heads/master
i:
  274741: f5a5dde
  274739: 51e43bf
  274735: b852af0

Author: jseyfried

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 7000e708252bd9e45f28926d8fd38cc9ec054e57
+refs/heads/stable: d7734aebeca4d2f230bdec631ffce1416740afa5
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/librustc_resolve/resolve_imports.rs

@@ -471,28 +471,19 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
             }
         }
 
-        let value_def_and_priv = {
-            module_.decrement_outstanding_references_for(target, ValueNS);
-
-            // Record what this import resolves to for later uses in documentation,
-            // this may resolve to either a value or a type, but for documentation
-            // purposes it's good enough to just favor one over the other.
-            value_result.success().map(|binding| {
-                let def = binding.def().unwrap();
-                let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
-                (def, last_private)
-            })
-        };
-
-        let type_def_and_priv = {
-            module_.decrement_outstanding_references_for(target, TypeNS);
-
-            type_result.success().map(|binding| {
-                let def = binding.def().unwrap();
-                let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
-                (def, last_private)
-            })
+        // Record what this import resolves to for later uses in documentation,
+        // this may resolve to either a value or a type, but for documentation
+        // purposes it's good enough to just favor one over the other.
+        module_.decrement_outstanding_references_for(target, ValueNS);
+        module_.decrement_outstanding_references_for(target, TypeNS);
+
+        let def_and_priv = |binding: &NameBinding| {
+            let def = binding.def().unwrap();
+            let last_private = if binding.is_public() { lp } else { DependsOn(def.def_id()) };
+            (def, last_private)
         };
+        let value_def_and_priv = value_result.success().map(&def_and_priv);
+        let type_def_and_priv = type_result.success().map(&def_and_priv);
 
         let import_lp = LastImport {
             value_priv: value_def_and_priv.map(|(_, p)| p),
@@ -501,22 +492,13 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
             type_used: Used,
         };
 
-        if let Some((def, _)) = value_def_and_priv {
-            self.resolver.def_map.borrow_mut().insert(directive.id,
-                                                      PathResolution {
-                                                          base_def: def,
-                                                          last_private: import_lp,
-                                                          depth: 0,
-                                                      });
-        }
-        if let Some((def, _)) = type_def_and_priv {
-            self.resolver.def_map.borrow_mut().insert(directive.id,
-                                                      PathResolution {
-                                                          base_def: def,
-                                                          last_private: import_lp,
-                                                          depth: 0,
-                                                      });
-        }
+        let write_path_resolution = |(def, _)| {
+            let path_resolution =
+                PathResolution { base_def: def, last_private: import_lp, depth: 0 };
+            self.resolver.def_map.borrow_mut().insert(directive.id, path_resolution);
+        };
+        value_def_and_priv.map(&write_path_resolution);
+        type_def_and_priv.map(&write_path_resolution);
 
         debug!("(resolving single import) successfully resolved import");
         return Success(());
@@ -575,19 +557,6 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
         return Success(());
     }
 
-    fn add_export(&mut self, module: Module<'b>, name: Name, binding: &NameBinding<'b>) {
-        if !binding.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 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);
-    }
-
     fn define(&mut self,
               parent: Module<'b>,
               name: Name,
@@ -596,8 +565,12 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
         let binding = self.resolver.new_name_binding(binding);
         if let Err(old_binding) = parent.try_define_child(name, ns, binding) {
             self.report_conflict(name, ns, binding, old_binding);
-        } else if binding.is_public() {
-            self.add_export(parent, name, binding);
+        } else if binding.is_public() { // Add to the export map
+            if let (Some(parent_def_id), Some(def)) = (parent.def_id(), binding.def()) {
+                let parent_node_id = self.resolver.ast_map.as_local_node_id(parent_def_id).unwrap();
+                let export = Export { name: name, def_id: def.def_id() };
+                self.resolver.export_map.entry(parent_node_id).or_insert(Vec::new()).push(export);
+            }
         }
     }