crates/hir_def/src/visibility.rs

   1 //! Defines hir-level representation of visibility (e.g. `pub` and `pub(crate)`).
   2
   3 use std::{iter, sync::Arc};
   4
   5 use hir_expand::{hygiene::Hygiene, InFile};
   6 use la_arena::ArenaMap;
   7 use syntax::ast;
   8
   9 use crate::{
  10     db::DefDatabase,
  11     nameres::DefMap,
  12     path::{ModPath, PathKind},
  13     resolver::HasResolver,
  14     FunctionId, HasModule, LocalFieldId, ModuleId, VariantId,
  15 };
  16
  17 /// Visibility of an item, not yet resolved.
  18 #[derive(Debug, Clone, PartialEq, Eq)]
  19 pub enum RawVisibility {
  20     /// `pub(in module)`, `pub(crate)` or `pub(super)`. Also private, which is
  21     /// equivalent to `pub(self)`.
  22     Module(ModPath),
  23     /// `pub`.
  24     Public,
  25 }
  26
  27 impl RawVisibility {
  28     pub(crate) const fn private() -> RawVisibility {
  29         RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)))
  30     }
  31
  32     pub(crate) fn from_ast(
  33         db: &dyn DefDatabase,
  34         node: InFile<Option<ast::Visibility>>,
  35     ) -> RawVisibility {
  36         Self::from_ast_with_hygiene(db, node.value, &Hygiene::new(db.upcast(), node.file_id))
  37     }
  38
  39     pub(crate) fn from_ast_with_hygiene(
  40         db: &dyn DefDatabase,
  41         node: Option<ast::Visibility>,
  42         hygiene: &Hygiene,
  43     ) -> RawVisibility {
  44         Self::from_ast_with_hygiene_and_default(db, node, RawVisibility::private(), hygiene)
  45     }
  46
  47     pub(crate) fn from_ast_with_hygiene_and_default(
  48         db: &dyn DefDatabase,
  49         node: Option<ast::Visibility>,
  50         default: RawVisibility,
  51         hygiene: &Hygiene,
  52     ) -> RawVisibility {
  53         let node = match node {
  54             None => return default,
  55             Some(node) => node,
  56         };
  57         match node.kind() {
  58             ast::VisibilityKind::In(path) => {
  59                 let path = ModPath::from_src(db.upcast(), path, hygiene);
  60                 let path = match path {
  61                     None => return RawVisibility::private(),
  62                     Some(path) => path,
  63                 };
  64                 RawVisibility::Module(path)
  65             }
  66             ast::VisibilityKind::PubCrate => {
  67                 let path = ModPath::from_kind(PathKind::Crate);
  68                 RawVisibility::Module(path)
  69             }
  70             ast::VisibilityKind::PubSuper => {
  71                 let path = ModPath::from_kind(PathKind::Super(1));
  72                 RawVisibility::Module(path)
  73             }
  74             ast::VisibilityKind::PubSelf => {
  75                 let path = ModPath::from_kind(PathKind::Plain);
  76                 RawVisibility::Module(path)
  77             }
  78             ast::VisibilityKind::Pub => RawVisibility::Public,
  79         }
  80     }
  81
  82     pub fn resolve(
  83         &self,
  84         db: &dyn DefDatabase,
  85         resolver: &crate::resolver::Resolver,
  86     ) -> Visibility {
  87         // we fall back to public visibility (i.e. fail open) if the path can't be resolved
  88         resolver.resolve_visibility(db, self).unwrap_or(Visibility::Public)
  89     }
  90 }
  91
  92 /// Visibility of an item, with the path resolved.
  93 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
  94 pub enum Visibility {
  95     /// Visibility is restricted to a certain module.
  96     Module(ModuleId),
  97     /// Visibility is unrestricted.
  98     Public,
  99 }
 100
 101 impl Visibility {
 102     pub fn is_visible_from(self, db: &dyn DefDatabase, from_module: ModuleId) -> bool {
 103         let to_module = match self {
 104             Visibility::Module(m) => m,
 105             Visibility::Public => return true,
 106         };
 107         // if they're not in the same crate, it can't be visible
 108         if from_module.krate != to_module.krate {
 109             return false;
 110         }
 111         let def_map = from_module.def_map(db);
 112         self.is_visible_from_def_map(db, &def_map, from_module.local_id)
 113     }
 114
 115     pub(crate) fn is_visible_from_other_crate(self) -> bool {
 116         matches!(self, Visibility::Public)
 117     }
 118
 119     pub(crate) fn is_visible_from_def_map(
 120         self,
 121         db: &dyn DefDatabase,
 122         def_map: &DefMap,
 123         mut from_module: crate::LocalModuleId,
 124     ) -> bool {
 125         let mut to_module = match self {
 126             Visibility::Module(m) => m,
 127             Visibility::Public => return true,
 128         };
 129
 130         // `to_module` might be the root module of a block expression. Those have the same
 131         // visibility as the containing module (even though no items are directly nameable from
 132         // there, getting this right is important for method resolution).
 133         // In that case, we adjust the visibility of `to_module` to point to the containing module.
 134         // Additional complication: `to_module` might be in `from_module`'s `DefMap`, which we're
 135         // currently computing, so we must not call the `def_map` query for it.
 136         let arc;
 137         let to_module_def_map =
 138             if to_module.krate == def_map.krate() && to_module.block == def_map.block_id() {
 139                 cov_mark::hit!(is_visible_from_same_block_def_map);
 140                 def_map
 141             } else {
 142                 arc = to_module.def_map(db);
 143                 &arc
 144             };
 145         let is_block_root = matches!(to_module.block, Some(_) if to_module_def_map[to_module.local_id].parent.is_none());
 146         if is_block_root {
 147             to_module = to_module_def_map.containing_module(to_module.local_id).unwrap();
 148         }
 149
 150         // from_module needs to be a descendant of to_module
 151         let mut def_map = def_map;
 152         let mut parent_arc;
 153         loop {
 154             if def_map.module_id(from_module) == to_module {
 155                 return true;
 156             }
 157             match def_map[from_module].parent {
 158                 Some(parent) => from_module = parent,
 159                 None => {
 160                     match def_map.parent() {
 161                         Some(module) => {
 162                             parent_arc = module.def_map(db);
 163                             def_map = &*parent_arc;
 164                             from_module = module.local_id;
 165                         }
 166                         // Reached the root module, nothing left to check.
 167                         None => return false,
 168                     }
 169                 }
 170             }
 171         }
 172     }
 173
 174     /// Returns the most permissive visibility of `self` and `other`.
 175     ///
 176     /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
 177     /// visible in unrelated modules).
 178     pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
 179         match (self, other) {
 180             (Visibility::Module(_) | Visibility::Public, Visibility::Public)
 181             | (Visibility::Public, Visibility::Module(_)) => Some(Visibility::Public),
 182             (Visibility::Module(mod_a), Visibility::Module(mod_b)) => {
 183                 if mod_a.krate != mod_b.krate {
 184                     return None;
 185                 }
 186
 187                 let mut a_ancestors = iter::successors(Some(mod_a.local_id), |&m| {
 188                     let parent_id = def_map[m].parent?;
 189                     Some(parent_id)
 190                 });
 191                 let mut b_ancestors = iter::successors(Some(mod_b.local_id), |&m| {
 192                     let parent_id = def_map[m].parent?;
 193                     Some(parent_id)
 194                 });
 195
 196                 if a_ancestors.any(|m| m == mod_b.local_id) {
 197                     // B is above A
 198                     return Some(Visibility::Module(mod_b));
 199                 }
 200
 201                 if b_ancestors.any(|m| m == mod_a.local_id) {
 202                     // A is above B
 203                     return Some(Visibility::Module(mod_a));
 204                 }
 205
 206                 None
 207             }
 208         }
 209     }
 210 }
 211
 212 /// Resolve visibility of all specific fields of a struct or union variant.
 213 pub(crate) fn field_visibilities_query(
 214     db: &dyn DefDatabase,
 215     variant_id: VariantId,
 216 ) -> Arc<ArenaMap<LocalFieldId, Visibility>> {
 217     let var_data = match variant_id {
 218         VariantId::StructId(it) => db.struct_data(it).variant_data.clone(),
 219         VariantId::UnionId(it) => db.union_data(it).variant_data.clone(),
 220         VariantId::EnumVariantId(it) => {
 221             db.enum_data(it.parent).variants[it.local_id].variant_data.clone()
 222         }
 223     };
 224     let resolver = variant_id.module(db).resolver(db);
 225     let mut res = ArenaMap::default();
 226     for (field_id, field_data) in var_data.fields().iter() {
 227         res.insert(field_id, field_data.visibility.resolve(db, &resolver))
 228     }
 229     Arc::new(res)
 230 }
 231
 232 /// Resolve visibility of a function.
 233 pub(crate) fn function_visibility_query(db: &dyn DefDatabase, def: FunctionId) -> Visibility {
 234     let resolver = def.resolver(db);
 235     db.function_data(def).visibility.resolve(db, &resolver)
 236 }