Fix cross-crate resolution of half-items created by export shadowing

Author: petrochenkov

src/librustc/hir/def.rs

@@ -100,8 +100,8 @@ pub type ExportMap = NodeMap<Vec<Export>>;
 
 #[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct Export {
-    pub name: ast::Name,    // The name of the target.
-    pub def_id: DefId, // The definition of the target.
+    pub name: ast::Name, // The name of the target.
+    pub def: Def, // The definition of the target.
 }
 
 impl CtorKind {

src/librustc_metadata/csearch.rs

@@ -149,7 +149,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         self.dep_graph.read(DepNode::MetaData(def_id));
         let mut result = vec![];
         self.get_crate_data(def_id.krate)
-            .each_child_of_item(def_id.index, |child| result.push(child.def_id));
+            .each_child_of_item(def_id.index, |child| result.push(child.def.def_id()));
         result
     }
 
@@ -566,7 +566,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
 
             let mut bfs_queue = &mut VecDeque::new();
             let mut add_child = |bfs_queue: &mut VecDeque<_>, child: def::Export, parent: DefId| {
-                let child = child.def_id;
+                let child = child.def.def_id();
 
                 if self.visibility(child) != ty::Visibility::Public {
                     return;

src/librustc_metadata/decoder.rs

@@ -670,10 +670,12 @@ impl<'a, 'tcx> CrateMetadata {
                     // FIXME(eddyb) Don't encode these in children.
                     EntryKind::ForeignMod => {
                         for child_index in child.children.decode(self) {
-                            callback(def::Export {
-                                def_id: self.local_def_id(child_index),
-                                name: self.item_name(&self.entry(child_index))
-                            });
+                            if let Some(def) = self.get_def(child_index) {
+                                callback(def::Export {
+                                    def: def,
+                                    name: self.item_name(&self.entry(child_index))
+                                });
+                            }
                         }
                         continue;
                     }
@@ -683,11 +685,26 @@ impl<'a, 'tcx> CrateMetadata {
                 }
 
                 let def_key = child.def_key.decode(self);
-                if let Some(name) = def_key.disambiguated_data.data.get_opt_name() {
-                    callback(def::Export {
-                        def_id: self.local_def_id(child_index),
-                        name: name
-                    });
+                if let (Some(def), Some(name)) = (self.get_def(child_index),
+                                                  def_key.disambiguated_data.data.get_opt_name()) {
+                    callback(def::Export { def: def, name: name });
+                    // For non-reexport structs and variants add their constructors to children.
+                    // Reexport lists automatically contain constructors when necessary.
+                    match def {
+                        Def::Struct(..) => {
+                            if let Some(ctor_def_id) = self.get_struct_ctor_def_id(child_index) {
+                                let vkind = self.get_variant_kind(child_index).unwrap();
+                                let ctor_def = Def::StructCtor(ctor_def_id, vkind.ctor_kind());
+                                callback(def::Export { def: ctor_def, name: name });
+                            }
+                        }
+                        Def::Variant(def_id) => {
+                            let vkind = self.get_variant_kind(child_index).unwrap();
+                            let ctor_def = Def::VariantCtor(def_id, vkind.ctor_kind());
+                            callback(def::Export { def: ctor_def, name: name });
+                        }
+                        _ => {}
+                    }
                 }
             }
         }

src/librustc_metadata/encoder.rs

@@ -406,17 +406,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
     fn encode_struct_ctor(&mut self, (adt_def_id, def_id): (DefId, DefId))
                           -> Entry<'tcx> {
-        let variant = self.tcx.lookup_adt_def(adt_def_id).struct_variant();
+        let tcx = self.tcx;
+        let variant = tcx.lookup_adt_def(adt_def_id).struct_variant();
 
         let data = VariantData {
             kind: variant.kind,
             disr: variant.disr_val.to_u64_unchecked(),
             struct_ctor: Some(def_id.index)
         };
 
+        let struct_id = tcx.map.as_local_node_id(adt_def_id).unwrap();
+        let struct_vis = &tcx.map.expect_item(struct_id).vis;
+
         Entry {
             kind: EntryKind::Struct(self.lazy(&data)),
-            visibility: ty::Visibility::Public,
+            visibility: struct_vis.simplify(),
             def_key: self.encode_def_key(def_id),
             attributes: LazySeq::empty(),
             children: LazySeq::empty(),

src/librustc_privacy/lib.rs

@@ -286,7 +286,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
         if self.prev_level.is_some() {
             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) {
+                    if let Some(node_id) = self.tcx.map.as_local_node_id(export.def.def_id()) {
                         self.update(node_id, Some(AccessLevel::Exported));
                     }
                 }

src/librustc_resolve/build_reduced_graph.rs

@@ -24,7 +24,6 @@ use {resolve_error, resolve_struct_error, ResolutionError};
 use rustc::middle::cstore::LoadedMacroKind;
 use rustc::hir::def::*;
 use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId};
-use rustc::hir::map::DefPathData;
 use rustc::ty;
 
 use std::cell::Cell;
@@ -398,15 +397,9 @@ impl<'b> Resolver<'b> {
     /// Builds the reduced graph for a single item in an external crate.
     fn build_reduced_graph_for_external_crate_def(&mut self, parent: Module<'b>,
                                                   child: Export) {
-        let def_id = child.def_id;
         let name = child.name;
-
-        let def = if let Some(def) = self.session.cstore.describe_def(def_id) {
-            def
-        } else {
-            return;
-        };
-
+        let def = child.def;
+        let def_id = def.def_id();
         let vis = if parent.is_trait() {
             ty::Visibility::Public
         } else {
@@ -424,14 +417,15 @@ impl<'b> Resolver<'b> {
                 debug!("(building reduced graph for external crate) building variant {}", name);
                 // All variants are defined in both type and value namespaces as future-proofing.
                 let vkind = self.session.cstore.variant_kind(def_id).unwrap();
-                let ctor_def = Def::VariantCtor(def_id, vkind.ctor_kind());
                 let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
-                let _ = self.try_define(parent, name, ValueNS, (ctor_def, DUMMY_SP, vis));
                 if vkind == ty::VariantKind::Struct {
                     // Not adding fields for variants as they are not accessed with a self receiver
                     self.structs.insert(def_id, Vec::new());
                 }
             }
+            Def::VariantCtor(..) => {
+                let _ = self.try_define(parent, name, ValueNS, (def, DUMMY_SP, vis));
+            }
             Def::Fn(..) |
             Def::Static(..) |
             Def::Const(..) |
@@ -468,33 +462,25 @@ impl<'b> Resolver<'b> {
                 debug!("(building reduced graph for external crate) building type {}", name);
                 let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
             }
-            Def::Struct(..)
-                if self.session.cstore.def_key(def_id).disambiguated_data.data !=
-                   DefPathData::StructCtor
-                => {
+            Def::Struct(..) => {
                 debug!("(building reduced graph for external crate) building type and value for {}",
                        name);
                 let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
-                if let Some(ctor_def_id) = self.session.cstore.struct_ctor_def_id(def_id) {
-                    let vkind = self.session.cstore.variant_kind(def_id).unwrap();
-                    let ctor_def = Def::StructCtor(ctor_def_id, vkind.ctor_kind());
-                    let _ = self.try_define(parent, name, ValueNS, (ctor_def, DUMMY_SP, vis));
-                }
 
                 // Record the def ID and fields of this struct.
                 let fields = self.session.cstore.struct_field_names(def_id);
                 self.structs.insert(def_id, fields);
             }
+            Def::StructCtor(..) => {
+                let _ = self.try_define(parent, name, ValueNS, (def, DUMMY_SP, vis));
+            }
             Def::Union(_) => {
                 let _ = self.try_define(parent, name, TypeNS, (def, DUMMY_SP, vis));
 
                 // Record the def ID and fields of this union.
                 let fields = self.session.cstore.struct_field_names(def_id);
                 self.structs.insert(def_id, fields);
             }
-            Def::Struct(..) => {}
-            Def::VariantCtor(..) |
-            Def::StructCtor(..) |
             Def::Local(..) |
             Def::PrimTy(..) |
             Def::TyParam(..) |

src/librustc_resolve/resolve_imports.rs

@@ -797,7 +797,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> {
                (binding.is_import() || binding.is_extern_crate()) {
                 let def = binding.def();
                 if def != Def::Err {
-                    reexports.push(Export { name: name, def_id: def.def_id() });
+                    reexports.push(Export { name: name, def: def });
                 }
             }
 

src/librustc_typeck/check/method/suggest.rs

@@ -461,7 +461,7 @@ pub fn all_traits<'a>(ccx: &'a CrateCtxt) -> AllTraits<'a> {
                         return;
                     }
                     for child in ccx.tcx.sess.cstore.item_children(def_id) {
-                        handle_external_def(ccx, traits, external_mods, child.def_id)
+                        handle_external_def(ccx, traits, external_mods, child.def.def_id())
                     }
                 }
                 _ => {}

src/librustdoc/clean/inline.rs

@@ -498,9 +498,10 @@ fn build_module<'a, 'tcx>(cx: &DocContext, tcx: TyCtxt<'a, 'tcx, 'tcx>,
         // visit each node at most once.
         let mut visited = FnvHashSet();
         for item in tcx.sess.cstore.item_children(did) {
-            if tcx.sess.cstore.visibility(item.def_id) == ty::Visibility::Public {
-                if !visited.insert(item.def_id) { continue }
-                if let Some(def) = tcx.sess.cstore.describe_def(item.def_id) {
+            let def_id = item.def.def_id();
+            if tcx.sess.cstore.visibility(def_id) == ty::Visibility::Public {
+                if !visited.insert(def_id) { continue }
+                if let Some(def) = tcx.sess.cstore.describe_def(def_id) {
                     if let Some(i) = try_inline_def(cx, tcx, def) {
                         items.extend(i)
                     }

src/librustdoc/clean/mod.rs

@@ -237,7 +237,7 @@ impl Clean<ExternalCrate> for CrateNum {
         let root = DefId { krate: self.0, index: CRATE_DEF_INDEX };
         cx.tcx_opt().map(|tcx| {
             for item in tcx.sess.cstore.item_children(root) {
-                let attrs = inline::load_attrs(cx, tcx, item.def_id);
+                let attrs = inline::load_attrs(cx, tcx, item.def.def_id());
                 PrimitiveType::find(&attrs).map(|prim| primitives.push(prim));
             }
         });