Mak DefId to AccessLevel map in resolve for export

hir_id to accesslevel in resolve and applied in privacy
using local def id
removing tracing probes
making function not recursive and adding comments

Author: lambinoo

compiler/rustc_middle/src/ty/context.rs

@@ -8,6 +8,7 @@ use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos};
 use crate::lint::{struct_lint_level, LintDiagnosticBuilder, LintLevelSource};
 use crate::middle;
 use crate::middle::cstore::EncodedMetadata;
+use crate::middle::privacy::AccessLevel;
 use crate::middle::resolve_lifetime::{self, LifetimeScopeForPath, ObjectLifetimeDefault};
 use crate::middle::stability;
 use crate::mir::interpret::{self, AllocId, Allocation, ConstValue, Scalar};
@@ -1160,6 +1161,10 @@ impl<'tcx> TyCtxt<'tcx> {
         )
     }
 
+    pub fn get_resolver_access_level(self, local_def_id: LocalDefId) -> Option<AccessLevel> {
+        self.gcx.untracked_resolutions.access_levels.get(&local_def_id).copied()
+    }
+
     pub fn lift<T: Lift<'tcx>>(self, value: T) -> Option<T::Lifted> {
         value.lift_to_tcx(self)
     }

compiler/rustc_middle/src/ty/mod.rs

@@ -23,6 +23,7 @@ pub use vtable::*;
 use crate::hir::exports::ExportMap;
 use crate::ich::StableHashingContext;
 use crate::middle::cstore::CrateStoreDyn;
+use crate::middle::privacy::AccessLevel;
 use crate::mir::{Body, GeneratorLayout};
 use crate::traits::{self, Reveal};
 use crate::ty;
@@ -118,6 +119,7 @@ pub struct ResolverOutputs {
     pub definitions: rustc_hir::definitions::Definitions,
     pub cstore: Box<CrateStoreDyn>,
     pub visibilities: FxHashMap<LocalDefId, Visibility>,
+    pub access_levels: FxHashMap<LocalDefId, 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

@@ -11,7 +11,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{DefId, LocalDefId, CRATE_DEF_ID, CRATE_DEF_INDEX, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::{self, DeepVisitor, NestedVisitorMap, Visitor};
 use rustc_hir::{AssocItemKind, HirIdSet, Node, PatKind};
 use rustc_middle::bug;
@@ -574,56 +574,6 @@ impl EmbargoVisitor<'tcx> {
             | DefKind::Generator => (),
         }
     }
-
-    /// Given the path segments of a `ItemKind::Use`, then we need
-    /// to update the visibility of the intermediate use so that it isn't linted
-    /// by `unreachable_pub`.
-    ///
-    /// This isn't trivial as `path.res` has the `DefId` of the eventual target
-    /// of the use statement not of the next intermediate use statement.
-    ///
-    /// To do this, consider the last two segments of the path to our intermediate
-    /// use statement. We expect the penultimate segment to be a module and the
-    /// last segment to be the name of the item we are exporting. We can then
-    /// look at the items contained in the module for the use statement with that
-    /// name and update that item's visibility.
-    ///
-    /// FIXME: This solution won't work with glob imports and doesn't respect
-    /// namespaces. See <https://github.com/rust-lang/rust/pull/57922#discussion_r251234202>.
-    fn update_visibility_of_intermediate_use_statements(
-        &mut self,
-        segments: &[hir::PathSegment<'_>],
-    ) {
-        if let [.., module, segment] = segments {
-            if let Some(item) = module
-                .res
-                .and_then(|res| res.mod_def_id())
-                // If the module is `self`, i.e. the current crate,
-                // there will be no corresponding item.
-                .filter(|def_id| def_id.index != CRATE_DEF_INDEX || def_id.krate != LOCAL_CRATE)
-                .and_then(|def_id| {
-                    def_id.as_local().map(|def_id| self.tcx.hir().local_def_id_to_hir_id(def_id))
-                })
-                .map(|module_hir_id| self.tcx.hir().expect_item(module_hir_id))
-            {
-                if let hir::ItemKind::Mod(m) = &item.kind {
-                    for &item_id in m.item_ids {
-                        let item = self.tcx.hir().item(item_id);
-                        if !self.tcx.hygienic_eq(
-                            segment.ident,
-                            item.ident,
-                            item_id.def_id.to_def_id(),
-                        ) {
-                            continue;
-                        }
-                        if let hir::ItemKind::Use(..) = item.kind {
-                            self.update(item.def_id, Some(AccessLevel::Exported));
-                        }
-                    }
-                }
-            }
-        }
-    }
 }
 
 impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
@@ -732,9 +682,10 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
             // Re-exports are handled in `visit_mod`. However, in order to avoid looping over
             // 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, _) => {
-                if item_level.is_some() {
-                    self.update_visibility_of_intermediate_use_statements(path.segments.as_ref());
+            hir::ItemKind::Use(..) => {
+                if item.vis.node.is_pub() {
+                    let access_level = self.tcx.get_resolver_access_level(item.def_id);
+                    self.update(item.hir_id(), access_level);
                 }
             }
             // The interface is empty.

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -397,8 +397,6 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
             used: Cell::new(false),
         });
 
-        debug!("add_import({:?})", import);
-
         self.r.indeterminate_imports.push(import);
         match import.kind {
             // Don't add unresolved underscore imports to modules
@@ -469,7 +467,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 +577,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,9 @@ pub enum ImportKind<'a> {
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
         nested: bool,
+        /// Additional `NodeId`s allocated to a `ast::UseTree` for automatically generated `use` statement
+        /// (eg. implicit struct constructors)
+        additional_ids: (NodeId, NodeId),
     },
     Glob {
         is_prelude: bool,
@@ -836,7 +839,6 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
                         import.span,
                     );
                     import.vis.set(orig_vis);
-
                     source_bindings[ns].set(binding);
                 } else {
                     return;

compiler/rustc_resolve/src/lib.rs

@@ -46,9 +46,10 @@ use rustc_index::vec::IndexVec;
 use rustc_metadata::creader::{CStore, CrateLoader};
 use rustc_middle::hir::exports::ExportMap;
 use rustc_middle::middle::cstore::{CrateStore, MetadataLoaderDyn};
+use rustc_middle::middle::privacy::AccessLevel;
 use rustc_middle::span_bug;
 use rustc_middle::ty::query::Providers;
-use rustc_middle::ty::{self, DefIdTree, MainDefinition, ResolverOutputs};
+use rustc_middle::ty::{self, DefIdTree, MainDefinition, ResolverOutputs, Visibility};
 use rustc_session::lint;
 use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
 use rustc_session::Session;
@@ -1032,6 +1033,8 @@ pub struct Resolver<'a> {
     legacy_const_generic_args: FxHashMap<DefId, Option<Vec<usize>>>,
 
     main_def: Option<MainDefinition>,
+
+    nodes_access_level: FxHashMap<LocalDefId, AccessLevel>,
 }
 
 /// Nothing really interesting here; it just provides memory for the rest of the crate.
@@ -1393,6 +1396,8 @@ impl<'a> Resolver<'a> {
             trait_impl_items: Default::default(),
             legacy_const_generic_args: Default::default(),
             main_def: Default::default(),
+
+            nodes_access_level: Default::default(),
         };
 
         let root_parent_scope = ParentScope::module(graph_root, &resolver);
@@ -1435,10 +1440,12 @@ impl<'a> Resolver<'a> {
         let maybe_unused_extern_crates = self.maybe_unused_extern_crates;
         let glob_map = self.glob_map;
         let main_def = self.main_def;
+        let access_levels = self.nodes_access_level;
         ResolverOutputs {
             definitions,
             cstore: Box::new(self.crate_loader.into_cstore()),
             visibilities,
+            access_levels,
             extern_crate_map,
             export_map,
             glob_map,
@@ -1456,6 +1463,7 @@ impl<'a> Resolver<'a> {
     pub fn clone_outputs(&self) -> ResolverOutputs {
         ResolverOutputs {
             definitions: self.definitions.clone(),
+            access_levels: self.nodes_access_level.clone(),
             cstore: Box::new(self.cstore().clone()),
             visibilities: self.visibilities.clone(),
             extern_crate_map: self.extern_crate_map.clone(),
@@ -1512,6 +1520,7 @@ impl<'a> Resolver<'a> {
     pub fn resolve_crate(&mut self, krate: &Crate) {
         self.session.time("resolve_crate", || {
             self.session.time("finalize_imports", || ImportResolver { r: self }.finalize_imports());
+            self.session.time("resolve_export_privacy", || self.resolve_export_privacy());
             self.session.time("finalize_macro_resolutions", || self.finalize_macro_resolutions());
             self.session.time("late_resolve_crate", || self.late_resolve_crate(krate));
             self.session.time("resolve_main", || self.resolve_main());
@@ -1521,6 +1530,58 @@ impl<'a> Resolver<'a> {
         });
     }
 
+    /// Compute access levels for exports and intermediate use statements
+    fn resolve_export_privacy(&mut self) {
+        let root = self.graph_root();
+        let exports = root.def_id().and_then(|id| self.export_map.get(&id.expect_local()));
+
+        if let Some(exports) = exports.cloned() {
+            let public_exports =
+                exports.iter().filter(|ex| ex.vis == Visibility::Public).collect::<Vec<_>>();
+
+            for export in public_exports {
+                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() {
+                        self.compute_binding_access_level(binding);
+                    }
+                }
+            }
+        }
+
+        tracing::debug!("nodes_access_level: {:?}", self.nodes_access_level);
+    }
+
+    /// Set the given binding access level to `AccessLevel::Public` and
+    /// sets the rest of the `use` chain to `AccessLevel::Exported` until
+    /// we hit the actual exported item
+    fn compute_binding_access_level(&mut self, mut binding: &NameBinding<'a>) {
+        let mut access_level = AccessLevel::Public;
+        while let NameBindingKind::Import { binding: nested_binding, import, .. } = binding.kind {
+            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);
+                }
+                _ => {}
+            };
+
+            access_level = AccessLevel::Exported;
+            binding = nested_binding;
+        }
+    }
+
+    fn mark_node_with_access_level(&mut self, node_id: NodeId, access_level: AccessLevel) -> bool {
+        if let Some(def_id) = self.opt_local_def_id(node_id) {
+            self.nodes_access_level.insert(def_id, access_level).is_none()
+        } else {
+            false
+        }
+    }
+
     pub fn traits_in_scope(
         &mut self,
         current_trait: Option<Module<'a>>,