1 files changed, 126 insertions, 37 deletions

diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index 88e10574e..dd1db0094 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -10,20 +10,19 @@
 //!
 //! `ReachedFixedPoint` signals about this.
 
-use std::iter::successors;
-
 use base_db::Edition;
+use hir_expand::name;
 use hir_expand::name::Name;
 use test_utils::mark;
 
 use crate::{
     db::DefDatabase,
     item_scope::BUILTIN_SCOPE,
-    nameres::{BuiltinShadowMode, CrateDefMap},
+    nameres::{BuiltinShadowMode, DefMap},
     path::{ModPath, PathKind},
     per_ns::PerNs,
     visibility::{RawVisibility, Visibility},
-    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
+    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -61,8 +60,12 @@ impl ResolvePathResult {
     }
 }
 
-impl CrateDefMap {
+impl DefMap {
     pub(super) fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
+        if name == &name!(self) {
+            mark::hit!(extern_crate_self_as);
+            return PerNs::types(self.module_id(self.root).into(), Visibility::Public);
+        }
         self.extern_prelude
             .get(name)
             .map_or(PerNs::none(), |&it| PerNs::types(it, Visibility::Public))
@@ -74,7 +77,7 @@ impl CrateDefMap {
         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);
@@ -83,15 +86,28 @@ impl CrateDefMap {
                 }
                 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 {
+                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
@@ -100,30 +116,69 @@ impl CrateDefMap {
         &self,
         db: &dyn DefDatabase,
         mode: ResolveMode,
+        mut original_module: LocalModuleId,
+        path: &ModPath,
+        shadow: BuiltinShadowMode,
+    ) -> ResolvePathResult {
+        let mut result = ResolvePathResult::empty(ReachedFixedPoint::No);
+
+        let mut arc;
+        let mut current_map = self;
+        loop {
+            let new = current_map.resolve_path_fp_with_macro_single(
+                db,
+                mode,
+                original_module,
+                path,
+                shadow,
+            );
+
+            // Merge `new` into `result`.
+            result.resolved_def = result.resolved_def.or(new.resolved_def);
+            if result.reached_fixedpoint == ReachedFixedPoint::No {
+                result.reached_fixedpoint = new.reached_fixedpoint;
+            }
+            // FIXME: this doesn't seem right; what if the different namespace resolutions come from different crates?
+            result.krate = result.krate.or(new.krate);
+            result.segment_index = match (result.segment_index, new.segment_index) {
+                (Some(idx), None) => Some(idx),
+                (Some(old), Some(new)) => Some(old.max(new)),
+                (None, new) => new,
+            };
+
+            match &current_map.block {
+                Some(block) => {
+                    original_module = block.parent.local_id;
+                    arc = block.parent.def_map(db);
+                    current_map = &*arc;
+                }
+                None => return result,
+            }
+        }
+    }
+
+    pub(super) fn resolve_path_fp_with_macro_single(
+        &self,
+        db: &dyn DefDatabase,
+        mode: ResolveMode,
         original_module: LocalModuleId,
         path: &ModPath,
         shadow: BuiltinShadowMode,
     ) -> ResolvePathResult {
-        let mut segments = path.segments.iter().enumerate();
+        let mut segments = path.segments().iter().enumerate();
         let mut curr_per_ns: PerNs = match path.kind {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
                     mark::hit!(macro_dollar_crate_self);
-                    PerNs::types(
-                        ModuleId { krate: self.krate, local_id: self.root }.into(),
-                        Visibility::Public,
-                    )
+                    PerNs::types(self.crate_root(db).into(), Visibility::Public)
                 } else {
                     let def_map = db.crate_def_map(krate);
-                    let module = ModuleId { krate, local_id: def_map.root };
+                    let module = def_map.module_id(def_map.root);
                     mark::hit!(macro_dollar_crate_other);
                     PerNs::types(module.into(), Visibility::Public)
                 }
             }
-            PathKind::Crate => PerNs::types(
-                ModuleId { krate: self.krate, local_id: self.root }.into(),
-                Visibility::Public,
-            ),
+            PathKind::Crate => PerNs::types(self.crate_root(db).into(), Visibility::Public),
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
@@ -151,23 +206,49 @@ impl CrateDefMap {
                 // BuiltinShadowMode wasn't Module, then we need to try
                 // resolving it as a builtin.
                 let prefer_module =
-                    if path.segments.len() == 1 { shadow } else { BuiltinShadowMode::Module };
+                    if path.segments().len() == 1 { shadow } else { BuiltinShadowMode::Module };
 
                 log::debug!("resolving {:?} in module", segment);
                 self.resolve_name_in_module(db, original_module, &segment, prefer_module)
             }
             PathKind::Super(lvl) => {
-                let m = successors(Some(original_module), |m| self.modules[*m].parent)
-                    .nth(lvl as usize);
-                if let Some(local_id) = m {
-                    PerNs::types(
-                        ModuleId { krate: self.krate, local_id }.into(),
-                        Visibility::Public,
-                    )
-                } else {
-                    log::debug!("super path in root module");
-                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                let mut module = original_module;
+                for i in 0..lvl {
+                    match self.modules[module].parent {
+                        Some(it) => module = it,
+                        None => match &self.block {
+                            Some(block) => {
+                                // Look up remaining path in parent `DefMap`
+                                let new_path = ModPath::from_segments(
+                                    PathKind::Super(lvl - i),
+                                    path.segments().to_vec(),
+                                );
+                                log::debug!("`super` path: {} -> {} in parent map", path, new_path);
+                                return block.parent.def_map(db).resolve_path_fp_with_macro(
+                                    db,
+                                    mode,
+                                    block.parent.local_id,
+                                    &new_path,
+                                    shadow,
+                                );
+                            }
+                            None => {
+                                log::debug!("super path in root module");
+                                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                            }
+                        },
+                    }
                 }
+
+                // Resolve `self` to the containing crate-rooted module if we're a block
+                self.with_ancestor_maps(db, module, &mut |def_map, module| {
+                    if def_map.block.is_some() {
+                        None // keep ascending
+                    } else {
+                        Some(PerNs::types(def_map.module_id(module).into(), Visibility::Public))
+                    }
+                })
+                .expect("block DefMap not rooted in crate DefMap")
             }
             PathKind::Abs => {
                 // 2018-style absolute path -- only extern prelude
@@ -201,12 +282,12 @@ impl CrateDefMap {
             curr_per_ns = match curr {
                 ModuleDefId::ModuleId(module) => {
                     if module.krate != self.krate {
-                        let path = ModPath {
-                            segments: path.segments[i..].to_vec(),
-                            kind: PathKind::Super(0),
-                        };
+                        let path = ModPath::from_segments(
+                            PathKind::Super(0),
+                            path.segments()[i..].iter().cloned(),
+                        );
                         log::debug!("resolving {:?} in other crate", path);
-                        let defp_map = db.crate_def_map(module.krate);
+                        let defp_map = module.def_map(db);
                         let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
                         return ResolvePathResult::with(
                             def,
@@ -216,8 +297,16 @@ impl CrateDefMap {
                         );
                     }
 
+                    let def_map;
+                    let module_data = if module.block == self.block_id() {
+                        &self[module.local_id]
+                    } else {
+                        def_map = module.def_map(db);
+                        &def_map[module.local_id]
+                    };
+
                     // Since it is a qualified path here, it should not contains legacy macros
-                    self[module.local_id].scope.get(&segment)
+                    module_data.scope.get(&segment)
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
                     // enum variant
@@ -319,7 +408,7 @@ impl CrateDefMap {
                 self
             } else {
                 // Extend lifetime
-                keep = db.crate_def_map(prelude.krate);
+                keep = prelude.def_map(db);
                 &keep
             };
             def_map[prelude.local_id].scope.get(name)