1 files changed, 252 insertions, 491 deletions

diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 73919ee37..edd2f25f7 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -1,60 +1,148 @@
-//! Name resolution algorithm. The end result of the algorithm is an `ItemMap`:
-//! a map which maps each module to its scope: the set of items visible in the
-//! module. That is, we only resolve imports here, name resolution of item
-//! bodies will be done in a separate step.
-//!
-//! Like Rustc, we use an interactive per-crate algorithm: we start with scopes
-//! containing only directly defined items, and then iteratively resolve
-//! imports.
-//!
-//! To make this work nicely in the IDE scenario, we place `InputModuleItems`
-//! in between raw syntax and name resolution. `InputModuleItems` are computed
-//! using only the module's syntax, and it is all directly defined items plus
-//! imports. The plan is to make `InputModuleItems` independent of local
-//! modifications (that is, typing inside a function should not change IMIs),
-//! so that the results of name resolution can be preserved unless the module
-//! structure itself is modified.
-pub(crate) mod lower;
-
-use std::{time, sync::Arc};
-
-use rustc_hash::{FxHashMap, FxHashSet};
-
-use ra_arena::map::ArenaMap;
-use ra_db::Edition;
+/// This module implements import-resolution/macro expansion algorithm.
+///
+/// The result of this module is `CrateDefMap`: a datastructure which contains:
+///
+///   * a tree of modules for the crate
+///   * for each module, a set of items visible in the module (directly declared
+///     or imported)
+///
+/// Note that `CrateDefMap` contains fully macro expanded code.
+///
+/// Computing `CrateDefMap` can be partitioned into several logically
+/// independent "phases". The phases are mutually recursive though, there's no
+/// strict ordering.
+///
+/// ## Collecting RawItems
+///
+///  This happens in the `raw` module, which parses a single source file into a
+///  set of top-level items. Nested imports are desugared to flat imports in
+///  this phase. Macro calls are represented as a triple of (Path, Option<Name>,
+///  TokenTree).
+///
+/// ## Collecting Modules
+///
+/// This happens in the `collector` module. In this phase, we recursively walk
+/// tree of modules, collect raw items from submodules, populate module scopes
+/// with defined items (so, we assign item ids in this phase) and record the set
+/// of unresolved imports and macros.
+///
+/// While we walk tree of modules, we also record macro_rules definitions and
+/// expand calls to macro_rules defined macros.
+///
+/// ## Resolving Imports
+///
+/// We maintain a list of currently unresolved imports. On every iteration, we
+/// try to resolve some imports from this list. If the import is resolved, we
+/// record it, by adding an item to current module scope and, if necessary, by
+/// recursively populating glob imports.
+///
+/// ## Resolving Macros
+///
+/// macro_rules from the same crate use a global mutable namespace. We expand
+/// them immediately, when we collect modules.
+///
+/// Macros from other crates (including proc-macros) can be used with
+/// `foo::bar!` syntax. We handle them similarly to imports. There's a list of
+/// unexpanded macros. On every iteration, we try to resolve each macro call
+/// path and, upon success, we run macro expansion and "collect module" phase
+/// on the result
+
+mod per_ns;
+mod raw;
+mod collector;
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use rustc_hash::FxHashMap;
+use ra_arena::{Arena, RawId, impl_arena_id};
+use ra_db::{FileId, Edition};
 use test_utils::tested_by;
 
 use crate::{
-    Module, ModuleDef,
-    Path, PathKind, PersistentHirDatabase,
-    Crate, Name,
-    module_tree::{ModuleId, ModuleTree},
-    nameres::lower::{ImportId, LoweredModule, ImportData},
+    ModuleDef, Name, Crate, Module, Problem,
+    PersistentHirDatabase, Path, PathKind, HirFileId,
+    ids::{SourceItemId, SourceFileItemId, MacroCallId},
 };
 
-/// `ItemMap` is the result of module name resolution. It contains, for each
-/// module, the set of visible items.
+pub(crate) use self::raw::{RawItems, ImportId, ImportSourceMap};
+
+pub use self::per_ns::{PerNs, Namespace};
+
+/// Contans all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
-pub struct ItemMap {
+pub struct CrateDefMap {
+    krate: Crate,
     edition: Edition,
     /// The prelude module for this crate. This either comes from an import
     /// marked with the `prelude_import` attribute, or (in the normal case) from
     /// a dependency (`std` or `core`).
-    pub(crate) prelude: Option<Module>,
-    pub(crate) extern_prelude: FxHashMap<Name, ModuleDef>,
-    per_module: ArenaMap<ModuleId, ModuleScope>,
+    prelude: Option<Module>,
+    extern_prelude: FxHashMap<Name, ModuleDef>,
+    root: CrateModuleId,
+    modules: Arena<CrateModuleId, ModuleData>,
+    macros: Arena<CrateMacroId, mbe::MacroRules>,
+    public_macros: FxHashMap<Name, CrateMacroId>,
+    macro_resolutions: FxHashMap<MacroCallId, (Crate, CrateMacroId)>,
+    problems: CrateDefMapProblems,
+}
+
+impl std::ops::Index<CrateModuleId> for CrateDefMap {
+    type Output = ModuleData;
+    fn index(&self, id: CrateModuleId) -> &ModuleData {
+        &self.modules[id]
+    }
+}
+
+impl std::ops::Index<CrateMacroId> for CrateDefMap {
+    type Output = mbe::MacroRules;
+    fn index(&self, id: CrateMacroId) -> &mbe::MacroRules {
+        &self.macros[id]
+    }
+}
+
+/// An ID of a macro, **local** to a specific crate
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct CrateMacroId(RawId);
+impl_arena_id!(CrateMacroId);
+
+/// An ID of a module, **local** to a specific crate
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct CrateModuleId(RawId);
+impl_arena_id!(CrateModuleId);
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub(crate) struct ModuleData {
+    pub(crate) parent: Option<CrateModuleId>,
+    pub(crate) children: FxHashMap<Name, CrateModuleId>,
+    pub(crate) scope: ModuleScope,
+    /// None for root
+    pub(crate) declaration: Option<SourceItemId>,
+    /// None for inline modules.
+    ///
+    /// Note that non-inline modules, by definition, live inside non-macro file.
+    pub(crate) definition: Option<FileId>,
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub(crate) struct CrateDefMapProblems {
+    problems: Vec<(SourceItemId, Problem)>,
 }
 
-impl std::ops::Index<ModuleId> for ItemMap {
-    type Output = ModuleScope;
-    fn index(&self, id: ModuleId) -> &ModuleScope {
-        &self.per_module[id]
+impl CrateDefMapProblems {
+    fn add(&mut self, source_item_id: SourceItemId, problem: Problem) {
+        self.problems.push((source_item_id, problem))
+    }
+
+    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (&'a SourceItemId, &'a Problem)> + 'a {
+        self.problems.iter().map(|(s, p)| (s, p))
     }
 }
 
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub struct ModuleScope {
-    pub(crate) items: FxHashMap<Name, Resolution>,
+    items: FxHashMap<Name, Resolution>,
 }
 
 impl ModuleScope {
@@ -66,8 +154,6 @@ impl ModuleScope {
     }
 }
 
-/// `Resolution` is basically `DefId` atm, but it should account for stuff like
-/// multiple namespaces, ambiguity and errors.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct Resolution {
     /// None for unresolved
@@ -76,372 +162,6 @@ pub struct Resolution {
     pub import: Option<ImportId>,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Namespace {
-    Types,
-    Values,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct PerNs<T> {
-    pub types: Option<T>,
-    pub values: Option<T>,
-}
-
-impl<T> Default for PerNs<T> {
-    fn default() -> Self {
-        PerNs { types: None, values: None }
-    }
-}
-
-impl<T> PerNs<T> {
-    pub fn none() -> PerNs<T> {
-        PerNs { types: None, values: None }
-    }
-
-    pub fn values(t: T) -> PerNs<T> {
-        PerNs { types: None, values: Some(t) }
-    }
-
-    pub fn types(t: T) -> PerNs<T> {
-        PerNs { types: Some(t), values: None }
-    }
-
-    pub fn both(types: T, values: T) -> PerNs<T> {
-        PerNs { types: Some(types), values: Some(values) }
-    }
-
-    pub fn is_none(&self) -> bool {
-        self.types.is_none() && self.values.is_none()
-    }
-
-    pub fn is_both(&self) -> bool {
-        self.types.is_some() && self.values.is_some()
-    }
-
-    pub fn take(self, namespace: Namespace) -> Option<T> {
-        match namespace {
-            Namespace::Types => self.types,
-            Namespace::Values => self.values,
-        }
-    }
-
-    pub fn take_types(self) -> Option<T> {
-        self.take(Namespace::Types)
-    }
-
-    pub fn take_values(self) -> Option<T> {
-        self.take(Namespace::Values)
-    }
-
-    pub fn get(&self, namespace: Namespace) -> Option<&T> {
-        self.as_ref().take(namespace)
-    }
-
-    pub fn as_ref(&self) -> PerNs<&T> {
-        PerNs { types: self.types.as_ref(), values: self.values.as_ref() }
-    }
-
-    pub fn or(self, other: PerNs<T>) -> PerNs<T> {
-        PerNs { types: self.types.or(other.types), values: self.values.or(other.values) }
-    }
-
-    pub fn and_then<U>(self, f: impl Fn(T) -> Option<U>) -> PerNs<U> {
-        PerNs { types: self.types.and_then(&f), values: self.values.and_then(&f) }
-    }
-
-    pub fn map<U>(self, f: impl Fn(T) -> U) -> PerNs<U> {
-        PerNs { types: self.types.map(&f), values: self.values.map(&f) }
-    }
-}
-
-struct Resolver<'a, DB> {
-    db: &'a DB,
-    input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-    krate: Crate,
-    module_tree: Arc<ModuleTree>,
-    processed_imports: FxHashSet<(ModuleId, ImportId)>,
-    /// If module `a` has `use b::*`, then this contains the mapping b -> a (and the import)
-    glob_imports: FxHashMap<ModuleId, Vec<(ModuleId, ImportId)>>,
-    result: ItemMap,
-}
-
-impl<'a, DB> Resolver<'a, DB>
-where
-    DB: PersistentHirDatabase,
-{
-    fn new(
-        db: &'a DB,
-        input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-        krate: Crate,
-    ) -> Resolver<'a, DB> {
-        let module_tree = db.module_tree(krate);
-        Resolver {
-            db,
-            input,
-            krate,
-            module_tree,
-            processed_imports: FxHashSet::default(),
-            glob_imports: FxHashMap::default(),
-            result: ItemMap {
-                edition: krate.edition(db),
-                prelude: None,
-                extern_prelude: FxHashMap::default(),
-                per_module: ArenaMap::default(),
-            },
-        }
-    }
-
-    pub(crate) fn resolve(mut self) -> ItemMap {
-        self.populate_extern_prelude();
-        for (&module_id, items) in self.input.iter() {
-            self.populate_module(module_id, Arc::clone(items));
-        }
-
-        let mut iter = 0;
-        loop {
-            iter += 1;
-            if iter > 1000 {
-                panic!("failed to reach fixedpoint after 1000 iters")
-            }
-            let processed_imports_count = self.processed_imports.len();
-            for &module_id in self.input.keys() {
-                self.db.check_canceled();
-                self.resolve_imports(module_id);
-            }
-            if processed_imports_count == self.processed_imports.len() {
-                // no new imports resolved
-                break;
-            }
-        }
-        self.result
-    }
-
-    fn populate_extern_prelude(&mut self) {
-        for dep in self.krate.dependencies(self.db) {
-            log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate);
-            if let Some(module) = dep.krate.root_module(self.db) {
-                self.result.extern_prelude.insert(dep.name.clone(), module.into());
-            }
-            // look for the prelude
-            if self.result.prelude.is_none() {
-                let item_map = self.db.item_map(dep.krate);
-                if item_map.prelude.is_some() {
-                    self.result.prelude = item_map.prelude;
-                }
-            }
-        }
-    }
-
-    fn populate_module(&mut self, module_id: ModuleId, input: Arc<LoweredModule>) {
-        let mut module_items = ModuleScope::default();
-        for (import_id, import_data) in input.imports.iter() {
-            if let Some(last_segment) = import_data.path.segments.iter().last() {
-                if !import_data.is_glob {
-                    let name =
-                        import_data.alias.clone().unwrap_or_else(|| last_segment.name.clone());
-                    module_items
-                        .items
-                        .insert(name, Resolution { def: PerNs::none(), import: Some(import_id) });
-                }
-            }
-        }
-        // Populate explicitly declared items, except modules
-        for (name, &def) in input.declarations.iter() {
-            let resolution = Resolution { def, import: None };
-            module_items.items.insert(name.clone(), resolution);
-        }
-
-        // Populate modules
-        for (name, module_id) in module_id.children(&self.module_tree) {
-            let module = Module { module_id, krate: self.krate };
-            self.add_module_item(&mut module_items, name, PerNs::types(module.into()));
-        }
-
-        self.result.per_module.insert(module_id, module_items);
-    }
-
-    fn add_module_item(&self, module_items: &mut ModuleScope, name: Name, def: PerNs<ModuleDef>) {
-        let resolution = Resolution { def, import: None };
-        module_items.items.insert(name, resolution);
-    }
-
-    fn resolve_imports(&mut self, module_id: ModuleId) {
-        for (import_id, import_data) in self.input[&module_id].imports.iter() {
-            if self.processed_imports.contains(&(module_id, import_id)) {
-                // already done
-                continue;
-            }
-            if self.resolve_import(module_id, import_id, import_data) == ReachedFixedPoint::Yes {
-                log::debug!("import {:?} resolved (or definite error)", import_id);
-                self.processed_imports.insert((module_id, import_id));
-            }
-        }
-    }
-
-    fn resolve_import(
-        &mut self,
-        module_id: ModuleId,
-        import_id: ImportId,
-        import: &ImportData,
-    ) -> ReachedFixedPoint {
-        log::debug!("resolving import: {:?} ({:?})", import, self.result.edition);
-        let original_module = Module { krate: self.krate, module_id };
-
-        let (def, reached_fixedpoint) = if import.is_extern_crate {
-            let res = self.result.resolve_name_in_extern_prelude(
-                &import
-                    .path
-                    .as_ident()
-                    .expect("extern crate should have been desugared to one-element path"),
-            );
-            (res, if res.is_none() { ReachedFixedPoint::No } else { ReachedFixedPoint::Yes })
-        } else {
-            let res = self.result.resolve_path_fp(
-                self.db,
-                ResolveMode::Import,
-                original_module,
-                &import.path,
-            );
-
-            (res.resolved_def, res.reached_fixedpoint)
-        };
-
-        if reached_fixedpoint != ReachedFixedPoint::Yes {
-            return reached_fixedpoint;
-        }
-
-        if import.is_glob {
-            log::debug!("glob import: {:?}", import);
-            match def.take_types() {
-                Some(ModuleDef::Module(m)) => {
-                    if import.is_prelude {
-                        tested_by!(std_prelude);
-                        self.result.prelude = Some(m);
-                    } else if m.krate != self.krate {
-                        tested_by!(glob_across_crates);
-                        // glob import from other crate => we can just import everything once
-                        let item_map = self.db.item_map(m.krate);
-                        let scope = &item_map[m.module_id];
-                        let items = scope
-                            .items
-                            .iter()
-                            .map(|(name, res)| (name.clone(), res.clone()))
-                            .collect::<Vec<_>>();
-                        self.update(module_id, Some(import_id), &items);
-                    } else {
-                        // glob import from same crate => we do an initial
-                        // import, and then need to propagate any further
-                        // additions
-                        let scope = &self.result[m.module_id];
-                        let items = scope
-                            .items
-                            .iter()
-                            .map(|(name, res)| (name.clone(), res.clone()))
-                            .collect::<Vec<_>>();
-                        self.update(module_id, Some(import_id), &items);
-                        // record the glob import in case we add further items
-                        self.glob_imports
-                            .entry(m.module_id)
-                            .or_default()
-                            .push((module_id, import_id));
-                    }
-                }
-                Some(ModuleDef::Enum(e)) => {
-                    tested_by!(glob_enum);
-                    // glob import from enum => just import all the variants
-                    let variants = e.variants(self.db);
-                    let resolutions = variants
-                        .into_iter()
-                        .filter_map(|variant| {
-                            let res = Resolution {
-                                def: PerNs::both(variant.into(), variant.into()),
-                                import: Some(import_id),
-                            };
-                            let name = variant.name(self.db)?;
-                            Some((name, res))
-                        })
-                        .collect::<Vec<_>>();
-                    self.update(module_id, Some(import_id), &resolutions);
-                }
-                Some(d) => {
-                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
-                }
-                None => {
-                    log::debug!("glob import {:?} didn't resolve as type", import);
-                }
-            }
-        } else {
-            let last_segment = import.path.segments.last().unwrap();
-            let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone());
-            log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
-
-            // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
-            if let Some(root_module) = self.krate.root_module(self.db) {
-                if import.is_extern_crate && module_id == root_module.module_id {
-                    if let Some(def) = def.take_types() {
-                        self.result.extern_prelude.insert(name.clone(), def);
-                    }
-                }
-            }
-            let resolution = Resolution { def, import: Some(import_id) };
-            self.update(module_id, None, &[(name, resolution)]);
-        }
-        reached_fixedpoint
-    }
-
-    fn update(
-        &mut self,
-        module_id: ModuleId,
-        import: Option<ImportId>,
-        resolutions: &[(Name, Resolution)],
-    ) {
-        self.update_recursive(module_id, import, resolutions, 0)
-    }
-
-    fn update_recursive(
-        &mut self,
-        module_id: ModuleId,
-        import: Option<ImportId>,
-        resolutions: &[(Name, Resolution)],
-        depth: usize,
-    ) {
-        if depth > 100 {
-            // prevent stack overflows (but this shouldn't be possible)
-            panic!("infinite recursion in glob imports!");
-        }
-        let module_items = self.result.per_module.get_mut(module_id).unwrap();
-        let mut changed = false;
-        for (name, res) in resolutions {
-            let existing = module_items.items.entry(name.clone()).or_default();
-            if existing.def.types.is_none() && res.def.types.is_some() {
-                existing.def.types = res.def.types;
-                existing.import = import.or(res.import);
-                changed = true;
-            }
-            if existing.def.values.is_none() && res.def.values.is_some() {
-                existing.def.values = res.def.values;
-                existing.import = import.or(res.import);
-                changed = true;
-            }
-        }
-        if !changed {
-            return;
-        }
-        let glob_imports = self
-            .glob_imports
-            .get(&module_id)
-            .into_iter()
-            .flat_map(|v| v.iter())
-            .cloned()
-            .collect::<Vec<_>>();
-        for (glob_importing_module, glob_import) in glob_imports {
-            // We pass the glob import so that the tracked import in those modules is that glob import
-            self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1);
-        }
-    }
-}
-
 #[derive(Debug, Clone)]
 struct ResolvePathResult {
     resolved_def: PerNs<ModuleDef>,
@@ -475,84 +195,85 @@ enum ReachedFixedPoint {
     No,
 }
 
-impl ItemMap {
-    pub(crate) fn item_map_query(db: &impl PersistentHirDatabase, krate: Crate) -> Arc<ItemMap> {
-        let start = time::Instant::now();
-        let module_tree = db.module_tree(krate);
-        let input = module_tree
-            .modules()
-            .map(|module_id| (module_id, db.lower_module(Module { krate, module_id })))
-            .collect::<FxHashMap<_, _>>();
-
-        let resolver = Resolver::new(db, &input, krate);
-        let res = resolver.resolve();
-        let elapsed = start.elapsed();
-        log::info!("item_map: {:?}", elapsed);
-        Arc::new(res)
+impl CrateDefMap {
+    pub(crate) fn crate_def_map_query(
+        db: &impl PersistentHirDatabase,
+        krate: Crate,
+    ) -> Arc<CrateDefMap> {
+        let start = std::time::Instant::now();
+        let def_map = {
+            let edition = krate.edition(db);
+            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+            let root = modules.alloc(ModuleData::default());
+            CrateDefMap {
+                krate,
+                edition,
+                extern_prelude: FxHashMap::default(),
+                prelude: None,
+                root,
+                modules,
+                macros: Arena::default(),
+                public_macros: FxHashMap::default(),
+                macro_resolutions: FxHashMap::default(),
+                problems: CrateDefMapProblems::default(),
+            }
+        };
+        let def_map = collector::collect_defs(db, def_map);
+        log::info!("crate_def_map_query: {:?}", start.elapsed());
+        Arc::new(def_map)
     }
 
-    pub(crate) fn resolve_path(
-        &self,
-        db: &impl PersistentHirDatabase,
-        original_module: Module,
-        path: &Path,
-    ) -> (PerNs<ModuleDef>, Option<usize>) {
-        let res = self.resolve_path_fp(db, ResolveMode::Other, original_module, path);
-        (res.resolved_def, res.segment_index)
+    pub(crate) fn root(&self) -> CrateModuleId {
+        self.root
     }
 
-    fn resolve_in_prelude(
-        &self,
-        db: &impl PersistentHirDatabase,
-        original_module: Module,
-        name: &Name,
-    ) -> PerNs<ModuleDef> {
-        if let Some(prelude) = self.prelude {
-            let resolution = if prelude.krate == original_module.krate {
-                self[prelude.module_id].items.get(name).cloned()
-            } else {
-                db.item_map(prelude.krate)[prelude.module_id].items.get(name).cloned()
-            };
-            resolution.map(|r| r.def).unwrap_or_else(PerNs::none)
-        } else {
-            PerNs::none()
-        }
+    pub(crate) fn problems(&self) -> &CrateDefMapProblems {
+        &self.problems
     }
 
-    pub(crate) fn resolve_name_in_module(
-        &self,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        name: &Name,
-    ) -> PerNs<ModuleDef> {
-        // Resolve in:
-        //  - current module / scope
-        //  - extern prelude
-        //  - std prelude
-        let from_scope = self[module.module_id].items.get(name).map_or(PerNs::none(), |it| it.def);
-        let from_extern_prelude =
-            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
-        let from_prelude = self.resolve_in_prelude(db, module, name);
+    pub(crate) fn mk_module(&self, module_id: CrateModuleId) -> Module {
+        Module { krate: self.krate, module_id }
+    }
 
-        from_scope.or(from_extern_prelude).or(from_prelude)
+    pub(crate) fn prelude(&self) -> Option<Module> {
+        self.prelude
     }
 
-    fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
-        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+    pub(crate) fn extern_prelude(&self) -> &FxHashMap<Name, ModuleDef> {
+        &self.extern_prelude
     }
 
-    fn resolve_name_in_crate_root_or_extern_prelude(
+    pub(crate) fn resolve_macro(
         &self,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        name: &Name,
-    ) -> PerNs<ModuleDef> {
-        let crate_root = module.crate_root(db);
-        let from_crate_root =
-            self[crate_root.module_id].items.get(name).map_or(PerNs::none(), |it| it.def);
-        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
+        macro_call_id: MacroCallId,
+    ) -> Option<(Crate, CrateMacroId)> {
+        self.macro_resolutions.get(&macro_call_id).map(|&it| it)
+    }
 
-        from_crate_root.or(from_extern_prelude)
+    pub(crate) fn find_module_by_source(
+        &self,
+        file_id: HirFileId,
+        decl_id: Option<SourceFileItemId>,
+    ) -> Option<CrateModuleId> {
+        let decl_id = decl_id.map(|it| it.with_file_id(file_id));
+        let (module_id, _module_data) = self.modules.iter().find(|(_module_id, module_data)| {
+            if decl_id.is_some() {
+                module_data.declaration == decl_id
+            } else {
+                module_data.definition.map(|it| it.into()) == Some(file_id)
+            }
+        })?;
+        Some(module_id)
+    }
+
+    pub(crate) fn resolve_path(
+        &self,
+        db: &impl PersistentHirDatabase,
+        original_module: CrateModuleId,
+        path: &Path,
+    ) -> (PerNs<ModuleDef>, Option<usize>) {
+        let res = self.resolve_path_fp(db, ResolveMode::Other, original_module, path);
+        (res.resolved_def, res.segment_index)
     }
 
     // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
@@ -561,13 +282,17 @@ impl ItemMap {
         &self,
         db: &impl PersistentHirDatabase,
         mode: ResolveMode,
-        original_module: Module,
+        original_module: CrateModuleId,
         path: &Path,
     ) -> ResolvePathResult {
         let mut segments = path.segments.iter().enumerate();
         let mut curr_per_ns: PerNs<ModuleDef> = match path.kind {
-            PathKind::Crate => PerNs::types(original_module.crate_root(db).into()),
-            PathKind::Self_ => PerNs::types(original_module.into()),
+            PathKind::Crate => {
+                PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
+            }
+            PathKind::Self_ => {
+                PerNs::types(Module { krate: self.krate, module_id: original_module }.into())
+            }
             // plain import or absolute path in 2015: crate-relative with
             // fallback to extern prelude (with the simplification in
             // rust-lang/rust#57745)
@@ -581,11 +306,7 @@ impl ItemMap {
                     None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                 };
                 log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(
-                    db,
-                    original_module,
-                    &segment.name,
-                )
+                self.resolve_name_in_crate_root_or_extern_prelude(&segment.name)
             }
             PathKind::Plain => {
                 let segment = match segments.next() {
@@ -596,8 +317,8 @@ impl ItemMap {
                 self.resolve_name_in_module(db, original_module, &segment.name)
             }
             PathKind::Super => {
-                if let Some(p) = original_module.parent(db) {
-                    PerNs::types(p.into())
+                if let Some(p) = self.modules[original_module].parent {
+                    PerNs::types(Module { krate: self.krate, module_id: p }.into())
                 } else {
                     log::debug!("super path in root module");
                     return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -634,14 +355,14 @@ impl ItemMap {
 
             curr_per_ns = match curr {
                 ModuleDef::Module(module) => {
-                    if module.krate != original_module.krate {
+                    if module.krate != self.krate {
                         let path = Path {
                             segments: path.segments[i..].iter().cloned().collect(),
                             kind: PathKind::Self_,
                         };
                         log::debug!("resolving {:?} in other crate", path);
-                        let item_map = db.item_map(module.krate);
-                        let (def, s) = item_map.resolve_path(db, *module, &path);
+                        let defp_map = db.crate_def_map(module.krate);
+                        let (def, s) = defp_map.resolve_path(db, module.module_id, &path);
                         return ResolvePathResult::with(
                             def,
                             ReachedFixedPoint::Yes,
@@ -649,7 +370,7 @@ impl ItemMap {
                         );
                     }
 
-                    match self[module.module_id].items.get(&segment.name) {
+                    match self[module.module_id].scope.items.get(&segment.name) {
                         Some(res) if !res.def.is_none() => res.def,
                         _ => {
                             log::debug!("path segment {:?} not found", segment.name);
@@ -659,7 +380,7 @@ impl ItemMap {
                 }
                 ModuleDef::Enum(e) => {
                     // enum variant
-                    tested_by!(item_map_enum_importing);
+                    tested_by!(can_import_enum_variant);
                     match e.variant(db, &segment.name) {
                         Some(variant) => PerNs::both(variant.into(), variant.into()),
                         None => {
@@ -690,7 +411,47 @@ impl ItemMap {
         }
         ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
     }
-}
 
-#[cfg(test)]
-mod tests;
+    fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
+        let from_crate_root =
+            self[self.root].scope.items.get(name).map_or(PerNs::none(), |it| it.def);
+        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
+
+        from_crate_root.or(from_extern_prelude)
+    }
+
+    pub(crate) fn resolve_name_in_module(
+        &self,
+        db: &impl PersistentHirDatabase,
+        module: CrateModuleId,
+        name: &Name,
+    ) -> PerNs<ModuleDef> {
+        // Resolve in:
+        //  - current module / scope
+        //  - extern prelude
+        //  - std prelude
+        let from_scope = self[module].scope.items.get(name).map_or(PerNs::none(), |it| it.def);
+        let from_extern_prelude =
+            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
+        let from_prelude = self.resolve_in_prelude(db, name);
+
+        from_scope.or(from_extern_prelude).or(from_prelude)
+    }
+
+    fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
+        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+    }
+
+    fn resolve_in_prelude(&self, db: &impl PersistentHirDatabase, name: &Name) -> PerNs<ModuleDef> {
+        if let Some(prelude) = self.prelude {
+            let resolution = if prelude.krate == self.krate {
+                self[prelude.module_id].scope.items.get(name).cloned()
+            } else {
+                db.crate_def_map(prelude.krate)[prelude.module_id].scope.items.get(name).cloned()
+            };
+            resolution.map(|r| r.def).unwrap_or_else(PerNs::none)
+        } else {
+            PerNs::none()
+        }
+    }
+}