1 //! Defines hir-level representation of visibility (e.g. `pub` and `pub(crate)`).
3 use std::{iter, sync::Arc};
5 use hir_expand::{hygiene::Hygiene, InFile};
6 use la_arena::ArenaMap;
12 path::{ModPath, PathKind},
13 resolver::HasResolver,
14 FunctionId, HasModule, LocalFieldId, ModuleId, VariantId,
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)`.
28 pub(crate) const fn private() -> RawVisibility {
29 RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)))
32 pub(crate) fn from_ast(
34 node: InFile<Option<ast::Visibility>>,
36 Self::from_ast_with_hygiene(db, node.value, &Hygiene::new(db.upcast(), node.file_id))
39 pub(crate) fn from_ast_with_hygiene(
41 node: Option<ast::Visibility>,
44 Self::from_ast_with_hygiene_and_default(db, node, RawVisibility::private(), hygiene)
47 pub(crate) fn from_ast_with_hygiene_and_default(
49 node: Option<ast::Visibility>,
50 default: RawVisibility,
53 let node = match node {
54 None => return default,
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(),
64 RawVisibility::Module(path)
66 ast::VisibilityKind::PubCrate => {
67 let path = ModPath::from_kind(PathKind::Crate);
68 RawVisibility::Module(path)
70 ast::VisibilityKind::PubSuper => {
71 let path = ModPath::from_kind(PathKind::Super(1));
72 RawVisibility::Module(path)
74 ast::VisibilityKind::PubSelf => {
75 let path = ModPath::from_kind(PathKind::Plain);
76 RawVisibility::Module(path)
78 ast::VisibilityKind::Pub => RawVisibility::Public,
85 resolver: &crate::resolver::Resolver,
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)
92 /// Visibility of an item, with the path resolved.
93 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
95 /// Visibility is restricted to a certain module.
97 /// Visibility is unrestricted.
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,
107 // if they're not in the same crate, it can't be visible
108 if from_module.krate != to_module.krate {
111 let def_map = from_module.def_map(db);
112 self.is_visible_from_def_map(db, &def_map, from_module.local_id)
115 pub(crate) fn is_visible_from_other_crate(self) -> bool {
116 matches!(self, Visibility::Public)
119 pub(crate) fn is_visible_from_def_map(
121 db: &dyn DefDatabase,
123 mut from_module: crate::LocalModuleId,
125 let mut to_module = match self {
126 Visibility::Module(m) => m,
127 Visibility::Public => return true,
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.
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);
142 arc = to_module.def_map(db);
145 let is_block_root = matches!(to_module.block, Some(_) if to_module_def_map[to_module.local_id].parent.is_none());
147 to_module = to_module_def_map.containing_module(to_module.local_id).unwrap();
150 // from_module needs to be a descendant of to_module
151 let mut def_map = def_map;
154 if def_map.module_id(from_module) == to_module {
157 match def_map[from_module].parent {
158 Some(parent) => from_module = parent,
160 match def_map.parent() {
162 parent_arc = module.def_map(db);
163 def_map = &*parent_arc;
164 from_module = module.local_id;
166 // Reached the root module, nothing left to check.
167 None => return false,
174 /// Returns the most permissive visibility of `self` and `other`.
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 {
187 let mut a_ancestors = iter::successors(Some(mod_a.local_id), |&m| {
188 let parent_id = def_map[m].parent?;
191 let mut b_ancestors = iter::successors(Some(mod_b.local_id), |&m| {
192 let parent_id = def_map[m].parent?;
196 if a_ancestors.any(|m| m == mod_b.local_id) {
198 return Some(Visibility::Module(mod_b));
201 if b_ancestors.any(|m| m == mod_a.local_id) {
203 return Some(Visibility::Module(mod_a));
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()
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))
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)