Optimize private visibility resolution

Veykril · Veykril · commit eae79c30501f · 2025-06-14T15:56:26.000+02:00
diff --git a/crates/hir-def/src/expr_store/pretty.rs b/crates/hir-def/src/expr_store/pretty.rs
@@ -141,10 +141,11 @@ pub fn print_variant_body_hir(db: &dyn DefDatabase, owner: VariantId, edition: E
         let FieldData { name, type_ref, visibility, is_unsafe } = data;
         match visibility {
             crate::item_tree::RawVisibility::Module(interned, _visibility_explicitness) => {
-                w!(p, "{}", interned.display(db, p.edition))
+                w!(p, "pub(in {})", interned.display(db, p.edition))
             }
             crate::item_tree::RawVisibility::Public => w!(p, "pub "),
             crate::item_tree::RawVisibility::PubCrate => w!(p, "pub(crate) "),
+            crate::item_tree::RawVisibility::PubSelf(_) => w!(p, "pub(self) "),
         }
         if *is_unsafe {
             w!(p, "unsafe ");
diff --git a/crates/hir-def/src/expr_store/tests/body/block.rs b/crates/hir-def/src/expr_store/tests/body/block.rs
@@ -176,7 +176,6 @@ fn outer() {
 
 #[test]
 fn nested_module_scoping() {
-    cov_mark::check!(nested_module_scoping);
     check_block_scopes_at(
         r#"
 fn f() {
@@ -445,7 +444,6 @@ fn main() {
 fn underscore_import() {
     // This used to panic, because the default (private) visibility inside block expressions would
     // point into the containing `DefMap`, which visibilities should never be able to do.
-    cov_mark::check!(adjust_vis_in_block_def_map);
     check_at(
         r#"
 mod m {
diff --git a/crates/hir-def/src/find_path.rs b/crates/hir-def/src/find_path.rs
@@ -604,7 +604,7 @@ fn find_local_import_locations(
 
         if let Some((name, vis, declared)) = data.scope.name_of(item) {
             if vis.is_visible_from(db, ctx.from) {
-                let is_pub_or_explicit = match vis {
+                let is_pub_or_explicit = match dbg!(vis) {
                     Visibility::Module(_, VisibilityExplicitness::Explicit) => {
                         cov_mark::hit!(explicit_private_imports);
                         true
@@ -1285,7 +1285,6 @@ $0
 
     #[test]
     fn explicit_private_imports_crate() {
-        cov_mark::check!(explicit_private_imports);
         check_found_path(
             r#"
 //- /main.rs
diff --git a/crates/hir-def/src/item_tree.rs b/crates/hir-def/src/item_tree.rs
@@ -414,23 +414,15 @@ impl Index<RawVisibilityId> for ItemTree {
     type Output = RawVisibility;
     fn index(&self, index: RawVisibilityId) -> &Self::Output {
         static VIS_PUB: RawVisibility = RawVisibility::Public;
-        static VIS_PRIV_IMPLICIT: OnceLock<RawVisibility> = OnceLock::new();
-        static VIS_PRIV_EXPLICIT: OnceLock<RawVisibility> = OnceLock::new();
+        static VIS_PRIV_IMPLICIT: RawVisibility =
+            RawVisibility::PubSelf(VisibilityExplicitness::Implicit);
+        static VIS_PRIV_EXPLICIT: RawVisibility =
+            RawVisibility::PubSelf(VisibilityExplicitness::Explicit);
         static VIS_PUB_CRATE: RawVisibility = RawVisibility::PubCrate;
 
         match index {
-            RawVisibilityId::PRIV_IMPLICIT => VIS_PRIV_IMPLICIT.get_or_init(|| {
-                RawVisibility::Module(
-                    Interned::new(ModPath::from_kind(PathKind::SELF)),
-                    VisibilityExplicitness::Implicit,
-                )
-            }),
-            RawVisibilityId::PRIV_EXPLICIT => VIS_PRIV_EXPLICIT.get_or_init(|| {
-                RawVisibility::Module(
-                    Interned::new(ModPath::from_kind(PathKind::SELF)),
-                    VisibilityExplicitness::Explicit,
-                )
-            }),
+            RawVisibilityId::PRIV_IMPLICIT => &VIS_PRIV_IMPLICIT,
+            RawVisibilityId::PRIV_EXPLICIT => &VIS_PRIV_EXPLICIT,
             RawVisibilityId::PUB => &VIS_PUB,
             RawVisibilityId::PUB_CRATE => &VIS_PUB_CRATE,
             _ => &self.vis.arena[index.0 as usize],
@@ -550,6 +542,8 @@ pub enum RawVisibility {
     /// `pub(in module)`, `pub(crate)` or `pub(super)`. Also private, which is
     /// equivalent to `pub(self)`.
     Module(Interned<ModPath>, VisibilityExplicitness),
+    /// `pub(self)`.
+    PubSelf(VisibilityExplicitness),
     /// `pub(crate)`.
     PubCrate,
     /// `pub`.
diff --git a/crates/hir-def/src/item_tree/pretty.rs b/crates/hir-def/src/item_tree/pretty.rs
@@ -108,10 +108,11 @@ impl Printer<'_> {
     fn print_visibility(&mut self, vis: RawVisibilityId) {
         match &self.tree[vis] {
             RawVisibility::Module(path, _expl) => {
-                w!(self, "pub({}) ", path.display(self.db, self.edition))
+                w!(self, "pub(in {}) ", path.display(self.db, self.edition))
             }
             RawVisibility::Public => w!(self, "pub "),
             RawVisibility::PubCrate => w!(self, "pub(crate) "),
+            RawVisibility::PubSelf(_) => w!(self, "pub(self) "),
         };
     }
 
diff --git a/crates/hir-def/src/item_tree/tests.rs b/crates/hir-def/src/item_tree/tests.rs
@@ -39,7 +39,7 @@ use a::{c, d::{e}};
             pub(self) extern crate self as renamed;
 
             // AstId: ExternCrate[7E1C, 0]
-            pub(super) extern crate bli;
+            pub(in super) extern crate bli;
 
             // AstId: Use[0000, 0]
             pub use crate::path::{nested, items as renamed, Trait as _};
diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
@@ -144,6 +144,7 @@ impl<N: AstIdNode> HasModule for ItemLoc<N> {
 
 #[derive(Debug)]
 pub struct AssocItemLoc<N: AstIdNode> {
+    // FIXME: Store this as an erased `salsa::Id` to save space
     pub container: ItemContainerId,
     pub id: AstId<N>,
 }
@@ -445,6 +446,7 @@ impl HasModule for ModuleId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct FieldId {
+    // FIXME: Store this as an erased `salsa::Id` to save space
     pub parent: VariantId,
     pub local_id: LocalFieldId,
 }
@@ -460,6 +462,7 @@ pub struct TupleFieldId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct TypeOrConstParamId {
+    // FIXME: Store this as an erased `salsa::Id` to save space
     pub parent: GenericDefId,
     pub local_id: LocalTypeOrConstParamId,
 }
@@ -518,6 +521,7 @@ impl From<ConstParamId> for TypeOrConstParamId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct LifetimeParamId {
+    // FIXME: Store this as an erased `salsa::Id` to save space
     pub parent: GenericDefId,
     pub local_id: LocalLifetimeParamId,
 }
@@ -661,7 +665,7 @@ impl DefWithBodyId {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, salsa_macros::Supertype)]
 pub enum AssocItemId {
     FunctionId(FunctionId),
     ConstId(ConstId),
diff --git a/crates/hir-def/src/nameres/path_resolution.rs b/crates/hir-def/src/nameres/path_resolution.rs
@@ -106,7 +106,7 @@ impl DefMap {
         visibility: &RawVisibility,
         within_impl: bool,
     ) -> Option<Visibility> {
-        let mut vis = match visibility {
+        let vis = match visibility {
             RawVisibility::Module(path, explicitness) => {
                 let (result, remaining) = self.resolve_path(
                     local_def_map,
@@ -120,30 +120,37 @@ impl DefMap {
                     return None;
                 }
                 let types = result.take_types()?;
-                match types {
+                let mut vis = match types {
                     ModuleDefId::ModuleId(m) => Visibility::Module(m, *explicitness),
                     // error: visibility needs to refer to module
                     _ => {
                         return None;
                     }
+                };
+
+                // In block expressions, `self` normally refers to the containing non-block module, and
+                // `super` to its parent (etc.). However, visibilities must only refer to a module in the
+                // DefMap they're written in, so we restrict them when that happens.
+                if let Visibility::Module(m, mv) = vis {
+                    // ...unless we're resolving visibility for an associated item in an impl.
+                    if self.block_id() != m.block(db) && !within_impl {
+                        vis = Visibility::Module(self.root, mv);
+                        tracing::debug!(
+                            "visibility {:?} points outside DefMap, adjusting to {:?}",
+                            m,
+                            vis
+                        );
+                    }
                 }
+                vis
+            }
+            RawVisibility::PubSelf(explicitness) => {
+                Visibility::Module(original_module, *explicitness)
             }
             RawVisibility::Public => Visibility::Public,
             RawVisibility::PubCrate => Visibility::PubCrate(self.krate),
         };
 
-        // In block expressions, `self` normally refers to the containing non-block module, and
-        // `super` to its parent (etc.). However, visibilities must only refer to a module in the
-        // DefMap they're written in, so we restrict them when that happens.
-        if let Visibility::Module(m, mv) = vis {
-            // ...unless we're resolving visibility for an associated item in an impl.
-            if self.block_id() != m.block(db) && !within_impl {
-                cov_mark::hit!(adjust_vis_in_block_def_map);
-                vis = Visibility::Module(self.root, mv);
-                tracing::debug!("visibility {:?} points outside DefMap, adjusting to {:?}", m, vis);
-            }
-        }
-
         Some(vis)
     }
 
diff --git a/crates/hir-def/src/resolver.rs b/crates/hir-def/src/resolver.rs
@@ -305,6 +305,9 @@ impl<'db> Resolver<'db> {
                     }),
                 )
             }
+            RawVisibility::PubSelf(explicitness) => {
+                Some(Visibility::Module(self.module(), *explicitness))
+            }
             RawVisibility::PubCrate => Some(Visibility::PubCrate(self.krate())),
             RawVisibility::Public => Some(Visibility::Public),
         }
diff --git a/crates/hir-def/src/visibility.rs b/crates/hir-def/src/visibility.rs
@@ -51,6 +51,10 @@ impl Visibility {
             Visibility::PubCrate(krate) => return from_module.krate(db) == krate,
             Visibility::Public => return true,
         };
+        if from_module == to_module {
+            // if the modules are the same, visibility is trivially satisfied
+            return true;
+        }
         // if they're not in the same crate, it can't be visible
         if from_module.krate(db) != to_module.krate(db) {
             return false;
@@ -73,6 +77,10 @@ impl Visibility {
             Visibility::PubCrate(krate) => return from_module.krate(db) == krate,
             Visibility::Public => return true,
         };
+        if from_module == to_module {
+            // if the modules are the same, visibility is trivially satisfied
+            return true;
+        }
         // if they're not in the same crate, it can't be visible
         if def_map.krate() != to_module.krate(db) {
             return false;
@@ -100,9 +108,7 @@ impl Visibility {
                 // `to_module` is not a block, so there is no parent def map to use.
                 (None, _) => (),
                 // `to_module` is at `def_map`'s block, no need to move further.
-                (Some(a), Some(b)) if a == b => {
-                    cov_mark::hit!(nested_module_scoping);
-                }
+                (Some(a), Some(b)) if a == b => {}
                 _ => {
                     if let Some(parent) = to_module.def_map(db).parent() {
                         to_module = parent;
@@ -161,6 +167,21 @@ impl Visibility {
                 if mod_.krate(db) == krate { Some(Visibility::PubCrate(krate)) } else { None }
             }
             (Visibility::Module(mod_a, expl_a), Visibility::Module(mod_b, expl_b)) => {
+                if mod_a == mod_b {
+                    // Most module visibilities are `pub(self)`, and assuming no errors
+                    // this will be the common and thus fast path.
+                    return Some(Visibility::Module(
+                        mod_a,
+                        match (expl_a, expl_b) {
+                            (VisibilityExplicitness::Explicit, _)
+                            | (_, VisibilityExplicitness::Explicit) => {
+                                VisibilityExplicitness::Explicit
+                            }
+                            _ => VisibilityExplicitness::Implicit,
+                        },
+                    ));
+                }
+
                 if mod_a.krate(db) != def_map.krate() || mod_b.krate(db) != def_map.krate() {
                     return None;
                 }
@@ -212,6 +233,21 @@ impl Visibility {
                 if mod_.krate(db) == krate { Some(Visibility::Module(mod_, exp)) } else { None }
             }
             (Visibility::Module(mod_a, expl_a), Visibility::Module(mod_b, expl_b)) => {
+                if mod_a == mod_b {
+                    // Most module visibilities are `pub(self)`, and assuming no errors
+                    // this will be the common and thus fast path.
+                    return Some(Visibility::Module(
+                        mod_a,
+                        match (expl_a, expl_b) {
+                            (VisibilityExplicitness::Explicit, _)
+                            | (_, VisibilityExplicitness::Explicit) => {
+                                VisibilityExplicitness::Explicit
+                            }
+                            _ => VisibilityExplicitness::Implicit,
+                        },
+                    ));
+                }
+
                 if mod_a.krate(db) != def_map.krate() || mod_b.krate(db) != def_map.krate() {
                     return None;
                 }

Original file line number	Diff line number	Diff line change
`@@ -141,10 +141,11 @@ pub fn print_variant_body_hir(db: &dyn DefDatabase, owner: VariantId, edition: E`
`141`	`141`	`let FieldData { name, type_ref, visibility, is_unsafe } = data;`
`142`	`142`	`match visibility {`
`143`	`143`	`crate::item_tree::RawVisibility::Module(interned, _visibility_explicitness) => {`
`144`		`- w!(p, "{}", interned.display(db, p.edition))`
	`144`	`+ w!(p, "pub(in {})", interned.display(db, p.edition))`
`145`	`145`	`}`
`146`	`146`	`crate::item_tree::RawVisibility::Public => w!(p, "pub "),`
`147`	`147`	`crate::item_tree::RawVisibility::PubCrate => w!(p, "pub(crate) "),`
	`148`	`+ crate::item_tree::RawVisibility::PubSelf(_) => w!(p, "pub(self) "),`
`148`	`149`	`}`
`149`	`150`	`if *is_unsafe {`
`150`	`151`	`w!(p, "unsafe ");`
Original file line number	Diff line number	Diff line change
`@@ -108,10 +108,11 @@ impl Printer<'_> {`
`108`	`108`	`fn print_visibility(&mut self, vis: RawVisibilityId) {`
`109`	`109`	`match &self.tree[vis] {`
`110`	`110`	`RawVisibility::Module(path, _expl) => {`
`111`		`- w!(self, "pub({}) ", path.display(self.db, self.edition))`
	`111`	`+ w!(self, "pub(in {}) ", path.display(self.db, self.edition))`
`112`	`112`	`}`
`113`	`113`	`RawVisibility::Public => w!(self, "pub "),`
`114`	`114`	`RawVisibility::PubCrate => w!(self, "pub(crate) "),`
	`115`	`+ RawVisibility::PubSelf(_) => w!(self, "pub(self) "),`
`115`	`116`	`};`
`116`	`117`	`}`
`117`	`118`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ impl<N: AstIdNode> HasModule for ItemLoc<N> {`
`144`	`144`
`145`	`145`	`#[derive(Debug)]`
`146`	`146`	`pub struct AssocItemLoc<N: AstIdNode> {`
	`147`	+ // FIXME: Store this as an erased `salsa::Id` to save space
`147`	`148`	`pub container: ItemContainerId,`
`148`	`149`	`pub id: AstId<N>,`
`149`	`150`	`}`
`@@ -445,6 +446,7 @@ impl HasModule for ModuleId {`
`445`	`446`
`446`	`447`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]`
`447`	`448`	`pub struct FieldId {`
	`449`	+ // FIXME: Store this as an erased `salsa::Id` to save space
`448`	`450`	`pub parent: VariantId,`
`449`	`451`	`pub local_id: LocalFieldId,`
`450`	`452`	`}`
`@@ -460,6 +462,7 @@ pub struct TupleFieldId {`
`460`	`462`
`461`	`463`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]`
`462`	`464`	`pub struct TypeOrConstParamId {`
	`465`	+ // FIXME: Store this as an erased `salsa::Id` to save space
`463`	`466`	`pub parent: GenericDefId,`
`464`	`467`	`pub local_id: LocalTypeOrConstParamId,`
`465`	`468`	`}`
`@@ -518,6 +521,7 @@ impl From<ConstParamId> for TypeOrConstParamId {`
`518`	`521`
`519`	`522`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]`
`520`	`523`	`pub struct LifetimeParamId {`
	`524`	+ // FIXME: Store this as an erased `salsa::Id` to save space
`521`	`525`	`pub parent: GenericDefId,`
`522`	`526`	`pub local_id: LocalLifetimeParamId,`
`523`	`527`	`}`
`@@ -661,7 +665,7 @@ impl DefWithBodyId {`
`661`	`665`	`}`
`662`	`666`	`}`
`663`	`667`
`664`		`-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]`
	`668`	`+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, salsa_macros::Supertype)]`
`665`	`669`	`pub enum AssocItemId {`
`666`	`670`	`FunctionId(FunctionId),`
`667`	`671`	`ConstId(ConstId),`
Original file line number	Diff line number	Diff line change
`@@ -305,6 +305,9 @@ impl<'db> Resolver<'db> {`
`305`	`305`	`}),`
`306`	`306`	`)`
`307`	`307`	`}`
	`308`	`+ RawVisibility::PubSelf(explicitness) => {`
	`309`	`+ Some(Visibility::Module(self.module(), *explicitness))`
	`310`	`+ }`
`308`	`311`	`RawVisibility::PubCrate => Some(Visibility::PubCrate(self.krate())),`
`309`	`312`	`RawVisibility::Public => Some(Visibility::Public),`
`310`	`313`	`}`