Move most of Exported/Public res to rustc_resolve

Author: lambinoo

compiler/rustc_privacy/src/lib.rs

@@ -591,9 +591,8 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
                 Option::<AccessLevel>::of_impl(item.hir_id(), self.tcx, &self.access_levels)
             }
             // Foreign modules inherit level from parents.
-            hir::ItemKind::ForeignMod { .. } => self.prev_level,
-            // Other `pub` items inherit levels from parents.
-            hir::ItemKind::Const(..)
+            hir::ItemKind::ForeignMod { .. }
+            | hir::ItemKind::Const(..)
             | hir::ItemKind::Enum(..)
             | hir::ItemKind::ExternCrate(..)
             | hir::ItemKind::GlobalAsm(..)

compiler/rustc_resolve/src/access_levels.rs

@@ -0,0 +1,115 @@
+use rustc_ast::ast;
+use rustc_ast::visit;
+use rustc_ast::visit::Visitor;
+use rustc_ast::EnumDef;
+use rustc_ast::ForeignMod;
+use rustc_middle::middle::privacy::AccessLevel;
+
+use crate::Resolver;
+
+pub struct PrivacyVisitor<'r, 'a> {
+    r: &'r mut Resolver<'a>,
+    prev_level: Option<AccessLevel>,
+}
+
+impl<'r, 'a> PrivacyVisitor<'r, 'a> {
+    pub fn new(r: &'r mut Resolver<'a>, root_level: Option<AccessLevel>) -> PrivacyVisitor<'r, 'a> {
+        PrivacyVisitor { r, prev_level: root_level }
+    }
+}
+
+impl<'r, 'a> Visitor<'a> for PrivacyVisitor<'a, 'r> {
+    fn visit_item(&mut self, item: &'a ast::Item) {
+        let inherited_item_level = match item.kind {
+            // TODO Is this the correct behavior for those macros?
+            ast::ItemKind::MacCall(..) | ast::ItemKind::MacroDef(..) => None,
+
+            ast::ItemKind::Impl(..) => None,
+            ast::ItemKind::ForeignMod(..) => self.prev_level,
+
+            ast::ItemKind::ExternCrate(..)
+            | ast::ItemKind::Use(..)
+            | ast::ItemKind::Static(..)
+            | ast::ItemKind::Const(..)
+            | ast::ItemKind::Fn(..)
+            | ast::ItemKind::Mod(..)
+            | ast::ItemKind::GlobalAsm(..)
+            | ast::ItemKind::TyAlias(..)
+            | ast::ItemKind::Enum(..)
+            | ast::ItemKind::Struct(..)
+            | ast::ItemKind::Union(..)
+            | ast::ItemKind::Trait(..)
+            | ast::ItemKind::TraitAlias(..) => {
+                if item.vis.kind.is_pub() {
+                    self.prev_level
+                } else {
+                    None
+                }
+            }
+        };
+
+        let access_level = self.r.set_access_level(item.id, inherited_item_level);
+
+        match item.kind {
+            ast::ItemKind::ExternCrate(..)
+            | ast::ItemKind::Use(..)
+            | ast::ItemKind::Static(..)
+            | ast::ItemKind::Const(..)
+            | ast::ItemKind::GlobalAsm(..)
+            | ast::ItemKind::TyAlias(..)
+            | ast::ItemKind::Mod(..)
+            | ast::ItemKind::TraitAlias(..)
+            | ast::ItemKind::MacroDef(..)
+            | ast::ItemKind::MacCall(..)
+            | ast::ItemKind::Fn(..) => {}
+
+            ast::ItemKind::ForeignMod(ForeignMod { ref items, .. }) => {
+                for nested in items {
+                    if nested.vis.kind.is_pub() {
+                        self.r.set_access_level(nested.id, access_level);
+                    }
+                }
+            }
+            ast::ItemKind::Enum(EnumDef { ref variants }, _) => {
+                for variant in variants {
+                    let variant_level = self.r.set_access_level(variant.id, access_level);
+                    if let Some(ctor_id) = variant.data.ctor_id() {
+                        self.r.set_access_level(ctor_id, access_level);
+                    }
+
+                    for field in variant.data.fields() {
+                        self.r.set_access_level(field.id, variant_level);
+                    }
+                }
+            }
+            ast::ItemKind::Struct(ref def, _) | ast::ItemKind::Union(ref def, _) => {
+                if let Some(ctor_id) = def.ctor_id() {
+                    self.r.set_access_level(ctor_id, access_level);
+                    for field in def.fields() {
+                        if field.vis.kind.is_pub() {
+                            self.r.set_access_level(field.id, access_level);
+                        }
+                    }
+                }
+            }
+            ast::ItemKind::Trait(ref trait_kind) => {
+                for nested in trait_kind.4.iter() {
+                    self.r.set_access_level(nested.id, access_level);
+                }
+            }
+            ast::ItemKind::Impl(ref impl_kind) => {
+                for nested in impl_kind.items.iter() {
+                    if impl_kind.of_trait.is_some() || nested.vis.kind.is_pub() {
+                        self.r.set_access_level(nested.id, access_level);
+                    }
+                }
+            }
+        }
+
+        let orig_level = std::mem::replace(&mut self.prev_level, access_level);
+        visit::walk_item(self, item);
+        self.prev_level = orig_level;
+    }
+
+    fn visit_block(&mut self, _block: &'a ast::Block) {}
+}

compiler/rustc_resolve/src/lib.rs

@@ -74,6 +74,7 @@ use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 
 type Res = def::Res<NodeId>;
 
+mod access_levels;
 mod build_reduced_graph;
 mod check_unused;
 mod def_collector;
@@ -1520,7 +1521,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("resolve_access_level", || self.resolve_access_level(krate));
             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());
@@ -1531,7 +1532,11 @@ impl<'a> Resolver<'a> {
     }
 
     /// Compute access levels for exports and intermediate use statements
-    fn resolve_export_privacy(&mut self) {
+    fn resolve_access_level(&mut self, krate: &Crate) {
+        let mut privacy_levels =
+            access_levels::PrivacyVisitor::new(self, Some(AccessLevel::Public));
+        visit::walk_crate(&mut privacy_levels, krate);
+
         let root = self.graph_root();
         let exports = root.def_id().and_then(|id| self.export_map.get(&id.expect_local()));
 
@@ -1544,7 +1549,7 @@ impl<'a> Resolver<'a> {
                     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);
+                        self.set_binding_to_public(binding);
                     }
                 }
             }
@@ -1556,30 +1561,35 @@ impl<'a> Resolver<'a> {
     /// 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;
+    fn set_binding_to_public(&mut self, mut binding: &NameBinding<'a>) {
+        let mut access_level = Some(AccessLevel::Public);
         while let NameBindingKind::Import { binding: nested_binding, import, .. } = binding.kind {
-            self.mark_node_with_access_level(import.id, access_level);
+            self.set_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.set_access_level(additional_ids.0, access_level);
+                    self.set_access_level(additional_ids.1, access_level);
                 }
                 _ => {}
             };
 
-            access_level = AccessLevel::Exported;
+            access_level = Some(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
+    fn set_access_level(
+        &mut self,
+        node_id: NodeId,
+        access_level: Option<AccessLevel>,
+    ) -> Option<AccessLevel> {
+        if let Some(access_level) = access_level {
+            let def_id = self.local_def_id(node_id);
+            self.nodes_access_level.insert(def_id, access_level);
         }
+
+        access_level
     }
 
     pub fn traits_in_scope(

src/test/ui/lint/lint-pub-unreachable-for-nested-glob.rs

@@ -0,0 +1,28 @@
+// check-pass
+
+#![deny(unreachable_pub)]
+
+pub use self::m1::*;
+
+mod m1 {
+    pub use self::m2::*;
+
+    mod m2 {
+        pub struct Item1;
+        pub struct Item2;
+    }
+}
+
+
+pub use self::o1::{ Item42, Item24 };
+
+mod o1 {
+    pub use self::o2::{ Item42, Item24 };
+
+    mod o2 {
+        pub struct Item42;
+        pub struct Item24;
+    }
+}
+
+fn main() {}