diff options
Diffstat (limited to 'compiler/rustc_resolve/src/access_levels.rs')
| -rw-r--r-- | compiler/rustc_resolve/src/access_levels.rs | 185 |
1 files changed, 0 insertions, 185 deletions
diff --git a/compiler/rustc_resolve/src/access_levels.rs b/compiler/rustc_resolve/src/access_levels.rs deleted file mode 100644 index 0a3add2e0..000000000 --- a/compiler/rustc_resolve/src/access_levels.rs +++ /dev/null @@ -1,185 +0,0 @@ -use crate::imports::ImportKind; -use crate::NameBinding; -use crate::NameBindingKind; -use crate::Resolver; -use rustc_ast::ast; -use rustc_ast::visit; -use rustc_ast::visit::Visitor; -use rustc_ast::Crate; -use rustc_ast::EnumDef; -use rustc_ast::NodeId; -use rustc_hir::def_id::LocalDefId; -use rustc_hir::def_id::CRATE_DEF_ID; -use rustc_middle::middle::privacy::AccessLevel; -use rustc_middle::ty::DefIdTree; -use rustc_span::sym; - -pub struct AccessLevelsVisitor<'r, 'a> { - r: &'r mut Resolver<'a>, - changed: bool, -} - -impl<'r, 'a> AccessLevelsVisitor<'r, 'a> { - /// Fills the `Resolver::access_levels` table with public & exported items - /// For now, this doesn't resolve macros (FIXME) and cannot resolve Impl, as we - /// need access to a TyCtxt for that. - pub fn compute_access_levels<'c>(r: &'r mut Resolver<'a>, krate: &'c Crate) { - let mut visitor = AccessLevelsVisitor { r, changed: false }; - - visitor.set_access_level_def_id(CRATE_DEF_ID, Some(AccessLevel::Public)); - visitor.set_bindings_access_level(CRATE_DEF_ID); - - while visitor.changed { - visitor.reset(); - visit::walk_crate(&mut visitor, krate); - } - - info!("resolve::access_levels: {:#?}", r.access_levels); - } - - fn reset(&mut self) { - self.changed = false; - } - - /// Update the access level of the bindings in the given module accordingly. The module access - /// level has to be Exported or Public. - /// This will also follow `use` chains (see PrivacyVisitor::set_import_binding_access_level). - fn set_bindings_access_level(&mut self, module_id: LocalDefId) { - assert!(self.r.module_map.contains_key(&&module_id.to_def_id())); - let module_level = self.r.access_levels.map.get(&module_id).copied(); - if !module_level.is_some() { - return; - } - // 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. - let set_import_binding_access_level = - |this: &mut Self, mut binding: &NameBinding<'a>, mut access_level| { - while let NameBindingKind::Import { binding: nested_binding, import, .. } = - binding.kind - { - this.set_access_level(import.id, access_level); - if let ImportKind::Single { additional_ids, .. } = import.kind { - this.set_access_level(additional_ids.0, access_level); - this.set_access_level(additional_ids.1, access_level); - } - - access_level = Some(AccessLevel::Exported); - binding = nested_binding; - } - }; - - let module = self.r.get_module(module_id.to_def_id()).unwrap(); - let resolutions = self.r.resolutions(module); - - for (.., name_resolution) in resolutions.borrow().iter() { - if let Some(binding) = name_resolution.borrow().binding() && binding.vis.is_public() && !binding.is_ambiguity() { - let access_level = match binding.is_import() { - true => { - set_import_binding_access_level(self, binding, module_level); - Some(AccessLevel::Exported) - }, - false => module_level, - }; - if let Some(def_id) = binding.res().opt_def_id().and_then(|id| id.as_local()) { - self.set_access_level_def_id(def_id, access_level); - } - } - } - } - - /// Sets the access level of the `LocalDefId` corresponding to the given `NodeId`. - /// This function will panic if the `NodeId` does not have a `LocalDefId` - fn set_access_level( - &mut self, - node_id: NodeId, - access_level: Option<AccessLevel>, - ) -> Option<AccessLevel> { - self.set_access_level_def_id(self.r.local_def_id(node_id), access_level) - } - - fn set_access_level_def_id( - &mut self, - def_id: LocalDefId, - access_level: Option<AccessLevel>, - ) -> Option<AccessLevel> { - let old_level = self.r.access_levels.map.get(&def_id).copied(); - if old_level < access_level { - self.r.access_levels.map.insert(def_id, access_level.unwrap()); - self.changed = true; - access_level - } else { - old_level - } - } -} - -impl<'r, 'ast> Visitor<'ast> for AccessLevelsVisitor<'ast, 'r> { - fn visit_item(&mut self, item: &'ast ast::Item) { - let def_id = self.r.local_def_id(item.id); - // Set access level of nested items. - // If it's a mod, also make the visitor walk all of its items - match item.kind { - // Resolved in rustc_privacy when types are available - ast::ItemKind::Impl(..) => return, - - // Should be unreachable at this stage - ast::ItemKind::MacCall(..) => panic!( - "ast::ItemKind::MacCall encountered, this should not anymore appear at this stage" - ), - - // Foreign modules inherit level from parents. - ast::ItemKind::ForeignMod(..) => { - let parent_level = - self.r.access_levels.map.get(&self.r.local_parent(def_id)).copied(); - self.set_access_level(item.id, parent_level); - } - - // Only exported `macro_rules!` items are public, but they always are - ast::ItemKind::MacroDef(ref macro_def) if macro_def.macro_rules => { - if item.attrs.iter().any(|attr| attr.has_name(sym::macro_export)) { - self.set_access_level(item.id, Some(AccessLevel::Public)); - } - } - - ast::ItemKind::Mod(..) => { - self.set_bindings_access_level(def_id); - visit::walk_item(self, item); - } - - ast::ItemKind::Enum(EnumDef { ref variants }, _) => { - self.set_bindings_access_level(def_id); - for variant in variants { - let variant_def_id = self.r.local_def_id(variant.id); - let variant_level = self.r.access_levels.map.get(&variant_def_id).copied(); - for field in variant.data.fields() { - self.set_access_level(field.id, variant_level); - } - } - } - - ast::ItemKind::Struct(ref def, _) | ast::ItemKind::Union(ref def, _) => { - let inherited_level = self.r.access_levels.map.get(&def_id).copied(); - for field in def.fields() { - if field.vis.kind.is_pub() { - self.set_access_level(field.id, inherited_level); - } - } - } - - ast::ItemKind::Trait(..) => { - self.set_bindings_access_level(def_id); - } - - ast::ItemKind::ExternCrate(..) - | ast::ItemKind::Use(..) - | ast::ItemKind::Static(..) - | ast::ItemKind::Const(..) - | ast::ItemKind::GlobalAsm(..) - | ast::ItemKind::TyAlias(..) - | ast::ItemKind::TraitAlias(..) - | ast::ItemKind::MacroDef(..) - | ast::ItemKind::Fn(..) => return, - } - } -} |