1 files changed, 32 insertions, 14 deletions

diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index fdcdc23ae..db459b1ed 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -13,7 +13,6 @@
 use base_db::Edition;
 use hir_expand::name;
 use hir_expand::name::Name;
-use test_utils::mark;
 
 use crate::{
     db::DefDatabase,
@@ -63,7 +62,7 @@ impl ResolvePathResult {
 impl DefMap {
     pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
         if name == &name!(self) {
-            mark::hit!(extern_crate_self_as);
+            cov_mark::hit!(extern_crate_self_as);
             return PerNs::types(self.module_id(self.root).into(), Visibility::Public);
         }
         self.extern_prelude
@@ -77,7 +76,7 @@ impl DefMap {
         original_module: LocalModuleId,
         visibility: &RawVisibility,
     ) -> Option<Visibility> {
-        match visibility {
+        let mut vis = match visibility {
             RawVisibility::Module(path) => {
                 let (result, remaining) =
                     self.resolve_path(db, original_module, &path, BuiltinShadowMode::Module);
@@ -86,15 +85,28 @@ impl DefMap {
                 }
                 let types = result.take_types()?;
                 match types {
-                    ModuleDefId::ModuleId(m) => Some(Visibility::Module(m)),
+                    ModuleDefId::ModuleId(m) => Visibility::Module(m),
                     _ => {
                         // error: visibility needs to refer to module
-                        None
+                        return None;
                     }
                 }
             }
-            RawVisibility::Public => Some(Visibility::Public),
+            RawVisibility::Public => Visibility::Public,
+        };
+
+        // 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) = vis {
+            if self.block_id() != m.block {
+                cov_mark::hit!(adjust_vis_in_block_def_map);
+                vis = Visibility::Module(self.module_id(self.root()));
+                log::debug!("visibility {:?} points outside DefMap, adjusting to {:?}", m, vis);
+            }
         }
+
+        Some(vis)
     }
 
     // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
@@ -144,7 +156,7 @@ impl DefMap {
         }
     }
 
-    pub(super) fn resolve_path_fp_with_macro_single(
+    fn resolve_path_fp_with_macro_single(
         &self,
         db: &dyn DefDatabase,
         mode: ResolveMode,
@@ -156,12 +168,12 @@ impl DefMap {
         let mut curr_per_ns: PerNs = match path.kind {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
-                    mark::hit!(macro_dollar_crate_self);
+                    cov_mark::hit!(macro_dollar_crate_self);
                     PerNs::types(self.crate_root(db).into(), Visibility::Public)
                 } else {
                     let def_map = db.crate_def_map(krate);
                     let module = def_map.module_id(def_map.root);
-                    mark::hit!(macro_dollar_crate_other);
+                    cov_mark::hit!(macro_dollar_crate_other);
                     PerNs::types(module.into(), Visibility::Public)
                 }
             }
@@ -297,7 +309,7 @@ impl DefMap {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
                     // enum variant
-                    mark::hit!(can_import_enum_variant);
+                    cov_mark::hit!(can_import_enum_variant);
                     let enum_data = db.enum_data(e);
                     match enum_data.variant(&segment) {
                         Some(local_id) => {
@@ -372,10 +384,16 @@ impl DefMap {
                 }
             }
         };
-        let from_extern_prelude = self
-            .extern_prelude
-            .get(name)
-            .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public));
+        // Give precedence to names in outer `DefMap`s over the extern prelude; only check prelude
+        // from the crate DefMap.
+        let from_extern_prelude = match self.block {
+            Some(_) => PerNs::none(),
+            None => self
+                .extern_prelude
+                .get(name)
+                .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public)),
+        };
+
         let from_prelude = self.resolve_in_prelude(db, name);
 
         from_legacy_macro.or(from_scope_or_builtin).or(from_extern_prelude).or(from_prelude)