hir_id to accesslevel in resolve and applied in privacy

Author: lambinoo

compiler/rustc_middle/src/ty/context.rs

@@ -1161,8 +1161,8 @@ impl<'tcx> TyCtxt<'tcx> {
         )
     }
 
-    pub fn get_resolver_access_level(self, def_id: DefId) -> Option<AccessLevel> {
-        self.gcx.untracked_resolutions.access_levels.get(&def_id).copied()
+    pub fn get_resolver_access_level(self, hir_id: HirId) -> Option<AccessLevel> {
+        self.gcx.untracked_resolutions.access_levels.get(&hir_id).copied()
     }
 
     pub fn lift<T: Lift<'tcx>>(self, value: T) -> Option<T::Lifted> {

compiler/rustc_middle/src/ty/mod.rs

@@ -119,7 +119,7 @@ pub struct ResolverOutputs {
     pub definitions: rustc_hir::definitions::Definitions,
     pub cstore: Box<CrateStoreDyn>,
     pub visibilities: FxHashMap<LocalDefId, Visibility>,
-    pub access_levels: FxHashMap<DefId, AccessLevel>,
+    pub access_levels: FxHashMap<HirId, AccessLevel>,
     pub extern_crate_map: FxHashMap<LocalDefId, CrateNum>,
     pub maybe_unused_trait_imports: FxHashSet<LocalDefId>,
     pub maybe_unused_extern_crates: Vec<(LocalDefId, Span)>,

compiler/rustc_privacy/src/lib.rs

@@ -681,9 +681,13 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
             // all of the items of a mod in `visit_mod` looking for use statements, we handle
             // making sure that intermediate use statements have their visibilities updated here.
             hir::ItemKind::Use(ref path, ..) => {
-                tracing::trace!("item: def_id={:?}, last_segment: {:?}", item.def_id.to_def_id(), path.segments.last());
+                tracing::trace!(
+                    "item: def_id={:?}, last_segment: {:?}",
+                    item.def_id.to_def_id(),
+                    path.segments.last()
+                );
                 if item.vis.node.is_pub() {
-                    let access_level = self.tcx.get_resolver_access_level(item.def_id.to_def_id());
+                    let access_level = self.tcx.get_resolver_access_level(item.hir_id());
                     self.update(item.hir_id(), access_level);
                 }
             }

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -469,7 +469,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
             prefix.is_empty() || prefix.len() == 1 && prefix[0].ident.name == kw::PathRoot
         };
         match use_tree.kind {
-            ast::UseTreeKind::Simple(rename, ..) => {
+            ast::UseTreeKind::Simple(rename, id1, id2) => {
                 let mut ident = use_tree.ident();
                 let mut module_path = prefix;
                 let mut source = module_path.pop().unwrap();
@@ -579,7 +579,9 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
                     },
                     type_ns_only,
                     nested,
+                    additional_ids: (id1, id2),
                 };
+
                 self.add_import(
                     module_path,
                     kind,

compiler/rustc_resolve/src/imports.rs

@@ -50,6 +50,7 @@ pub enum ImportKind<'a> {
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
         nested: bool,
+        additional_ids: (NodeId, NodeId),
     },
     Glob {
         is_prelude: bool,
@@ -838,7 +839,10 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
                         import.span,
                     );
                     import.vis.set(orig_vis);
-                    tracing::trace!("resolve_import: determinacy: {:?}", binding.map(|binding| binding.span));
+                    tracing::trace!(
+                        "resolve_import: determinacy: {:?}",
+                        binding.map(|binding| binding.span)
+                    );
                     source_bindings[ns].set(binding);
                 } else {
                     return;

compiler/rustc_resolve/src/lib.rs

@@ -1034,7 +1034,7 @@ pub struct Resolver<'a> {
 
     main_def: Option<MainDefinition>,
 
-    node_privacy: FxHashMap<DefId, AccessLevel>
+    node_privacy: FxHashMap<HirId, AccessLevel>,
 }
 
 /// Nothing really interesting here; it just provides memory for the rest of the crate.
@@ -1535,40 +1535,64 @@ impl<'a> Resolver<'a> {
 
         if let Some(def_id) = root.def_id() {
             if let Some(exports) = self.export_map.get(&def_id.expect_local()).cloned() {
-                tracing::trace!("exports={:?}", exports);
-                let public_exports = exports.iter().filter(|ex| ex.vis == Visibility::Public).collect::<Vec<_>>();
+                let public_exports =
+                    exports.iter().filter(|ex| ex.vis == Visibility::Public).collect::<Vec<_>>();
                 for export in public_exports.into_iter() {
-                    self.per_ns(|this, ns| {
-                        let new_key = this.new_key(export.ident, ns);
-                        let name_res = this.resolution(root, new_key);
+                    if let Some(ns) = export.res.ns() {
+                        let key = self.new_key(export.ident, ns);
+                        let name_res = self.resolution(root, key);
                         if let Some(binding) = name_res.borrow().binding() {
-                            this.recursive_define_access_level(binding, AccessLevel::Public, 30);
+                            self.recursive_define_access_level(binding, AccessLevel::Public, 30);
                         }
-                    });
+                    }
                 }
             }
         }
 
         tracing::info!("node_privacy: {:#?}", self.node_privacy);
     }
 
-    fn recursive_define_access_level(&mut self, binding: &NameBinding<'a>, access_level: AccessLevel, max_recurse: usize) {
+    fn recursive_define_access_level(
+        &mut self,
+        binding: &NameBinding<'a>,
+        access_level: AccessLevel,
+        max_recurse: usize,
+    ) {
         // Is this useful in case of very very veryyyyyy deep nesting?
         if max_recurse == 0 {
             return;
         }
 
         if let NameBindingKind::Import { binding, import, .. } = binding.kind {
-            let def_id = self.opt_local_def_id(import.id).map(|local_def_id| local_def_id.to_def_id());
-            if let Some(def_id) = def_id {
-                tracing::trace!("binding found! import.id={:?} def_id={:?}", import.id, def_id);
-                self.node_privacy.insert(def_id, access_level);
-            }
+            tracing::trace!(
+                "binding found! import.id={:?}, import.root_id={:?}, res={:?}",
+                import.id,
+                import.root_id,
+                binding.res()
+            );
+            self.mark_node_with_access_level(import.id, access_level);
+            match import.kind {
+                ImportKind::Single { additional_ids, .. } => {
+                    self.mark_node_with_access_level(additional_ids.0, access_level);
+                    self.mark_node_with_access_level(additional_ids.1, access_level);
+                }
+                _ => {}
+            };
 
             self.recursive_define_access_level(binding, AccessLevel::Exported, max_recurse - 1);
         }
     }
 
+    fn mark_node_with_access_level(&mut self, node_id: NodeId, access_level: AccessLevel) -> bool {
+        if let Some(local_def_id) = self.opt_local_def_id(node_id) {
+            if let Some(hir_id) = self.definitions().def_id_to_hir_id.get(local_def_id.to_def_id()) {
+                self.node_privacy.insert(hir_id, access_level).is_none();
+            }
+        } else {
+            false
+        }
+    }
+
     pub fn traits_in_scope(
         &mut self,
         current_trait: Option<Module<'a>>,