1 files changed, 37 insertions, 16 deletions

diff --git a/crates/hir_def/src/visibility.rs b/crates/hir_def/src/visibility.rs
index f3bc9d680..0e3951910 100644
--- a/crates/hir_def/src/visibility.rs
+++ b/crates/hir_def/src/visibility.rs
@@ -5,7 +5,7 @@ use syntax::ast;
 
 use crate::{
     db::DefDatabase,
-    nameres::CrateDefMap,
+    nameres::DefMap,
     path::{ModPath, PathKind},
     ModuleId,
 };
@@ -22,8 +22,7 @@ pub enum RawVisibility {
 
 impl RawVisibility {
     pub(crate) const fn private() -> RawVisibility {
-        let path = ModPath { kind: PathKind::Super(0), segments: Vec::new() };
-        RawVisibility::Module(path)
+        RawVisibility::Module(ModPath::from_kind(PathKind::Super(0)))
     }
 
     pub(crate) fn from_ast(
@@ -59,15 +58,15 @@ impl RawVisibility {
                 RawVisibility::Module(path)
             }
             ast::VisibilityKind::PubCrate => {
-                let path = ModPath { kind: PathKind::Crate, segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Crate);
                 RawVisibility::Module(path)
             }
             ast::VisibilityKind::PubSuper => {
-                let path = ModPath { kind: PathKind::Super(1), segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Super(1));
                 RawVisibility::Module(path)
             }
             ast::VisibilityKind::PubSelf => {
-                let path = ModPath { kind: PathKind::Plain, segments: Vec::new() };
+                let path = ModPath::from_kind(PathKind::Plain);
                 RawVisibility::Module(path)
             }
             ast::VisibilityKind::Pub => RawVisibility::Public,
@@ -103,8 +102,8 @@ impl Visibility {
         if from_module.krate != to_module.krate {
             return false;
         }
-        let def_map = db.crate_def_map(from_module.krate);
-        self.is_visible_from_def_map(&def_map, from_module.local_id)
+        let def_map = from_module.def_map(db);
+        self.is_visible_from_def_map(db, &def_map, from_module.local_id)
     }
 
     pub(crate) fn is_visible_from_other_crate(self) -> bool {
@@ -116,26 +115,48 @@ impl Visibility {
 
     pub(crate) fn is_visible_from_def_map(
         self,
-        def_map: &CrateDefMap,
-        from_module: crate::LocalModuleId,
+        db: &dyn DefDatabase,
+        def_map: &DefMap,
+        mut from_module: crate::LocalModuleId,
     ) -> bool {
         let to_module = match self {
             Visibility::Module(m) => m,
             Visibility::Public => return true,
         };
+
         // from_module needs to be a descendant of to_module
-        let mut ancestors = std::iter::successors(Some(from_module), |m| {
-            let parent_id = def_map[*m].parent?;
-            Some(parent_id)
-        });
-        ancestors.any(|m| m == to_module.local_id)
+        let mut def_map = def_map;
+        let mut parent_arc;
+        loop {
+            if def_map.module_id(from_module) == to_module {
+                return true;
+            }
+            match def_map[from_module].parent {
+                Some(parent) => {
+                    from_module = parent;
+                }
+                None => {
+                    match def_map.parent() {
+                        Some(module) => {
+                            parent_arc = module.def_map(db);
+                            def_map = &*parent_arc;
+                            from_module = module.local_id;
+                        }
+                        None => {
+                            // Reached the root module, nothing left to check.
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
     }
 
     /// Returns the most permissive visibility of `self` and `other`.
     ///
     /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
     /// visible in unrelated modules).
-    pub(crate) fn max(self, other: Visibility, def_map: &CrateDefMap) -> Option<Visibility> {
+    pub(crate) fn max(self, other: Visibility, def_map: &DefMap) -> Option<Visibility> {
         match (self, other) {
             (Visibility::Module(_), Visibility::Public)
             | (Visibility::Public, Visibility::Module(_))