local snapshot

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, def_id: DefId) -> Option<AccessLevel> {
+        self.gcx.untracked_resolutions.access_levels.get(&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<DefId, 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_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;
@@ -573,56 +573,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.hir_id(), Some(AccessLevel::Exported));
-                        }
-                    }
-                }
-            }
-        }
-    }
 }
 
 impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
@@ -730,9 +680,11 @@ 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(ref path, ..) => {
+                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());
+                    self.update(item.hir_id(), access_level);
                 }
             }
             // The interface is empty.

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -397,7 +397,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
             used: Cell::new(false),
         });
 
-        debug!("add_import({:?})", import);
+        debug!("add_import({:#?})", import);
 
         self.r.indeterminate_imports.push(import);
         match import.kind {

compiler/rustc_resolve/src/imports.rs

@@ -265,6 +265,8 @@ impl<'a> Resolver<'a> {
         let resolution =
             self.resolution(module, key).try_borrow_mut().map_err(|_| (Determined, Weak::No))?; // This happens when there is a cycle of imports.
 
+        tracing::info!("resolve_ident: module={:?}, ident={:?}", module, ident);
+
         if let Some(binding) = resolution.binding {
             if !restricted_shadowing && binding.expansion != LocalExpnId::ROOT {
                 if let NameBindingKind::Res(_, true) = binding.kind {
@@ -836,7 +838,7 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
                         import.span,
                     );
                     import.vis.set(orig_vis);
-
+                    tracing::trace!("resolve_import: determinacy: {:?}", binding.map(|binding| binding.span));
                     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>,
+
+    node_privacy: FxHashMap<DefId, 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(),
+
+            node_privacy: 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.node_privacy;
         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.node_privacy.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("prepare_privacy", || self.prepare_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,45 @@ impl<'a> Resolver<'a> {
         });
     }
 
+    fn prepare_privacy(&mut self) {
+        let root = self.graph_root();
+
+        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<_>>();
+                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(binding) = name_res.borrow().binding() {
+                            this.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) {
+        // 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);
+            }
+
+            self.recursive_define_access_level(binding, AccessLevel::Exported, max_recurse - 1);
+        }
+    }
+
     pub fn traits_in_scope(
         &mut self,
         current_trait: Option<Module<'a>>,