8 files changed, 1584 insertions, 721 deletions

diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
new file mode 100644
index 000000000..12ed49a0a
--- /dev/null
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -0,0 +1,564 @@
+use arrayvec::ArrayVec;
+use rustc_hash::FxHashMap;
+use relative_path::RelativePathBuf;
+use test_utils::tested_by;
+use ra_db::FileId;
+
+use crate::{
+    Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
+    PersistentHirDatabase, HirFileId, Name, Path, Problem, Crate,
+    KnownName,
+    nameres::{Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode, raw},
+    ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId},
+};
+
+use super::{CrateDefMap, CrateModuleId, ModuleData, CrateMacroId};
+
+pub(super) fn collect_defs(
+    db: &impl PersistentHirDatabase,
+    mut def_map: CrateDefMap,
+) -> CrateDefMap {
+    // populate external prelude
+    for dep in def_map.krate.dependencies(db) {
+        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate);
+        if let Some(module) = dep.krate.root_module(db) {
+            def_map.extern_prelude.insert(dep.name.clone(), module.into());
+        }
+        // look for the prelude
+        if def_map.prelude.is_none() {
+            let map = db.crate_def_map(dep.krate);
+            if map.prelude.is_some() {
+                def_map.prelude = map.prelude;
+            }
+        }
+    }
+
+    let mut collector = DefCollector {
+        db,
+        def_map,
+        glob_imports: FxHashMap::default(),
+        unresolved_imports: Vec::new(),
+        unexpanded_macros: Vec::new(),
+        global_macro_scope: FxHashMap::default(),
+    };
+    collector.collect();
+    collector.finish()
+}
+
+/// Walks the tree of module recursively
+struct DefCollector<DB> {
+    db: DB,
+    def_map: CrateDefMap,
+    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
+    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
+    unexpanded_macros: Vec<(CrateModuleId, MacroCallId, Path, tt::Subtree)>,
+    global_macro_scope: FxHashMap<Name, CrateMacroId>,
+}
+
+impl<'a, DB> DefCollector<&'a DB>
+where
+    DB: PersistentHirDatabase,
+{
+    fn collect(&mut self) {
+        let crate_graph = self.db.crate_graph();
+        let file_id = crate_graph.crate_root(self.def_map.krate.crate_id());
+        let raw_items = self.db.raw_items(file_id);
+        let module_id = self.def_map.root;
+        self.def_map.modules[module_id].definition = Some(file_id);
+        ModCollector {
+            def_collector: &mut *self,
+            module_id,
+            file_id: file_id.into(),
+            raw_items: &raw_items,
+        }
+        .collect(raw_items.items());
+
+        // main name resolution fixed-point loop.
+        let mut i = 0;
+        loop {
+            match (self.resolve_imports(), self.resolve_macros()) {
+                (ReachedFixedPoint::Yes, ReachedFixedPoint::Yes) => break,
+                _ => i += 1,
+            }
+            if i == 1000 {
+                log::error!("diverging name resolution");
+                break;
+            }
+        }
+
+        let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        // show unresolved imports in completion, etc
+        for (module_id, import, import_data) in unresolved_imports {
+            self.record_resolved_import(module_id, PerNs::none(), import, &import_data)
+        }
+    }
+
+    fn define_macro(&mut self, name: Name, tt: &tt::Subtree, export: bool) {
+        if let Ok(rules) = mbe::MacroRules::parse(tt) {
+            let macro_id = self.def_map.macros.alloc(rules);
+            if export {
+                self.def_map.public_macros.insert(name.clone(), macro_id);
+            }
+            self.global_macro_scope.insert(name, macro_id);
+        }
+    }
+
+    fn resolve_imports(&mut self) -> ReachedFixedPoint {
+        let mut imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        let mut resolved = Vec::new();
+        imports.retain(|(module_id, import, import_data)| {
+            let (def, fp) = self.resolve_import(*module_id, import_data);
+            if fp == ReachedFixedPoint::Yes {
+                resolved.push((*module_id, def, *import, import_data.clone()))
+            }
+            fp == ReachedFixedPoint::No
+        });
+        self.unresolved_imports = imports;
+        // Resolves imports, filling-in module scopes
+        let result =
+            if resolved.is_empty() { ReachedFixedPoint::Yes } else { ReachedFixedPoint::No };
+        for (module_id, def, import, import_data) in resolved {
+            self.record_resolved_import(module_id, def, import, &import_data)
+        }
+        result
+    }
+
+    fn resolve_import(
+        &mut self,
+        module_id: CrateModuleId,
+        import: &raw::ImportData,
+    ) -> (PerNs<ModuleDef>, ReachedFixedPoint) {
+        log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
+        if import.is_extern_crate {
+            let res = self.def_map.resolve_name_in_extern_prelude(
+                &import
+                    .path
+                    .as_ident()
+                    .expect("extern crate should have been desugared to one-element path"),
+            );
+            (res, ReachedFixedPoint::Yes)
+        } else {
+            let res =
+                self.def_map.resolve_path_fp(self.db, ResolveMode::Import, module_id, &import.path);
+
+            (res.resolved_def, res.reached_fixedpoint)
+        }
+    }
+
+    fn record_resolved_import(
+        &mut self,
+        module_id: CrateModuleId,
+        def: PerNs<ModuleDef>,
+        import_id: raw::ImportId,
+        import: &raw::ImportData,
+    ) {
+        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.def_map.prelude = Some(m);
+                    } else if m.krate != self.def_map.krate {
+                        tested_by!(glob_across_crates);
+                        // glob import from other crate => we can just import everything once
+                        let item_map = self.db.crate_def_map(m.krate);
+                        let scope = &item_map[m.module_id].scope;
+                        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.def_map[m.module_id].scope;
+                        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 {
+            match import.path.segments.last() {
+                Some(last_segment) => {
+                    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 import.is_extern_crate && module_id == self.def_map.root {
+                        if let Some(def) = def.take_types() {
+                            self.def_map.extern_prelude.insert(name.clone(), def);
+                        }
+                    }
+                    let resolution = Resolution { def, import: Some(import_id) };
+                    self.update(module_id, Some(import_id), &[(name, resolution)]);
+                }
+                None => tested_by!(bogus_paths),
+            }
+        }
+    }
+
+    fn update(
+        &mut self,
+        module_id: CrateModuleId,
+        import: Option<raw::ImportId>,
+        resolutions: &[(Name, Resolution)],
+    ) {
+        self.update_recursive(module_id, import, resolutions, 0)
+    }
+
+    fn update_recursive(
+        &mut self,
+        module_id: CrateModuleId,
+        import: Option<raw::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 = &mut self.def_map.modules[module_id].scope;
+        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 existing.def.is_none()
+                && res.def.is_none()
+                && existing.import.is_none()
+                && res.import.is_some()
+            {
+                existing.import = res.import;
+            }
+        }
+        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);
+        }
+    }
+
+    // XXX: this is just a pile of hacks now, because `PerNs` does not handle
+    // macro namespace.
+    fn resolve_macros(&mut self) -> ReachedFixedPoint {
+        let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new());
+        let mut resolved = Vec::new();
+        let mut res = ReachedFixedPoint::Yes;
+        macros.retain(|(module_id, call_id, path, tt)| {
+            if path.segments.len() != 2 {
+                return true;
+            }
+            let crate_name = &path.segments[0].name;
+            let krate = match self.def_map.resolve_name_in_extern_prelude(crate_name).take_types() {
+                Some(ModuleDef::Module(m)) => m.krate(self.db),
+                _ => return true,
+            };
+            let krate = match krate {
+                Some(it) => it,
+                _ => return true,
+            };
+            res = ReachedFixedPoint::No;
+            let def_map = self.db.crate_def_map(krate);
+            if let Some(macro_id) = def_map.public_macros.get(&path.segments[1].name).cloned() {
+                resolved.push((*module_id, *call_id, (krate, macro_id), tt.clone()));
+            }
+            false
+        });
+
+        for (module_id, macro_call_id, macro_def_id, arg) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id, arg);
+        }
+        res
+    }
+
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: CrateModuleId,
+        macro_call_id: MacroCallId,
+        macro_def_id: (Crate, CrateMacroId),
+        macro_arg: tt::Subtree,
+    ) {
+        let (macro_krate, macro_id) = macro_def_id;
+        let dm;
+        let rules = if macro_krate == self.def_map.krate {
+            &self.def_map[macro_id]
+        } else {
+            dm = self.db.crate_def_map(macro_krate);
+            &dm[macro_id]
+        };
+        if let Ok(expansion) = rules.expand(&macro_arg) {
+            self.def_map.macro_resolutions.insert(macro_call_id, macro_def_id);
+            // XXX: this **does not** go through a database, because we can't
+            // identify macro_call without adding the whole state of name resolution
+            // as a parameter to the query.
+            //
+            // So, we run the queries "manually" and we must ensure that
+            // `db.hir_parse(macro_call_id)` returns the same source_file.
+            let file_id: HirFileId = macro_call_id.into();
+            let source_file = mbe::token_tree_to_ast_item_list(&expansion);
+
+            let raw_items = raw::RawItems::from_source_file(&source_file, file_id);
+            ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items }
+                .collect(raw_items.items())
+        }
+    }
+
+    fn finish(self) -> CrateDefMap {
+        self.def_map
+    }
+}
+
+/// Walks a single module, populating defs, imports and macros
+struct ModCollector<'a, D> {
+    def_collector: D,
+    module_id: CrateModuleId,
+    file_id: HirFileId,
+    raw_items: &'a raw::RawItems,
+}
+
+impl<DB> ModCollector<'_, &'_ mut DefCollector<&'_ DB>>
+where
+    DB: PersistentHirDatabase,
+{
+    fn collect(&mut self, items: &[raw::RawItem]) {
+        for item in items {
+            match *item {
+                raw::RawItem::Module(m) => self.collect_module(&self.raw_items[m]),
+                raw::RawItem::Import(import) => self.def_collector.unresolved_imports.push((
+                    self.module_id,
+                    import,
+                    self.raw_items[import].clone(),
+                )),
+                raw::RawItem::Def(def) => self.define_def(&self.raw_items[def]),
+                raw::RawItem::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+            }
+        }
+    }
+
+    fn collect_module(&mut self, module: &raw::ModuleData) {
+        match module {
+            // inline module, just recurse
+            raw::ModuleData::Definition { name, items, source_item_id } => {
+                let module_id = self.push_child_module(
+                    name.clone(),
+                    source_item_id.with_file_id(self.file_id),
+                    None,
+                );
+                ModCollector {
+                    def_collector: &mut *self.def_collector,
+                    module_id,
+                    file_id: self.file_id,
+                    raw_items: self.raw_items,
+                }
+                .collect(&*items);
+            }
+            // out of line module, resovle, parse and recurse
+            raw::ModuleData::Declaration { name, source_item_id } => {
+                let source_item_id = source_item_id.with_file_id(self.file_id);
+                let is_root = self.def_collector.def_map.modules[self.module_id].parent.is_none();
+                let (file_ids, problem) =
+                    resolve_submodule(self.def_collector.db, self.file_id, name, is_root);
+
+                if let Some(problem) = problem {
+                    self.def_collector.def_map.problems.add(source_item_id, problem)
+                }
+
+                if let Some(&file_id) = file_ids.first() {
+                    let module_id =
+                        self.push_child_module(name.clone(), source_item_id, Some(file_id));
+                    let raw_items = self.def_collector.db.raw_items(file_id);
+                    ModCollector {
+                        def_collector: &mut *self.def_collector,
+                        module_id,
+                        file_id: file_id.into(),
+                        raw_items: &raw_items,
+                    }
+                    .collect(raw_items.items())
+                }
+            }
+        }
+    }
+
+    fn push_child_module(
+        &mut self,
+        name: Name,
+        declaration: SourceItemId,
+        definition: Option<FileId>,
+    ) -> CrateModuleId {
+        let modules = &mut self.def_collector.def_map.modules;
+        let res = modules.alloc(ModuleData::default());
+        modules[res].parent = Some(self.module_id);
+        modules[res].declaration = Some(declaration);
+        modules[res].definition = definition;
+        modules[self.module_id].children.insert(name.clone(), res);
+        let resolution = Resolution {
+            def: PerNs::types(
+                Module { krate: self.def_collector.def_map.krate, module_id: res }.into(),
+            ),
+            import: None,
+        };
+        self.def_collector.update(self.module_id, None, &[(name, resolution)]);
+        res
+    }
+
+    fn define_def(&mut self, def: &raw::DefData) {
+        let module = Module { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id.into());
+        macro_rules! id {
+            () => {
+                AstItemDef::from_source_item_id_unchecked(ctx, def.source_item_id)
+            };
+        }
+        let name = def.name.clone();
+        let def: PerNs<ModuleDef> = match def.kind {
+            raw::DefKind::Function => PerNs::values(Function { id: id!() }.into()),
+            raw::DefKind::Struct => {
+                let s = Struct { id: id!() }.into();
+                PerNs::both(s, s)
+            }
+            raw::DefKind::Enum => PerNs::types(Enum { id: id!() }.into()),
+            raw::DefKind::Const => PerNs::values(Const { id: id!() }.into()),
+            raw::DefKind::Static => PerNs::values(Static { id: id!() }.into()),
+            raw::DefKind::Trait => PerNs::types(Trait { id: id!() }.into()),
+            raw::DefKind::TypeAlias => PerNs::types(TypeAlias { id: id!() }.into()),
+        };
+        let resolution = Resolution { def, import: None };
+        self.def_collector.update(self.module_id, None, &[(name, resolution)])
+    }
+
+    fn collect_macro(&mut self, mac: &raw::MacroData) {
+        // Case 1: macro rules, define a macro in crate-global mutable scope
+        if is_macro_rules(&mac.path) {
+            if let Some(name) = &mac.name {
+                self.def_collector.define_macro(name.clone(), &mac.arg, mac.export)
+            }
+            return;
+        }
+
+        let source_item_id = SourceItemId { file_id: self.file_id, item_id: mac.source_item_id };
+        let macro_call_id = MacroCallLoc {
+            module: Module { krate: self.def_collector.def_map.krate, module_id: self.module_id },
+            source_item_id,
+        }
+        .id(self.def_collector.db);
+
+        // Case 2: try to expand macro_rules from this crate, triggering
+        // recursive item collection.
+        if let Some(&macro_id) =
+            mac.path.as_ident().and_then(|name| self.def_collector.global_macro_scope.get(name))
+        {
+            self.def_collector.collect_macro_expansion(
+                self.module_id,
+                macro_call_id,
+                (self.def_collector.def_map.krate, macro_id),
+                mac.arg.clone(),
+            );
+            return;
+        }
+
+        // Case 3: path to a macro from another crate, expand during name resolution
+        self.def_collector.unexpanded_macros.push((
+            self.module_id,
+            macro_call_id,
+            mac.path.clone(),
+            mac.arg.clone(),
+        ))
+    }
+}
+
+fn is_macro_rules(path: &Path) -> bool {
+    path.as_ident().and_then(Name::as_known_name) == Some(KnownName::MacroRules)
+}
+
+fn resolve_submodule(
+    db: &impl PersistentHirDatabase,
+    file_id: HirFileId,
+    name: &Name,
+    is_root: bool,
+) -> (Vec<FileId>, Option<Problem>) {
+    // FIXME: handle submodules of inline modules properly
+    let file_id = file_id.original_file(db);
+    let source_root_id = db.file_source_root(file_id);
+    let path = db.file_relative_path(file_id);
+    let root = RelativePathBuf::default();
+    let dir_path = path.parent().unwrap_or(&root);
+    let mod_name = path.file_stem().unwrap_or("unknown");
+    let is_dir_owner = is_root || mod_name == "mod";
+
+    let file_mod = dir_path.join(format!("{}.rs", name));
+    let dir_mod = dir_path.join(format!("{}/mod.rs", name));
+    let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name));
+    let mut candidates = ArrayVec::<[_; 2]>::new();
+    if is_dir_owner {
+        candidates.push(file_mod.clone());
+        candidates.push(dir_mod);
+    } else {
+        candidates.push(file_dir_mod.clone());
+    };
+    let sr = db.source_root(source_root_id);
+    let points_to = candidates
+        .into_iter()
+        .filter_map(|path| sr.files.get(&path))
+        .map(|&it| it)
+        .collect::<Vec<_>>();
+    let problem = if points_to.is_empty() {
+        Some(Problem::UnresolvedModule {
+            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
+        })
+    } else {
+        None
+    };
+    (points_to, problem)
+}
diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs
deleted file mode 100644
index 56262ad6d..000000000
--- a/crates/ra_hir/src/nameres/lower.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-use std::sync::Arc;
-
-use ra_syntax::{
-    AstNode, SourceFile, TreeArc, AstPtr,
-    ast::{self, ModuleItemOwner, NameOwner, AttrsOwner},
-};
-use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
-use rustc_hash::FxHashMap;
-
-use crate::{
-    SourceItemId, Path, ModuleSource, Name,
-    HirFileId, MacroCallLoc, AsName, PerNs, Function,
-    ModuleDef, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
-    ids::LocationCtx, PersistentHirDatabase,
-};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImportId(RawId);
-impl_arena_id!(ImportId);
-
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct ImportData {
-    pub(super) path: Path,
-    pub(super) alias: Option<Name>,
-    pub(super) is_glob: bool,
-    pub(super) is_prelude: bool,
-    pub(super) is_extern_crate: bool,
-}
-
-/// A set of items and imports declared inside a module, without relation to
-/// other modules.
-///
-/// This sits in-between raw syntax and name resolution and allows us to avoid
-/// recomputing name res: if two instance of `InputModuleItems` are the same, we
-/// can avoid redoing name resolution.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct LoweredModule {
-    pub(crate) declarations: FxHashMap<Name, PerNs<ModuleDef>>,
-    pub(super) imports: Arena<ImportId, ImportData>,
-}
-
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, AstPtr<ast::PathSegment>>,
-}
-
-impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
-        self.map.insert(import, AstPtr::new(segment))
-    }
-
-    pub fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
-        let file = match source {
-            ModuleSource::SourceFile(file) => &*file,
-            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
-        };
-
-        self.map[import].to_node(file).to_owned()
-    }
-}
-
-impl LoweredModule {
-    pub(crate) fn lower_module_query(
-        db: &impl PersistentHirDatabase,
-        module: Module,
-    ) -> Arc<LoweredModule> {
-        db.lower_module_with_source_map(module).0
-    }
-
-    pub(crate) fn lower_module_with_source_map_query(
-        db: &impl PersistentHirDatabase,
-        module: Module,
-    ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>) {
-        let (file_id, source) = module.definition_source(db);
-        let file_id: HirFileId = file_id.into();
-        let mut source_map = ImportSourceMap::default();
-        let mut res = LoweredModule::default();
-        match source {
-            ModuleSource::SourceFile(it) => {
-                res.fill(&mut source_map, db, module, file_id, &mut it.items_with_macros())
-            }
-            ModuleSource::Module(it) => {
-                if let Some(item_list) = it.item_list() {
-                    res.fill(
-                        &mut source_map,
-                        db,
-                        module,
-                        file_id,
-                        &mut item_list.items_with_macros(),
-                    )
-                }
-            }
-        };
-        (Arc::new(res), Arc::new(source_map))
-    }
-
-    fn fill(
-        &mut self,
-        source_map: &mut ImportSourceMap,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        file_id: HirFileId,
-        items: &mut Iterator<Item = ast::ItemOrMacro>,
-    ) {
-        let file_items = db.file_items(file_id);
-
-        for item in items {
-            match item {
-                ast::ItemOrMacro::Item(it) => {
-                    self.add_def_id(source_map, db, module, file_id, it);
-                }
-                ast::ItemOrMacro::Macro(macro_call) => {
-                    let item_id = file_items.id_of_unchecked(macro_call.syntax());
-                    let loc =
-                        MacroCallLoc { module, source_item_id: SourceItemId { file_id, item_id } };
-                    let id = loc.id(db);
-                    let file_id = HirFileId::from(id);
-                    //FIXME: expand recursively
-                    for item in db.hir_parse(file_id).items() {
-                        self.add_def_id(source_map, db, module, file_id, item);
-                    }
-                }
-            }
-        }
-    }
-
-    fn add_def_id(
-        &mut self,
-        source_map: &mut ImportSourceMap,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        file_id: HirFileId,
-        item: &ast::ModuleItem,
-    ) {
-        let ctx = LocationCtx::new(db, module, file_id);
-        match item.kind() {
-            ast::ModuleItemKind::StructDef(it) => {
-                if let Some(name) = it.name() {
-                    let s = Struct { id: ctx.to_def(it) };
-                    let s: ModuleDef = s.into();
-                    self.declarations.insert(name.as_name(), PerNs::both(s, s));
-                }
-            }
-            ast::ModuleItemKind::EnumDef(it) => {
-                if let Some(name) = it.name() {
-                    let e = Enum { id: ctx.to_def(it) };
-                    let e: ModuleDef = e.into();
-                    self.declarations.insert(name.as_name(), PerNs::types(e));
-                }
-            }
-            ast::ModuleItemKind::FnDef(it) => {
-                if let Some(name) = it.name() {
-                    let func = Function { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(func.into()));
-                }
-            }
-            ast::ModuleItemKind::TraitDef(it) => {
-                if let Some(name) = it.name() {
-                    let t = Trait { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::types(t.into()));
-                }
-            }
-            ast::ModuleItemKind::TypeAliasDef(it) => {
-                if let Some(name) = it.name() {
-                    let t = TypeAlias { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::types(t.into()));
-                }
-            }
-            ast::ModuleItemKind::ImplBlock(_) => {
-                // impls don't define items
-            }
-            ast::ModuleItemKind::UseItem(it) => {
-                self.add_use_item(source_map, it);
-            }
-            ast::ModuleItemKind::ExternCrateItem(it) => {
-                if let Some(name_ref) = it.name_ref() {
-                    let path = Path::from_name_ref(name_ref);
-                    let alias = it.alias().and_then(|a| a.name()).map(AsName::as_name);
-                    self.imports.alloc(ImportData {
-                        path,
-                        alias,
-                        is_glob: false,
-                        is_prelude: false,
-                        is_extern_crate: true,
-                    });
-                }
-            }
-            ast::ModuleItemKind::ConstDef(it) => {
-                if let Some(name) = it.name() {
-                    let c = Const { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(c.into()));
-                }
-            }
-            ast::ModuleItemKind::StaticDef(it) => {
-                if let Some(name) = it.name() {
-                    let s = Static { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(s.into()));
-                }
-            }
-            ast::ModuleItemKind::Module(_) => {
-                // modules are handled separately directly by name res
-            }
-        };
-    }
-
-    fn add_use_item(&mut self, source_map: &mut ImportSourceMap, item: &ast::UseItem) {
-        let is_prelude =
-            item.attrs().any(|attr| attr.as_atom().map(|s| s == "prelude_import").unwrap_or(false));
-        Path::expand_use_item(item, |path, segment, alias| {
-            let import = self.imports.alloc(ImportData {
-                path,
-                alias,
-                is_glob: segment.is_none(),
-                is_prelude,
-                is_extern_crate: false,
-            });
-            if let Some(segment) = segment {
-                source_map.insert(import, segment)
-            }
-        })
-    }
-}
diff --git a/crates/ra_hir/src/nameres/per_ns.rs b/crates/ra_hir/src/nameres/per_ns.rs
new file mode 100644
index 000000000..c40a3ff9d
--- /dev/null
+++ b/crates/ra_hir/src/nameres/per_ns.rs
@@ -0,0 +1,78 @@
+#[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) }
+    }
+}
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
new file mode 100644
index 000000000..3226bbf0d
--- /dev/null
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -0,0 +1,322 @@
+use std::{
+    sync::Arc,
+    ops::Index,
+};
+
+use test_utils::tested_by;
+use ra_db::FileId;
+use ra_arena::{Arena, impl_arena_id, RawId, map::ArenaMap};
+use ra_syntax::{
+    AstNode, SourceFile, AstPtr, TreeArc,
+    ast::{self, NameOwner, AttrsOwner},
+};
+
+use crate::{
+    PersistentHirDatabase, Name, AsName, Path, HirFileId, ModuleSource,
+    ids::{SourceFileItemId, SourceFileItems},
+};
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct RawItems {
+    modules: Arena<Module, ModuleData>,
+    imports: Arena<ImportId, ImportData>,
+    defs: Arena<Def, DefData>,
+    macros: Arena<Macro, MacroData>,
+    /// items for top-level module
+    items: Vec<RawItem>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ImportSourceMap {
+    map: ArenaMap<ImportId, AstPtr<ast::PathSegment>>,
+}
+
+impl ImportSourceMap {
+    pub(crate) fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
+        self.map.insert(import, AstPtr::new(segment))
+    }
+
+    pub fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
+        let file = match source {
+            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
+        };
+
+        self.map[import].to_node(file).to_owned()
+    }
+}
+
+impl RawItems {
+    pub(crate) fn raw_items_query(
+        db: &impl PersistentHirDatabase,
+        file_id: FileId,
+    ) -> Arc<RawItems> {
+        db.raw_items_with_source_map(file_id).0
+    }
+
+    pub(crate) fn raw_items_with_source_map_query(
+        db: &impl PersistentHirDatabase,
+        file_id: FileId,
+    ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
+        let mut collector = RawItemsCollector {
+            raw_items: RawItems::default(),
+            source_file_items: db.file_items(file_id.into()),
+            source_map: ImportSourceMap::default(),
+        };
+        let source_file = db.parse(file_id);
+        collector.process_module(None, &*source_file);
+        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
+    }
+
+    pub(crate) fn items(&self) -> &[RawItem] {
+        &self.items
+    }
+
+    // We can't use queries during name resolution for fear of cycles, so this
+    // is a query-less variant of the above function.
+    pub(crate) fn from_source_file(source_file: &SourceFile, file_id: HirFileId) -> RawItems {
+        let source_file_items = SourceFileItems::from_source_file(source_file, file_id);
+        let mut collector = RawItemsCollector {
+            raw_items: RawItems::default(),
+            source_file_items: Arc::new(source_file_items),
+            source_map: ImportSourceMap::default(),
+        };
+        collector.process_module(None, &*source_file);
+        collector.raw_items
+    }
+}
+
+impl Index<Module> for RawItems {
+    type Output = ModuleData;
+    fn index(&self, idx: Module) -> &ModuleData {
+        &self.modules[idx]
+    }
+}
+
+impl Index<ImportId> for RawItems {
+    type Output = ImportData;
+    fn index(&self, idx: ImportId) -> &ImportData {
+        &self.imports[idx]
+    }
+}
+
+impl Index<Def> for RawItems {
+    type Output = DefData;
+    fn index(&self, idx: Def) -> &DefData {
+        &self.defs[idx]
+    }
+}
+
+impl Index<Macro> for RawItems {
+    type Output = MacroData;
+    fn index(&self, idx: Macro) -> &MacroData {
+        &self.macros[idx]
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(crate) enum RawItem {
+    Module(Module),
+    Import(ImportId),
+    Def(Def),
+    Macro(Macro),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Module(RawId);
+impl_arena_id!(Module);
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum ModuleData {
+    Declaration { name: Name, source_item_id: SourceFileItemId },
+    Definition { name: Name, source_item_id: SourceFileItemId, items: Vec<RawItem> },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImportId(RawId);
+impl_arena_id!(ImportId);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportData {
+    pub(crate) path: Path,
+    pub(crate) alias: Option<Name>,
+    pub(crate) is_glob: bool,
+    pub(crate) is_prelude: bool,
+    pub(crate) is_extern_crate: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Def(RawId);
+impl_arena_id!(Def);
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct DefData {
+    pub(crate) source_item_id: SourceFileItemId,
+    pub(crate) name: Name,
+    pub(crate) kind: DefKind,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(crate) enum DefKind {
+    Function,
+    Struct,
+    Enum,
+    Const,
+    Static,
+    Trait,
+    TypeAlias,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Macro(RawId);
+impl_arena_id!(Macro);
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct MacroData {
+    pub(crate) source_item_id: SourceFileItemId,
+    pub(crate) path: Path,
+    pub(crate) name: Option<Name>,
+    pub(crate) arg: tt::Subtree,
+    pub(crate) export: bool,
+}
+
+struct RawItemsCollector {
+    raw_items: RawItems,
+    source_file_items: Arc<SourceFileItems>,
+    source_map: ImportSourceMap,
+}
+
+impl RawItemsCollector {
+    fn process_module(&mut self, current_module: Option<Module>, body: &impl ast::ModuleItemOwner) {
+        for item_or_macro in body.items_with_macros() {
+            match item_or_macro {
+                ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m),
+                ast::ItemOrMacro::Item(item) => self.add_item(current_module, item),
+            }
+        }
+    }
+
+    fn add_item(&mut self, current_module: Option<Module>, item: &ast::ModuleItem) {
+        let (kind, name) = match item.kind() {
+            ast::ModuleItemKind::Module(module) => {
+                self.add_module(current_module, module);
+                return;
+            }
+            ast::ModuleItemKind::UseItem(use_item) => {
+                self.add_use_item(current_module, use_item);
+                return;
+            }
+            ast::ModuleItemKind::ExternCrateItem(extern_crate) => {
+                self.add_extern_crate_item(current_module, extern_crate);
+                return;
+            }
+            ast::ModuleItemKind::ImplBlock(_) => {
+                // impls don't participate in name resolution
+                return;
+            }
+            ast::ModuleItemKind::StructDef(it) => (DefKind::Struct, it.name()),
+            ast::ModuleItemKind::EnumDef(it) => (DefKind::Enum, it.name()),
+            ast::ModuleItemKind::FnDef(it) => (DefKind::Function, it.name()),
+            ast::ModuleItemKind::TraitDef(it) => (DefKind::Trait, it.name()),
+            ast::ModuleItemKind::TypeAliasDef(it) => (DefKind::TypeAlias, it.name()),
+            ast::ModuleItemKind::ConstDef(it) => (DefKind::Const, it.name()),
+            ast::ModuleItemKind::StaticDef(it) => (DefKind::Static, it.name()),
+        };
+        if let Some(name) = name {
+            let name = name.as_name();
+            let source_item_id = self.source_file_items.id_of_unchecked(item.syntax());
+            let def = self.raw_items.defs.alloc(DefData { name, kind, source_item_id });
+            self.push_item(current_module, RawItem::Def(def))
+        }
+    }
+
+    fn add_module(&mut self, current_module: Option<Module>, module: &ast::Module) {
+        let name = match module.name() {
+            Some(it) => it.as_name(),
+            None => return,
+        };
+        let source_item_id = self.source_file_items.id_of_unchecked(module.syntax());
+        if module.has_semi() {
+            let item =
+                self.raw_items.modules.alloc(ModuleData::Declaration { name, source_item_id });
+            self.push_item(current_module, RawItem::Module(item));
+            return;
+        }
+
+        if let Some(item_list) = module.item_list() {
+            let item = self.raw_items.modules.alloc(ModuleData::Definition {
+                name,
+                source_item_id,
+                items: Vec::new(),
+            });
+            self.process_module(Some(item), item_list);
+            self.push_item(current_module, RawItem::Module(item));
+            return;
+        }
+        tested_by!(name_res_works_for_broken_modules);
+    }
+
+    fn add_use_item(&mut self, current_module: Option<Module>, use_item: &ast::UseItem) {
+        let is_prelude = use_item.has_atom_attr("prelude_import");
+
+        Path::expand_use_item(use_item, |path, segment, alias| {
+            let import = self.raw_items.imports.alloc(ImportData {
+                path,
+                alias,
+                is_glob: segment.is_none(),
+                is_prelude,
+                is_extern_crate: false,
+            });
+            if let Some(segment) = segment {
+                self.source_map.insert(import, segment)
+            }
+            self.push_item(current_module, RawItem::Import(import))
+        })
+    }
+
+    fn add_extern_crate_item(
+        &mut self,
+        current_module: Option<Module>,
+        extern_crate: &ast::ExternCrateItem,
+    ) {
+        if let Some(name_ref) = extern_crate.name_ref() {
+            let path = Path::from_name_ref(name_ref);
+            let alias = extern_crate.alias().and_then(|a| a.name()).map(AsName::as_name);
+            let import = self.raw_items.imports.alloc(ImportData {
+                path,
+                alias,
+                is_glob: false,
+                is_prelude: false,
+                is_extern_crate: true,
+            });
+            self.push_item(current_module, RawItem::Import(import))
+        }
+    }
+
+    fn add_macro(&mut self, current_module: Option<Module>, m: &ast::MacroCall) {
+        let (path, arg) = match (
+            m.path().and_then(Path::from_ast),
+            m.token_tree().and_then(mbe::ast_to_token_tree),
+        ) {
+            (Some(path), Some((token_tree, _token_map))) => (path, token_tree),
+            _ => return,
+        };
+
+        let name = m.name().map(|it| it.as_name());
+        let source_item_id = self.source_file_items.id_of_unchecked(m.syntax());
+        let export = m.has_atom_attr("macro_export");
+        let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, arg, name, export });
+        self.push_item(current_module, RawItem::Macro(m));
+    }
+
+    fn push_item(&mut self, current_module: Option<Module>, item: RawItem) {
+        match current_module {
+            Some(module) => match &mut self.raw_items.modules[module] {
+                ModuleData::Definition { items, .. } => items,
+                ModuleData::Declaration { .. } => unreachable!(),
+            },
+            None => &mut self.raw_items.items,
+        }
+        .push(item)
+    }
+}
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 9b151bb0c..ac9b88520 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -1,34 +1,43 @@
+mod macros;
+mod globs;
+mod incremental;
+
 use std::sync::Arc;
 
 use ra_db::SourceDatabase;
-use test_utils::{assert_eq_text, covers};
-
-use crate::{
-    ItemMap,
-    PersistentHirDatabase,
-    mock::MockDatabase,
-    module_tree::ModuleId,
-};
-use super::Resolution;
-
-fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
-    let (db, pos) = MockDatabase::with_position(fixture);
-    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let module_id = module.module_id;
-    (db.item_map(krate), module_id)
+use test_utils::covers;
+use insta::assert_snapshot_matches;
+
+use crate::{Crate, mock::{MockDatabase, CrateGraphFixture}, nameres::Resolution};
+
+use super::*;
+
+fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> {
+    let mut db = MockDatabase::with_files(fixture);
+    if let Some(graph) = graph {
+        db.set_crate_graph_from_fixture(graph);
+    }
+    let crate_id = db.crate_graph().iter().next().unwrap();
+    let krate = Crate { crate_id };
+    db.crate_def_map(krate)
 }
 
-fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
-    let mut lines = map[module_id]
-        .items
-        .iter()
-        .map(|(name, res)| format!("{}: {}", name, dump_resolution(res)))
-        .collect::<Vec<_>>();
-    lines.sort();
-    let actual = lines.join("\n");
-    let expected = expected.trim().lines().map(|it| it.trim()).collect::<Vec<_>>().join("\n");
-    assert_eq_text!(&expected, &actual);
+fn render_crate_def_map(map: &CrateDefMap) -> String {
+    let mut buf = String::new();
+    go(&mut buf, map, "\ncrate", map.root);
+    return buf;
+
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+        *buf += path;
+        *buf += "\n";
+        for (name, res) in map.modules[module].scope.items.iter() {
+            *buf += &format!("{}: {}\n", name, dump_resolution(res))
+        }
+        for (name, child) in map.modules[module].children.iter() {
+            let path = path.to_string() + &format!("::{}", name);
+            go(buf, map, &path, *child);
+        }
+    }
 
     fn dump_resolution(resolution: &Resolution) -> &'static str {
         match (resolution.def.types.is_some(), resolution.def.values.is_some()) {
@@ -40,66 +49,112 @@ fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
     }
 }
 
+fn def_map(fixtute: &str) -> String {
+    let dm = compute_crate_def_map(fixtute, None);
+    render_crate_def_map(&dm)
+}
+
+fn def_map_with_crate_graph(fixtute: &str, graph: CrateGraphFixture) -> String {
+    let dm = compute_crate_def_map(fixtute, Some(graph));
+    render_crate_def_map(&dm)
+}
+
 #[test]
-fn item_map_smoke_test() {
-    let (item_map, module_id) = item_map(
+fn crate_def_map_smoke_test() {
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
-
-        use crate::foo::bar::Baz;
-        <|>
+        struct S;
+        use crate::foo::bar::E;
+        use self::E::V;
 
         //- /foo/mod.rs
         pub mod bar;
+        fn f() {}
 
         //- /foo/bar.rs
         pub struct Baz;
-    ",
+        enum E { V }
+        ",
     );
-    check_module_item_map(
-        &item_map,
-        module_id,
+    assert_snapshot_matches!(map, @r###"
+crate
+V: t v
+E: t
+foo: t
+S: t v
+
+crate::foo
+bar: t
+f: v
+
+crate::foo::bar
+Baz: t v
+E: t
+"###
+    )
+}
+
+#[test]
+fn bogus_paths() {
+    covers!(bogus_paths);
+    let map = def_map(
         "
-            Baz: t v
-            foo: t
+        //- /lib.rs
+        mod foo;
+        struct S;
+        use self;
+
+        //- /foo/mod.rs
+        use super;
+        use crate;
+
         ",
     );
+    assert_snapshot_matches!(map, @r###"
+crate
+foo: t
+S: t v
+
+crate::foo
+"###
+    )
 }
 
 #[test]
 fn use_as() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use crate::foo::Baz as Foo;
-        <|>
 
         //- /foo/mod.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Foo: t v
-            foo: t
         ",
     );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Foo: t v
+foo: t
+
+crate::foo
+Baz: t v
+"###
+    );
 }
 
 #[test]
 fn use_trees() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use crate::foo::bar::{Baz, Quux};
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -107,28 +162,33 @@ fn use_trees() {
         //- /foo/bar.rs
         pub struct Baz;
         pub enum Quux {};
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Quux: t
-            foo: t
         ",
     );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Quux: t
+Baz: t v
+foo: t
+
+crate::foo
+bar: t
+
+crate::foo::bar
+Quux: t
+Baz: t v
+"###
+    );
 }
 
 #[test]
 fn re_exports() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use self::foo::Baz;
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -137,137 +197,73 @@ fn re_exports() {
 
         //- /foo/bar.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
         ",
     );
-}
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+foo: t
 
-#[test]
-fn glob_1() {
-    let (item_map, module_id) = item_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        <|>
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::Baz;
-        pub struct Foo;
+crate::foo
+bar: t
+Baz: t v
 
-        //- /foo/bar.rs
-        pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Foo: t v
-            bar: t
-            foo: t
-        ",
+crate::foo::bar
+Baz: t v
+"###
     );
 }
 
 #[test]
-fn glob_2() {
-    let (item_map, module_id) = item_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        <|>
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::*;
-        pub struct Foo;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        pub use super::*;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
+fn std_prelude() {
+    covers!(std_prelude);
+    let map = def_map_with_crate_graph(
         "
-            Baz: t v
-            Foo: t v
-            bar: t
-            foo: t
-        ",
-    );
-}
+        //- /main.rs
+        use Foo::*;
 
-#[test]
-fn glob_enum() {
-    covers!(glob_enum);
-    let (item_map, module_id) = item_map(
-        "
         //- /lib.rs
-        enum Foo {
-            Bar, Baz
-        }
-        use self::Foo::*;
-        <|>
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Bar: t v
-            Baz: t v
-            Foo: t
+        mod prelude;
+        #[prelude_import]
+        use prelude::*;
+
+        //- /prelude.rs
+        pub enum Foo { Bar, Baz };
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
+    assert_snapshot_matches!(map, @r###"
+crate
+Bar: t v
+Baz: t v
+"###);
 }
 
 #[test]
-fn glob_across_crates() {
-    covers!(glob_across_crates);
-    let mut db = MockDatabase::with_files(
+fn can_import_enum_variant() {
+    covers!(can_import_enum_variant);
+    let map = def_map(
         "
-        //- /main.rs
-        use test_crate::*;
-
         //- /lib.rs
-        pub struct Baz;
+        enum E { V }
+        use self::E::V;
         ",
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Baz: t v
-        ",
+    assert_snapshot_matches!(map, @r###"
+crate
+V: t v
+E: t
+"###
     );
 }
 
 #[test]
 fn edition_2015_imports() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         mod foo;
@@ -282,31 +278,32 @@ fn edition_2015_imports() {
 
         //- /lib.rs
         struct FromLib;
-    ",
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["other_crate"]),
-        "other_crate": ("/lib.rs", "2018", []),
-    });
-    let foo_id = db.file_id_of("/foo.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, foo_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            FromLib: t v
         ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["other_crate"]),
+            "other_crate": ("/lib.rs", "2018", []),
+        },
+    );
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+bar: t
+foo: t
+
+crate::bar
+Bar: t v
+
+crate::foo
+FromLib: t v
+Bar: t v
+"###
     );
 }
 
 #[test]
 fn module_resolution_works_for_non_standard_filenames() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /my_library.rs
         mod foo;
@@ -315,73 +312,32 @@ fn module_resolution_works_for_non_standard_filenames() {
         //- /foo/mod.rs
         pub struct Bar;
         ",
+        crate_graph! {
+            "my_library": ("/my_library.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "my_library": ("/my_library.rs", []),
-    });
-    let file_id = db.file_id_of("/my_library.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let module_id = module.module_id;
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-        Bar: t v
-        foo: t
-        ",
-    );
-}
 
-#[test]
-fn std_prelude() {
-    covers!(std_prelude);
-    let mut db = MockDatabase::with_files(
-        "
-        //- /main.rs
-        use Foo::*;
-
-        //- /lib.rs
-        mod prelude;
-        #[prelude_import]
-        use prelude::*;
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Bar: t v
+foo: t
 
-        //- /prelude.rs
-        pub enum Foo { Bar, Baz };
-    ",
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            Baz: t v
-        ",
+crate::foo
+Bar: t v
+"###
     );
 }
 
 #[test]
 fn name_res_works_for_broken_modules() {
     covers!(name_res_works_for_broken_modules);
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo // no `;`, no body
 
         use self::foo::Baz;
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -390,65 +346,47 @@ fn name_res_works_for_broken_modules() {
 
         //- /foo/bar.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: _
         ",
     );
-}
-
-#[test]
-fn item_map_using_self() {
-    let (item_map, module_id) = item_map(
-        "
-            //- /lib.rs
-            mod foo;
-            use crate::foo::bar::Baz::{self};
-            <|>
-            //- /foo/mod.rs
-            pub mod bar;
-            //- /foo/bar.rs
-            pub struct Baz;
-        ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
-        ",
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: _
+"###
     );
 }
 
 #[test]
-fn item_map_enum_importing() {
-    covers!(item_map_enum_importing);
-    let (item_map, module_id) = item_map(
+fn item_map_using_self() {
+    let map = def_map(
         "
         //- /lib.rs
-        enum E { V }
-        use self::E::V;
-        <|>
+        mod foo;
+        use crate::foo::bar::Baz::{self};
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
         ",
     );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-        E: t
-        V: t v
-        ",
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+foo: t
+
+crate::foo
+bar: t
+
+crate::foo::bar
+Baz: t v
+"###
     );
 }
 
 #[test]
 fn item_map_across_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         use test_crate::Baz;
@@ -456,29 +394,23 @@ fn item_map_across_crates() {
         //- /lib.rs
         pub struct Baz;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+"###
     );
 }
 
 #[test]
 fn extern_crate_rename() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         extern crate alloc as alloc_crate;
@@ -492,29 +424,23 @@ fn extern_crate_rename() {
         //- /lib.rs
         struct Arc;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["alloc"]),
-        "alloc": ("/lib.rs", []),
-    });
-    let sync_id = db.file_id_of("/sync.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Arc: t v
+"###
     );
 }
 
 #[test]
 fn extern_crate_rename_2015_edition() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         extern crate alloc as alloc_crate;
@@ -528,29 +454,23 @@ fn extern_crate_rename_2015_edition() {
         //- /lib.rs
         struct Arc;
         ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["alloc"]),
-        "alloc": ("/lib.rs", []),
-    });
-    let sync_id = db.file_id_of("/sync.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Arc: t v
+"###
     );
 }
 
 #[test]
 fn import_across_source_roots() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /lib.rs
         pub mod a {
@@ -564,29 +484,23 @@ fn import_across_source_roots() {
         //- /main/main.rs
         use test_crate::a::b::C;
         ",
+        crate_graph! {
+            "main": ("/main/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            C: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+C: t v
+"###
     );
 }
 
 #[test]
 fn reexport_across_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         use test_crate::Baz;
@@ -599,29 +513,23 @@ fn reexport_across_crates() {
         //- /foo.rs
         pub struct Baz;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+"###
     );
 }
 
 #[test]
 fn values_dont_shadow_extern_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         fn foo() {}
@@ -630,139 +538,17 @@ fn values_dont_shadow_extern_crates() {
         //- /foo/lib.rs
         pub struct Bar;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/foo/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["foo"]),
-        "foo": ("/foo/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Bar: t v
-        foo: v
-        ",
-    );
-}
-
-fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
-    let (mut db, pos) = MockDatabase::with_position(initial);
-    let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(format!("{:?}", events).contains("item_map"))
-    }
-    db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
-
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(!format!("{:?}", events).contains("item_map"), "{:#?}", events)
-    }
-}
-
-#[test]
-fn typing_inside_a_function_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        mod foo;<|>
-
-        use crate::foo::bar::Baz;
-
-        fn foo() -> i32 {
-            1 + 1
-        }
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        mod foo;
-
-        use crate::foo::bar::Baz;
-
-        fn foo() -> i32 { 92 }
-        ",
-    );
-}
-
-#[test]
-fn adding_inner_items_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        struct S { a: i32}
-        enum E { A }
-        trait T {
-            fn a() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-        }
-        use crate::foo::bar::Baz;
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        struct S { a: i32, b: () }
-        enum E { A, B }
-        trait T {
-            fn a() {}
-            fn b() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-            fn b() {}
-        }
-        use crate::foo::bar::Baz;
-        ",
-    );
-}
 
-#[test]
-fn typing_inside_a_function_inside_a_macro_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        mod foo;
-
-        use crate::foo::bar::Baz;
-
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        <|>
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 1 + 1 }
-            }
-        }
-        ",
-        "
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 92 }
-            }
-        }
-        ",
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Bar: t v
+foo: v
+"###
     );
 }
diff --git a/crates/ra_hir/src/nameres/tests/globs.rs b/crates/ra_hir/src/nameres/tests/globs.rs
new file mode 100644
index 000000000..6e50c7ff6
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/globs.rs
@@ -0,0 +1,118 @@
+use super::*;
+
+#[test]
+fn glob_1() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::Baz;
+        pub struct Foo;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Baz: t v
+foo: t
+
+crate::foo
+bar: t
+Foo: t v
+Baz: t v
+
+crate::foo::bar
+Baz: t v
+"###
+    );
+}
+
+#[test]
+fn glob_2() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::*;
+        pub struct Foo;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        pub use super::*;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Baz: t v
+foo: t
+
+crate::foo
+bar: t
+Foo: t v
+Baz: t v
+
+crate::foo::bar
+bar: t
+Foo: t v
+Baz: t v
+"###
+    );
+}
+
+#[test]
+fn glob_across_crates() {
+    covers!(glob_across_crates);
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        use test_crate::*;
+
+        //- /lib.rs
+        pub struct Baz;
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+Baz: t v
+"###
+    );
+}
+
+#[test]
+fn glob_enum() {
+    covers!(glob_enum);
+    let map = def_map(
+        "
+        //- /lib.rs
+        enum Foo {
+            Bar, Baz
+        }
+        use self::Foo::*;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+Foo: t
+Bar: t v
+Baz: t v
+"###
+    );
+}
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
new file mode 100644
index 000000000..698781923
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -0,0 +1,123 @@
+use super::*;
+
+use std::sync::Arc;
+
+use ra_db::SourceDatabase;
+
+fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
+    let (mut db, pos) = MockDatabase::with_position(initial);
+    let crate_id = db.crate_graph().iter().next().unwrap();
+    let krate = Crate { crate_id };
+    {
+        let events = db.log_executed(|| {
+            db.crate_def_map(krate);
+        });
+        assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+    db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
+
+    {
+        let events = db.log_executed(|| {
+            db.crate_def_map(krate);
+        });
+        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+}
+
+#[test]
+fn typing_inside_a_function_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        mod foo;<|>
+
+        use crate::foo::bar::Baz;
+
+        fn foo() -> i32 {
+            1 + 1
+        }
+        //- /foo/mod.rs
+        pub mod bar;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+        "
+        mod foo;
+
+        use crate::foo::bar::Baz;
+
+        fn foo() -> i32 { 92 }
+        ",
+    );
+}
+
+#[test]
+fn adding_inner_items_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        struct S { a: i32}
+        enum E { A }
+        trait T {
+            fn a() {}
+        }
+        mod foo;<|>
+        impl S {
+            fn a() {}
+        }
+        use crate::foo::bar::Baz;
+        //- /foo/mod.rs
+        pub mod bar;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+        "
+        struct S { a: i32, b: () }
+        enum E { A, B }
+        trait T {
+            fn a() {}
+            fn b() {}
+        }
+        mod foo;<|>
+        impl S {
+            fn a() {}
+            fn b() {}
+        }
+        use crate::foo::bar::Baz;
+        ",
+    );
+}
+
+// It would be awesome to make this work, but it's unclear how
+#[test]
+#[ignore]
+fn typing_inside_a_function_inside_a_macro_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        mod foo;
+
+        use crate::foo::bar::Baz;
+
+        //- /foo/mod.rs
+        pub mod bar;
+
+        //- /foo/bar.rs
+        <|>
+        salsa::query_group! {
+            trait Baz {
+                fn foo() -> i32 { 1 + 1 }
+            }
+        }
+        ",
+        "
+        salsa::query_group! {
+            trait Baz {
+                fn foo() -> i32 { 92 }
+            }
+        }
+        ",
+    );
+}
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
new file mode 100644
index 000000000..8781b026b
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -0,0 +1,94 @@
+use super::*;
+
+#[test]
+fn macro_rules_are_globally_visible() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        structs!(Foo);
+        mod nested;
+
+        //- /nested.rs
+        structs!(Bar, Baz);
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+nested: t
+Foo: t v
+
+crate::nested
+Bar: t v
+Baz: t v
+"###);
+}
+
+#[test]
+fn macro_rules_can_define_modules() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        macro_rules! m {
+            ($name:ident) => { mod $name;  }
+        }
+        m!(n1);
+
+        //- /n1.rs
+        m!(n2)
+        //- /n1/n2.rs
+        struct X;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+n1: t
+
+crate::n1
+n2: t
+
+crate::n1::n2
+X: t v
+"###);
+}
+
+#[test]
+fn macro_rules_from_other_crates_are_visible() {
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        foo::structs!(Foo, Bar)
+        mod bar;
+
+        //- /bar.rs
+        use crate::*;
+
+        //- /lib.rs
+        #[macro_export]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Bar: t v
+
+crate::bar
+bar: t
+Foo: t v
+Bar: t v
+"###);
+}