Merge branch 'master' into feature/themes

18 files changed, 3799 insertions, 28 deletions

diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index 746c907e8..21262be79 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -7,7 +7,6 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 log = "0.4.5"
 once_cell = "1.0.1"
-relative-path = "1.0.0"
 rustc-hash = "1.0"
 
 ra_arena = { path = "../ra_arena" }
@@ -19,3 +18,6 @@ test_utils = { path = "../test_utils" }
 mbe = { path = "../ra_mbe", package = "ra_mbe" }
 ra_cfg = { path = "../ra_cfg" }
 tt = { path = "../ra_tt", package = "ra_tt" }
+
+[dev-dependencies]
+insta = "0.12.0"
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 22bd469f0..8f41e55d2 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -8,7 +8,7 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 
 use crate::{
     db::DefDatabase2, type_ref::TypeRef, AstItemDef, EnumId, LocalEnumVariantId,
-    LocalStructFieldId, StructId,
+    LocalStructFieldId, StructId, UnionId,
 };
 
 /// Note that we use `StructData` for unions as well!
@@ -56,6 +56,13 @@ impl StructData {
         let variant_data = Arc::new(variant_data);
         Arc::new(StructData { name, variant_data })
     }
+    pub(crate) fn union_data_query(db: &impl DefDatabase2, struct_: UnionId) -> Arc<StructData> {
+        let src = struct_.source(db);
+        let name = src.ast.name().map(|n| n.as_name());
+        let variant_data = VariantData::new(src.ast.kind());
+        let variant_data = Arc::new(variant_data);
+        Arc::new(StructData { name, variant_data })
+    }
 }
 
 impl EnumData {
@@ -74,6 +81,11 @@ impl EnumData {
             .collect();
         Arc::new(EnumData { name, variants })
     }
+
+    pub(crate) fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
+        let (id, _) = self.variants.iter().find(|(_id, data)| data.name.as_ref() == Some(name))?;
+        Some(id)
+    }
 }
 
 impl VariantData {
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index f6027013f..a42348101 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -2,13 +2,16 @@
 use std::sync::Arc;
 
 use hir_expand::{db::AstDatabase, HirFileId};
-use ra_db::{salsa, SourceDatabase};
+use ra_db::{salsa, CrateId, SourceDatabase};
 use ra_syntax::ast;
 
 use crate::{
     adt::{EnumData, StructData},
-    nameres::raw::{ImportSourceMap, RawItems},
-    EnumId, StructId,
+    nameres::{
+        raw::{ImportSourceMap, RawItems},
+        CrateDefMap,
+    },
+    EnumId, StructId, UnionId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
@@ -42,9 +45,15 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
     #[salsa::invoke(RawItems::raw_items_query)]
     fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
 
+    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
+    fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
+
     #[salsa::invoke(StructData::struct_data_query)]
     fn struct_data(&self, s: StructId) -> Arc<StructData>;
 
+    #[salsa::invoke(StructData::union_data_query)]
+    fn union_data(&self, s: UnionId) -> Arc<StructData>;
+
     #[salsa::invoke(EnumData::enum_data_query)]
     fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
 }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
new file mode 100644
index 000000000..9843009a5
--- /dev/null
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -0,0 +1,28 @@
+//! Diagnostics produced by `hir_def`.
+
+use std::any::Any;
+
+use hir_expand::diagnostics::Diagnostic;
+use ra_db::RelativePathBuf;
+use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
+
+use hir_expand::{HirFileId, Source};
+
+#[derive(Debug)]
+pub struct UnresolvedModule {
+    pub file: HirFileId,
+    pub decl: AstPtr<ast::Module>,
+    pub candidate: RelativePathBuf,
+}
+
+impl Diagnostic for UnresolvedModule {
+    fn message(&self) -> String {
+        "unresolved module".to_string()
+    }
+    fn source(&self) -> Source<SyntaxNodePtr> {
+        Source { file_id: self.file, ast: self.decl.into() }
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 76d5f1852..63ed2a098 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,25 +13,25 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod adt;
+pub mod diagnostics;
+
+#[cfg(test)]
+mod test_db;
+#[cfg(test)]
+mod marks;
 
 // FIXME: this should be private
 pub mod nameres;
 
 use std::hash::{Hash, Hasher};
 
-use hir_expand::{ast_id_map::FileAstId, db::AstDatabase, AstId, HirFileId};
+use hir_expand::{ast_id_map::FileAstId, db::AstDatabase, AstId, HirFileId, Source};
 use ra_arena::{impl_arena_id, RawId};
 use ra_db::{salsa, CrateId, FileId};
 use ra_syntax::{ast, AstNode, SyntaxNode};
 
 use crate::{builtin_type::BuiltinType, db::InternDatabase};
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct Source<T> {
-    pub file_id: HirFileId,
-    pub ast: T,
-}
-
 pub enum ModuleSource {
     SourceFile(ast::SourceFile),
     Module(ast::Module),
@@ -94,15 +94,6 @@ impl ModuleSource {
     }
 }
 
-impl<T> Source<T> {
-    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
-        Source { file_id: self.file_id, ast: f(self.ast) }
-    }
-    pub fn file_syntax(&self, db: &impl AstDatabase) -> SyntaxNode {
-        db.parse_or_expand(self.file_id).expect("source created from invalid file")
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
     pub krate: CrateId,
@@ -252,8 +243,8 @@ impl AstItemDef<ast::EnumDef> for EnumId {
 // FIXME: rename to `VariantId`, only enums can ave variants
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EnumVariantId {
-    parent: EnumId,
-    local_id: LocalEnumVariantId,
+    pub parent: EnumId,
+    pub local_id: LocalEnumVariantId,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
new file mode 100644
index 000000000..0b99eac71
--- /dev/null
+++ b/crates/ra_hir_def/src/marks.rs
@@ -0,0 +1,14 @@
+//! See test_utils/src/marks.rs
+
+test_utils::marks!(
+    bogus_paths
+    name_res_works_for_broken_modules
+    can_import_enum_variant
+    glob_enum
+    glob_across_crates
+    std_prelude
+    macro_rules_from_other_crates_are_visible_with_macro_use
+    prelude_is_macro_use
+    macro_dollar_crate_self
+    macro_dollar_crate_other
+);
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 11ba8a777..433bdde48 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -1,5 +1,543 @@
-//! FIXME: write short doc here
+//! This module implements import-resolution/macro expansion algorithm.
+//!
+//! The result of this module is `CrateDefMap`: a data structure 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
 
 // FIXME: review privacy of submodules
 pub mod raw;
+pub mod per_ns;
+pub mod collector;
 pub mod mod_resolution;
+
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use hir_expand::{diagnostics::DiagnosticSink, name::Name, MacroDefId};
+use once_cell::sync::Lazy;
+use ra_arena::Arena;
+use ra_db::{CrateId, Edition, FileId};
+use ra_prof::profile;
+use ra_syntax::ast;
+use rustc_hash::{FxHashMap, FxHashSet};
+use test_utils::tested_by;
+
+use crate::{
+    builtin_type::BuiltinType,
+    db::DefDatabase2,
+    nameres::{diagnostics::DefDiagnostic, per_ns::PerNs, raw::ImportId},
+    path::{Path, PathKind},
+    AdtId, AstId, CrateModuleId, EnumVariantId, ModuleDefId, ModuleId, TraitId,
+};
+
+/// Contains all top-level defs from a macro-expanded crate
+#[derive(Debug, PartialEq, Eq)]
+pub struct CrateDefMap {
+    krate: CrateId,
+    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`).
+    prelude: Option<ModuleId>,
+    extern_prelude: FxHashMap<Name, ModuleDefId>,
+    root: CrateModuleId,
+    pub modules: Arena<CrateModuleId, ModuleData>,
+
+    /// Some macros are not well-behavior, which leads to infinite loop
+    /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
+    /// We mark it down and skip it in collector
+    ///
+    /// FIXME:
+    /// Right now it only handle a poison macro in a single crate,
+    /// such that if other crate try to call that macro,
+    /// the whole process will do again until it became poisoned in that crate.
+    /// We should handle this macro set globally
+    /// However, do we want to put it as a global variable?
+    poison_macros: FxHashSet<MacroDefId>,
+
+    diagnostics: Vec<DefDiagnostic>,
+}
+
+impl std::ops::Index<CrateModuleId> for CrateDefMap {
+    type Output = ModuleData;
+    fn index(&self, id: CrateModuleId) -> &ModuleData {
+        &self.modules[id]
+    }
+}
+
+#[derive(Default, Debug, PartialEq, Eq)]
+pub struct ModuleData {
+    pub parent: Option<CrateModuleId>,
+    pub children: FxHashMap<Name, CrateModuleId>,
+    pub scope: ModuleScope,
+    /// None for root
+    pub declaration: Option<AstId<ast::Module>>,
+    /// None for inline modules.
+    ///
+    /// Note that non-inline modules, by definition, live inside non-macro file.
+    pub definition: Option<FileId>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct ModuleScope {
+    pub items: FxHashMap<Name, Resolution>,
+    /// Macros visable in current module in legacy textual scope
+    ///
+    /// For macros invoked by an unquatified identifier like `bar!()`, `legacy_macros` will be searched in first.
+    /// If it yields no result, then it turns to module scoped `macros`.
+    /// It macros with name quatified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped,
+    /// and only normal scoped `macros` will be searched in.
+    ///
+    /// Note that this automatically inherit macros defined textually before the definition of module itself.
+    ///
+    /// Module scoped macros will be inserted into `items` instead of here.
+    // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will
+    // be all resolved to the last one defined if shadowing happens.
+    legacy_macros: FxHashMap<Name, MacroDefId>,
+}
+
+static BUILTIN_SCOPE: Lazy<FxHashMap<Name, Resolution>> = Lazy::new(|| {
+    BuiltinType::ALL
+        .iter()
+        .map(|(name, ty)| {
+            (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), import: None })
+        })
+        .collect()
+});
+
+/// Legacy macros can only be accessed through special methods like `get_legacy_macros`.
+/// Other methods will only resolve values, types and module scoped macros only.
+impl ModuleScope {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, &'a Resolution)> + 'a {
+        //FIXME: shadowing
+        self.items.iter().chain(BUILTIN_SCOPE.iter())
+    }
+
+    /// Iterate over all module scoped macros
+    pub fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
+        self.items
+            .iter()
+            .filter_map(|(name, res)| res.def.get_macros().map(|macro_| (name, macro_)))
+    }
+
+    /// Iterate over all legacy textual scoped macros visable at the end of the module
+    pub fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
+        self.legacy_macros.iter().map(|(name, def)| (name, *def))
+    }
+
+    /// Get a name from current module scope, legacy macros are not included
+    pub fn get(&self, name: &Name) -> Option<&Resolution> {
+        self.items.get(name).or_else(|| BUILTIN_SCOPE.get(name))
+    }
+
+    pub fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
+        self.items.values().filter_map(|r| match r.def.take_types() {
+            Some(ModuleDefId::TraitId(t)) => Some(t),
+            _ => None,
+        })
+    }
+
+    fn get_legacy_macro(&self, name: &Name) -> Option<MacroDefId> {
+        self.legacy_macros.get(name).copied()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Resolution {
+    /// None for unresolved
+    pub def: PerNs,
+    /// ident by which this is imported into local scope.
+    pub import: Option<ImportId>,
+}
+
+impl Resolution {
+    pub(crate) fn from_macro(macro_: MacroDefId) -> Self {
+        Resolution { def: PerNs::macros(macro_), import: None }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct ResolvePathResult {
+    resolved_def: PerNs,
+    segment_index: Option<usize>,
+    reached_fixedpoint: ReachedFixedPoint,
+}
+
+impl ResolvePathResult {
+    fn empty(reached_fixedpoint: ReachedFixedPoint) -> ResolvePathResult {
+        ResolvePathResult::with(PerNs::none(), reached_fixedpoint, None)
+    }
+
+    fn with(
+        resolved_def: PerNs,
+        reached_fixedpoint: ReachedFixedPoint,
+        segment_index: Option<usize>,
+    ) -> ResolvePathResult {
+        ResolvePathResult { resolved_def, reached_fixedpoint, segment_index }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ResolveMode {
+    Import,
+    Other,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ReachedFixedPoint {
+    Yes,
+    No,
+}
+
+impl CrateDefMap {
+    pub(crate) fn crate_def_map_query(
+        // Note that this doesn't have `+ AstDatabase`!
+        // This gurantess that `CrateDefMap` is stable across reparses.
+        db: &impl DefDatabase2,
+        krate: CrateId,
+    ) -> Arc<CrateDefMap> {
+        let _p = profile("crate_def_map_query");
+        let def_map = {
+            let crate_graph = db.crate_graph();
+            let edition = crate_graph.edition(krate);
+            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,
+                poison_macros: FxHashSet::default(),
+                diagnostics: Vec::new(),
+            }
+        };
+        let def_map = collector::collect_defs(db, def_map);
+        Arc::new(def_map)
+    }
+
+    pub fn krate(&self) -> CrateId {
+        self.krate
+    }
+
+    pub fn root(&self) -> CrateModuleId {
+        self.root
+    }
+
+    pub fn prelude(&self) -> Option<ModuleId> {
+        self.prelude
+    }
+
+    pub fn extern_prelude(&self) -> &FxHashMap<Name, ModuleDefId> {
+        &self.extern_prelude
+    }
+
+    pub fn add_diagnostics(
+        &self,
+        db: &impl DefDatabase2,
+        module: CrateModuleId,
+        sink: &mut DiagnosticSink,
+    ) {
+        self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
+    }
+
+    pub fn resolve_path(
+        &self,
+        db: &impl DefDatabase2,
+        original_module: CrateModuleId,
+        path: &Path,
+    ) -> (PerNs, Option<usize>) {
+        let res = self.resolve_path_fp_with_macro(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
+    // the result.
+    fn resolve_path_fp_with_macro(
+        &self,
+        db: &impl DefDatabase2,
+        mode: ResolveMode,
+        original_module: CrateModuleId,
+        path: &Path,
+    ) -> ResolvePathResult {
+        let mut segments = path.segments.iter().enumerate();
+        let mut curr_per_ns: PerNs = match path.kind {
+            PathKind::DollarCrate(krate) => {
+                if krate == self.krate {
+                    tested_by!(macro_dollar_crate_self);
+                    PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
+                } else {
+                    let def_map = db.crate_def_map(krate);
+                    let module = ModuleId { krate, module_id: def_map.root };
+                    tested_by!(macro_dollar_crate_other);
+                    PerNs::types(module.into())
+                }
+            }
+            PathKind::Crate => {
+                PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
+            }
+            PathKind::Self_ => {
+                PerNs::types(ModuleId { 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)
+            // FIXME there must be a nicer way to write this condition
+            PathKind::Plain | PathKind::Abs
+                if self.edition == Edition::Edition2015
+                    && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
+            {
+                let segment = match segments.next() {
+                    Some((_, segment)) => segment,
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
+                };
+                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
+                self.resolve_name_in_crate_root_or_extern_prelude(&segment.name)
+            }
+            PathKind::Plain => {
+                let segment = match segments.next() {
+                    Some((_, segment)) => segment,
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
+                };
+                log::debug!("resolving {:?} in module", segment);
+                self.resolve_name_in_module(db, original_module, &segment.name)
+            }
+            PathKind::Super => {
+                if let Some(p) = self.modules[original_module].parent {
+                    PerNs::types(ModuleId { krate: self.krate, module_id: p }.into())
+                } else {
+                    log::debug!("super path in root module");
+                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                }
+            }
+            PathKind::Abs => {
+                // 2018-style absolute path -- only extern prelude
+                let segment = match segments.next() {
+                    Some((_, segment)) => segment,
+                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
+                };
+                if let Some(def) = self.extern_prelude.get(&segment.name) {
+                    log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
+                    PerNs::types(*def)
+                } else {
+                    return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
+                }
+            }
+            PathKind::Type(_) => {
+                // This is handled in `infer::infer_path_expr`
+                // The result returned here does not matter
+                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+            }
+        };
+
+        for (i, segment) in segments {
+            let curr = match curr_per_ns.take_types() {
+                Some(r) => r,
+                None => {
+                    // we still have path segments left, but the path so far
+                    // didn't resolve in the types namespace => no resolution
+                    // (don't break here because `curr_per_ns` might contain
+                    // something in the value namespace, and it would be wrong
+                    // to return that)
+                    return ResolvePathResult::empty(ReachedFixedPoint::No);
+                }
+            };
+            // resolve segment in curr
+
+            curr_per_ns = match curr {
+                ModuleDefId::ModuleId(module) => {
+                    if module.krate != self.krate {
+                        let path =
+                            Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
+                        log::debug!("resolving {:?} in other crate", 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,
+                            s.map(|s| s + i),
+                        );
+                    }
+
+                    // Since it is a qualified path here, it should not contains legacy macros
+                    match self[module.module_id].scope.get(&segment.name) {
+                        Some(res) => res.def,
+                        _ => {
+                            log::debug!("path segment {:?} not found", segment.name);
+                            return ResolvePathResult::empty(ReachedFixedPoint::No);
+                        }
+                    }
+                }
+                ModuleDefId::AdtId(AdtId::EnumId(e)) => {
+                    // enum variant
+                    tested_by!(can_import_enum_variant);
+                    let enum_data = db.enum_data(e);
+                    match enum_data.variant(&segment.name) {
+                        Some(local_id) => {
+                            let variant = EnumVariantId { parent: e, local_id };
+                            PerNs::both(variant.into(), variant.into())
+                        }
+                        None => {
+                            return ResolvePathResult::with(
+                                PerNs::types(e.into()),
+                                ReachedFixedPoint::Yes,
+                                Some(i),
+                            );
+                        }
+                    }
+                }
+                s => {
+                    // could be an inherent method call in UFCS form
+                    // (`Struct::method`), or some other kind of associated item
+                    log::debug!(
+                        "path segment {:?} resolved to non-module {:?}, but is not last",
+                        segment.name,
+                        curr,
+                    );
+
+                    return ResolvePathResult::with(
+                        PerNs::types(s),
+                        ReachedFixedPoint::Yes,
+                        Some(i),
+                    );
+                }
+            };
+        }
+        ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
+    }
+
+    fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs {
+        let from_crate_root =
+            self[self.root].scope.get(name).map_or_else(PerNs::none, |res| res.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 DefDatabase2,
+        module: CrateModuleId,
+        name: &Name,
+    ) -> PerNs {
+        // Resolve in:
+        //  - legacy scope of macro
+        //  - current module / scope
+        //  - extern prelude
+        //  - std prelude
+        let from_legacy_macro =
+            self[module].scope.get_legacy_macro(name).map_or_else(PerNs::none, PerNs::macros);
+        let from_scope = self[module].scope.get(name).map_or_else(PerNs::none, |res| res.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_legacy_macro.or(from_scope).or(from_extern_prelude).or(from_prelude)
+    }
+
+    fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
+        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+    }
+
+    fn resolve_in_prelude(&self, db: &impl DefDatabase2, name: &Name) -> PerNs {
+        if let Some(prelude) = self.prelude {
+            let keep;
+            let def_map = if prelude.krate == self.krate {
+                self
+            } else {
+                // Extend lifetime
+                keep = db.crate_def_map(prelude.krate);
+                &keep
+            };
+            def_map[prelude.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
+        } else {
+            PerNs::none()
+        }
+    }
+}
+
+mod diagnostics {
+    use hir_expand::diagnostics::DiagnosticSink;
+    use ra_db::RelativePathBuf;
+    use ra_syntax::{ast, AstPtr};
+
+    use crate::{db::DefDatabase2, diagnostics::UnresolvedModule, nameres::CrateModuleId, AstId};
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub(super) enum DefDiagnostic {
+        UnresolvedModule {
+            module: CrateModuleId,
+            declaration: AstId<ast::Module>,
+            candidate: RelativePathBuf,
+        },
+    }
+
+    impl DefDiagnostic {
+        pub(super) fn add_to(
+            &self,
+            db: &impl DefDatabase2,
+            target_module: CrateModuleId,
+            sink: &mut DiagnosticSink,
+        ) {
+            match self {
+                DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
+                    if *module != target_module {
+                        return;
+                    }
+                    let decl = declaration.to_node(db);
+                    sink.push(UnresolvedModule {
+                        file: declaration.file_id(),
+                        decl: AstPtr::new(&decl),
+                        candidate: candidate.clone(),
+                    })
+                }
+            }
+        }
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
new file mode 100644
index 000000000..3b61d9895
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -0,0 +1,844 @@
+//! FIXME: write short doc here
+
+use hir_expand::{
+    name::{self, AsName, Name},
+    HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind,
+};
+use ra_cfg::CfgOptions;
+use ra_db::{CrateId, FileId};
+use ra_syntax::{ast, SmolStr};
+use rustc_hash::FxHashMap;
+use test_utils::tested_by;
+
+use crate::{
+    attr::Attr,
+    db::DefDatabase2,
+    nameres::{
+        diagnostics::DefDiagnostic, mod_resolution::ModDir, per_ns::PerNs, raw, CrateDefMap,
+        ModuleData, ReachedFixedPoint, Resolution, ResolveMode,
+    },
+    path::{Path, PathKind},
+    AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId,
+    LocationCtx, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
+};
+
+pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
+    let crate_graph = db.crate_graph();
+
+    // populate external prelude
+    for dep in crate_graph.dependencies(def_map.krate) {
+        let dep_def_map = db.crate_def_map(dep.crate_id);
+        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
+        def_map.extern_prelude.insert(
+            dep.as_name(),
+            ModuleId { krate: dep.crate_id, module_id: dep_def_map.root }.into(),
+        );
+
+        // look for the prelude
+        if def_map.prelude.is_none() {
+            let map = db.crate_def_map(dep.crate_id);
+            if map.prelude.is_some() {
+                def_map.prelude = map.prelude;
+            }
+        }
+    }
+
+    let cfg_options = crate_graph.cfg_options(def_map.krate);
+
+    let mut collector = DefCollector {
+        db,
+        def_map,
+        glob_imports: FxHashMap::default(),
+        unresolved_imports: Vec::new(),
+        unexpanded_macros: Vec::new(),
+        mod_dirs: FxHashMap::default(),
+        macro_stack_monitor: MacroStackMonitor::default(),
+        cfg_options,
+    };
+    collector.collect();
+    collector.finish()
+}
+
+#[derive(Default)]
+struct MacroStackMonitor {
+    counts: FxHashMap<MacroDefId, u32>,
+
+    /// Mainly use for test
+    validator: Option<Box<dyn Fn(u32) -> bool>>,
+}
+
+impl MacroStackMonitor {
+    fn increase(&mut self, macro_def_id: MacroDefId) {
+        *self.counts.entry(macro_def_id).or_default() += 1;
+    }
+
+    fn decrease(&mut self, macro_def_id: MacroDefId) {
+        *self.counts.entry(macro_def_id).or_default() -= 1;
+    }
+
+    fn is_poison(&self, macro_def_id: MacroDefId) -> bool {
+        let cur = *self.counts.get(&macro_def_id).unwrap_or(&0);
+
+        if let Some(validator) = &self.validator {
+            validator(cur)
+        } else {
+            cur > 100
+        }
+    }
+}
+
+/// Walks the tree of module recursively
+struct DefCollector<'a, DB> {
+    db: &'a DB,
+    def_map: CrateDefMap,
+    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
+    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
+    unexpanded_macros: Vec<(CrateModuleId, AstId<ast::MacroCall>, Path)>,
+    mod_dirs: FxHashMap<CrateModuleId, ModDir>,
+
+    /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
+    /// To prevent stack overflow, we add a deep counter here for prevent that.
+    macro_stack_monitor: MacroStackMonitor,
+
+    cfg_options: &'a CfgOptions,
+}
+
+impl<DB> DefCollector<'_, DB>
+where
+    DB: DefDatabase2,
+{
+    fn collect(&mut self) {
+        let crate_graph = self.db.crate_graph();
+        let file_id = crate_graph.crate_root(self.def_map.krate);
+        let raw_items = self.db.raw_items(file_id.into());
+        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,
+            mod_dir: ModDir::root(),
+        }
+        .collect(raw_items.items());
+
+        // main name resolution fixed-point loop.
+        let mut i = 0;
+        loop {
+            self.db.check_canceled();
+            match (self.resolve_imports(), self.resolve_macros()) {
+                (ReachedFixedPoint::Yes, ReachedFixedPoint::Yes) => break,
+                _ => i += 1,
+            }
+            if i == 1000 {
+                log::error!("name resolution is stuck");
+                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)
+        }
+    }
+
+    /// Define a macro with `macro_rules`.
+    ///
+    /// It will define the macro in legacy textual scope, and if it has `#[macro_export]`,
+    /// then it is also defined in the root module scope.
+    /// You can `use` or invoke it by `crate::macro_name` anywhere, before or after the definition.
+    ///
+    /// It is surprising that the macro will never be in the current module scope.
+    /// These code fails with "unresolved import/macro",
+    /// ```rust,compile_fail
+    /// mod m { macro_rules! foo { () => {} } }
+    /// use m::foo as bar;
+    /// ```
+    ///
+    /// ```rust,compile_fail
+    /// macro_rules! foo { () => {} }
+    /// self::foo!();
+    /// crate::foo!();
+    /// ```
+    ///
+    /// Well, this code compiles, bacause the plain path `foo` in `use` is searched
+    /// in the legacy textual scope only.
+    /// ```rust
+    /// macro_rules! foo { () => {} }
+    /// use foo as bar;
+    /// ```
+    fn define_macro(
+        &mut self,
+        module_id: CrateModuleId,
+        name: Name,
+        macro_: MacroDefId,
+        export: bool,
+    ) {
+        // Textual scoping
+        self.define_legacy_macro(module_id, name.clone(), macro_);
+
+        // Module scoping
+        // In Rust, `#[macro_export]` macros are unconditionally visible at the
+        // crate root, even if the parent modules is **not** visible.
+        if export {
+            self.update(self.def_map.root, None, &[(name, Resolution::from_macro(macro_))]);
+        }
+    }
+
+    /// Define a legacy textual scoped macro in module
+    ///
+    /// We use a map `legacy_macros` to store all legacy textual scoped macros visable per module.
+    /// It will clone all macros from parent legacy scope, whose definition is prior to
+    /// the definition of current module.
+    /// And also, `macro_use` on a module will import all legacy macros visable inside to
+    /// current legacy scope, with possible shadowing.
+    fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDefId) {
+        // Always shadowing
+        self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_);
+    }
+
+    /// Import macros from `#[macro_use] extern crate`.
+    fn import_macros_from_extern_crate(
+        &mut self,
+        current_module_id: CrateModuleId,
+        import: &raw::ImportData,
+    ) {
+        log::debug!(
+            "importing macros from extern crate: {:?} ({:?})",
+            import,
+            self.def_map.edition,
+        );
+
+        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"),
+        );
+
+        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
+            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
+            self.import_all_macros_exported(current_module_id, m.krate);
+        }
+    }
+
+    /// Import all exported macros from another crate
+    ///
+    /// Exported macros are just all macros in the root module scope.
+    /// Note that it contains not only all `#[macro_export]` macros, but also all aliases
+    /// created by `use` in the root module, ignoring the visibility of `use`.
+    fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: CrateId) {
+        let def_map = self.db.crate_def_map(krate);
+        for (name, def) in def_map[def_map.root].scope.macros() {
+            // `macro_use` only bring things into legacy scope.
+            self.define_legacy_macro(current_module_id, name.clone(), def);
+        }
+    }
+
+    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(
+        &self,
+        module_id: CrateModuleId,
+        import: &raw::ImportData,
+    ) -> (PerNs, 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_with_macro(
+                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,
+        import_id: raw::ImportId,
+        import: &raw::ImportData,
+    ) {
+        if import.is_glob {
+            log::debug!("glob import: {:?}", import);
+            match def.take_types() {
+                Some(ModuleDefId::ModuleId(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;
+
+                        // Module scoped macros is included
+                        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;
+
+                        // Module scoped macros is included
+                        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(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
+                    tested_by!(glob_enum);
+                    // glob import from enum => just import all the variants
+                    let enum_data = self.db.enum_data(e);
+                    let resolutions = enum_data
+                        .variants
+                        .iter()
+                        .filter_map(|(local_id, variant_data)| {
+                            let name = variant_data.name.clone()?;
+                            let variant = EnumVariantId { parent: e, local_id };
+                            let res = Resolution {
+                                def: PerNs::both(variant.into(), variant.into()),
+                                import: Some(import_id),
+                            };
+                            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.macros.is_none() && res.def.macros.is_some() {
+                existing.def.macros = res.def.macros;
+                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);
+        }
+    }
+
+    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, ast_id, path)| {
+            let resolved_res = self.def_map.resolve_path_fp_with_macro(
+                self.db,
+                ResolveMode::Other,
+                *module_id,
+                path,
+            );
+
+            if let Some(def) = resolved_res.resolved_def.get_macros() {
+                let call_id = self.db.intern_macro(MacroCallLoc { def, ast_id: *ast_id });
+                resolved.push((*module_id, call_id, def));
+                res = ReachedFixedPoint::No;
+                return false;
+            }
+
+            true
+        });
+
+        self.unexpanded_macros = macros;
+
+        for (module_id, macro_call_id, macro_def_id) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id);
+        }
+
+        res
+    }
+
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: CrateModuleId,
+        macro_call_id: MacroCallId,
+        macro_def_id: MacroDefId,
+    ) {
+        if self.def_map.poison_macros.contains(&macro_def_id) {
+            return;
+        }
+
+        self.macro_stack_monitor.increase(macro_def_id);
+
+        if !self.macro_stack_monitor.is_poison(macro_def_id) {
+            let file_id: HirFileId = macro_call_id.as_file(MacroFileKind::Items);
+            let raw_items = self.db.raw_items(file_id);
+            let mod_dir = self.mod_dirs[&module_id].clone();
+            ModCollector {
+                def_collector: &mut *self,
+                file_id,
+                module_id,
+                raw_items: &raw_items,
+                mod_dir,
+            }
+            .collect(raw_items.items());
+        } else {
+            log::error!("Too deep macro expansion: {:?}", macro_call_id);
+            self.def_map.poison_macros.insert(macro_def_id);
+        }
+
+        self.macro_stack_monitor.decrease(macro_def_id);
+    }
+
+    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,
+    mod_dir: ModDir,
+}
+
+impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
+where
+    DB: DefDatabase2,
+{
+    fn collect(&mut self, items: &[raw::RawItem]) {
+        // Note: don't assert that inserted value is fresh: it's simply not true
+        // for macros.
+        self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone());
+
+        // Prelude module is always considered to be `#[macro_use]`.
+        if let Some(prelude_module) = self.def_collector.def_map.prelude {
+            if prelude_module.krate != self.def_collector.def_map.krate {
+                tested_by!(prelude_is_macro_use);
+                self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
+            }
+        }
+
+        // This should be processed eagerly instead of deferred to resolving.
+        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
+        // any other items.
+        for item in items {
+            if self.is_cfg_enabled(item.attrs()) {
+                if let raw::RawItemKind::Import(import_id) = item.kind {
+                    let import = self.raw_items[import_id].clone();
+                    if import.is_extern_crate && import.is_macro_use {
+                        self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
+                    }
+                }
+            }
+        }
+
+        for item in items {
+            if self.is_cfg_enabled(item.attrs()) {
+                match item.kind {
+                    raw::RawItemKind::Module(m) => {
+                        self.collect_module(&self.raw_items[m], item.attrs())
+                    }
+                    raw::RawItemKind::Import(import_id) => self
+                        .def_collector
+                        .unresolved_imports
+                        .push((self.module_id, import_id, self.raw_items[import_id].clone())),
+                    raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]),
+                    raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+                }
+            }
+        }
+    }
+
+    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &[Attr]) {
+        let path_attr = self.path_attr(attrs);
+        let is_macro_use = self.is_macro_use(attrs);
+        match module {
+            // inline module, just recurse
+            raw::ModuleData::Definition { name, items, ast_id } => {
+                let module_id =
+                    self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None);
+
+                ModCollector {
+                    def_collector: &mut *self.def_collector,
+                    module_id,
+                    file_id: self.file_id,
+                    raw_items: self.raw_items,
+                    mod_dir: self.mod_dir.descend_into_definition(name, path_attr),
+                }
+                .collect(&*items);
+                if is_macro_use {
+                    self.import_all_legacy_macros(module_id);
+                }
+            }
+            // out of line module, resolve, parse and recurse
+            raw::ModuleData::Declaration { name, ast_id } => {
+                let ast_id = AstId::new(self.file_id, *ast_id);
+                match self.mod_dir.resolve_declaration(
+                    self.def_collector.db,
+                    self.file_id,
+                    name,
+                    path_attr,
+                ) {
+                    Ok((file_id, mod_dir)) => {
+                        let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
+                        let raw_items = self.def_collector.db.raw_items(file_id.into());
+                        ModCollector {
+                            def_collector: &mut *self.def_collector,
+                            module_id,
+                            file_id: file_id.into(),
+                            raw_items: &raw_items,
+                            mod_dir,
+                        }
+                        .collect(raw_items.items());
+                        if is_macro_use {
+                            self.import_all_legacy_macros(module_id);
+                        }
+                    }
+                    Err(candidate) => self.def_collector.def_map.diagnostics.push(
+                        DefDiagnostic::UnresolvedModule {
+                            module: self.module_id,
+                            declaration: ast_id,
+                            candidate,
+                        },
+                    ),
+                };
+            }
+        }
+    }
+
+    fn push_child_module(
+        &mut self,
+        name: Name,
+        declaration: AstId<ast::Module>,
+        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[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone();
+        modules[self.module_id].children.insert(name.clone(), res);
+        let resolution = Resolution {
+            def: PerNs::types(
+                ModuleId { 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 =
+            ModuleId { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+
+        let name = def.name.clone();
+        let def: PerNs = match def.kind {
+            raw::DefKind::Function(ast_id) => {
+                PerNs::values(FunctionId::from_ast_id(ctx, ast_id).into())
+            }
+            raw::DefKind::Struct(ast_id) => {
+                let s = StructId::from_ast_id(ctx, ast_id).into();
+                PerNs::both(s, s)
+            }
+            raw::DefKind::Union(ast_id) => {
+                let s = UnionId::from_ast_id(ctx, ast_id).into();
+                PerNs::both(s, s)
+            }
+            raw::DefKind::Enum(ast_id) => PerNs::types(EnumId::from_ast_id(ctx, ast_id).into()),
+            raw::DefKind::Const(ast_id) => PerNs::values(ConstId::from_ast_id(ctx, ast_id).into()),
+            raw::DefKind::Static(ast_id) => {
+                PerNs::values(StaticId::from_ast_id(ctx, ast_id).into())
+            }
+            raw::DefKind::Trait(ast_id) => PerNs::types(TraitId::from_ast_id(ctx, ast_id).into()),
+            raw::DefKind::TypeAlias(ast_id) => {
+                PerNs::types(TypeAliasId::from_ast_id(ctx, ast_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) {
+        let ast_id = AstId::new(self.file_id, mac.ast_id);
+
+        // Case 1: macro rules, define a macro in crate-global mutable scope
+        if is_macro_rules(&mac.path) {
+            if let Some(name) = &mac.name {
+                let macro_id = MacroDefId { ast_id, krate: self.def_collector.def_map.krate };
+                self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
+            }
+            return;
+        }
+
+        // Case 2: try to resolve in legacy scope and expand macro_rules, triggering
+        // recursive item collection.
+        if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
+            self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
+        }) {
+            let macro_call_id =
+                self.def_collector.db.intern_macro(MacroCallLoc { def: macro_def, ast_id });
+
+            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_def);
+            return;
+        }
+
+        // Case 3: resolve in module scope, expand during name resolution.
+        // We rewrite simple path `macro_name` to `self::macro_name` to force resolve in module scope only.
+        let mut path = mac.path.clone();
+        if path.is_ident() {
+            path.kind = PathKind::Self_;
+        }
+        self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path));
+    }
+
+    fn import_all_legacy_macros(&mut self, module_id: CrateModuleId) {
+        let macros = self.def_collector.def_map[module_id].scope.legacy_macros.clone();
+        for (name, macro_) in macros {
+            self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
+        }
+    }
+
+    fn is_cfg_enabled(&self, attrs: &[Attr]) -> bool {
+        attrs.iter().all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
+    }
+
+    fn path_attr<'a>(&self, attrs: &'a [Attr]) -> Option<&'a SmolStr> {
+        attrs.iter().find_map(|attr| attr.as_path())
+    }
+
+    fn is_macro_use<'a>(&self, attrs: &'a [Attr]) -> bool {
+        attrs.iter().any(|attr| attr.is_simple_atom("macro_use"))
+    }
+}
+
+fn is_macro_rules(path: &Path) -> bool {
+    path.as_ident() == Some(&name::MACRO_RULES)
+}
+
+#[cfg(test)]
+mod tests {
+    use ra_arena::Arena;
+    use ra_db::{fixture::WithFixture, SourceDatabase};
+    use rustc_hash::FxHashSet;
+
+    use crate::{db::DefDatabase2, test_db::TestDB};
+
+    use super::*;
+
+    fn do_collect_defs(
+        db: &impl DefDatabase2,
+        def_map: CrateDefMap,
+        monitor: MacroStackMonitor,
+    ) -> CrateDefMap {
+        let mut collector = DefCollector {
+            db,
+            def_map,
+            glob_imports: FxHashMap::default(),
+            unresolved_imports: Vec::new(),
+            unexpanded_macros: Vec::new(),
+            mod_dirs: FxHashMap::default(),
+            macro_stack_monitor: monitor,
+            cfg_options: &CfgOptions::default(),
+        };
+        collector.collect();
+        collector.finish()
+    }
+
+    fn do_limited_resolve(code: &str, limit: u32, poison_limit: u32) -> CrateDefMap {
+        let (db, _file_id) = TestDB::with_single_file(&code);
+        let krate = db.crate_graph().iter().next().unwrap();
+
+        let def_map = {
+            let edition = db.crate_graph().edition(krate);
+            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,
+                poison_macros: FxHashSet::default(),
+                diagnostics: Vec::new(),
+            }
+        };
+
+        let mut monitor = MacroStackMonitor::default();
+        monitor.validator = Some(Box::new(move |count| {
+            assert!(count < limit);
+            count >= poison_limit
+        }));
+
+        do_collect_defs(&db, def_map, monitor)
+    }
+
+    #[test]
+    fn test_macro_expand_limit_width() {
+        do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); }
+        }
+foo!(KABOOM);
+        "#,
+            16,
+            1000,
+        );
+    }
+
+    #[test]
+    fn test_macro_expand_poisoned() {
+        let def = do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($ty:ty) => { foo!($ty); }
+        }
+foo!(KABOOM);
+        "#,
+            100,
+            16,
+        );
+
+        assert_eq!(def.poison_macros.len(), 1);
+    }
+
+    #[test]
+    fn test_macro_expand_normal() {
+        let def = do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($ident:ident) => { struct $ident {} }
+        }
+foo!(Bar);
+        "#,
+            16,
+            16,
+        );
+
+        assert_eq!(def.poison_macros.len(), 0);
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index 7d7e2779a..f6b0b8fb1 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -1,8 +1,7 @@
 //! This module resolves `mod foo;` declaration to file.
 use hir_expand::name::Name;
-use ra_db::FileId;
+use ra_db::{FileId, RelativePathBuf};
 use ra_syntax::SmolStr;
-use relative_path::RelativePathBuf;
 
 use crate::{db::DefDatabase2, HirFileId};
 
diff --git a/crates/ra_hir_def/src/nameres/per_ns.rs b/crates/ra_hir_def/src/nameres/per_ns.rs
new file mode 100644
index 000000000..298b0b0c7
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/per_ns.rs
@@ -0,0 +1,82 @@
+//! FIXME: write short doc here
+
+use hir_expand::MacroDefId;
+
+use crate::ModuleDefId;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Namespace {
+    Types,
+    Values,
+    // Note that only type inference uses this enum, and it doesn't care about macros.
+    // Macro,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct PerNs {
+    pub types: Option<ModuleDefId>,
+    pub values: Option<ModuleDefId>,
+    /// Since macros has different type, many methods simply ignore it.
+    /// We can only use special method like `get_macros` to access it.
+    pub macros: Option<MacroDefId>,
+}
+
+impl Default for PerNs {
+    fn default() -> Self {
+        PerNs { types: None, values: None, macros: None }
+    }
+}
+
+impl PerNs {
+    pub fn none() -> PerNs {
+        PerNs { types: None, values: None, macros: None }
+    }
+
+    pub fn values(t: ModuleDefId) -> PerNs {
+        PerNs { types: None, values: Some(t), macros: None }
+    }
+
+    pub fn types(t: ModuleDefId) -> PerNs {
+        PerNs { types: Some(t), values: None, macros: None }
+    }
+
+    pub fn both(types: ModuleDefId, values: ModuleDefId) -> PerNs {
+        PerNs { types: Some(types), values: Some(values), macros: None }
+    }
+
+    pub fn macros(macro_: MacroDefId) -> PerNs {
+        PerNs { types: None, values: None, macros: Some(macro_) }
+    }
+
+    pub fn is_none(&self) -> bool {
+        self.types.is_none() && self.values.is_none() && self.macros.is_none()
+    }
+
+    pub fn is_all(&self) -> bool {
+        self.types.is_some() && self.values.is_some() && self.macros.is_some()
+    }
+
+    pub fn take_types(self) -> Option<ModuleDefId> {
+        self.types
+    }
+
+    pub fn take_values(self) -> Option<ModuleDefId> {
+        self.values
+    }
+
+    pub fn get_macros(&self) -> Option<MacroDefId> {
+        self.macros
+    }
+
+    pub fn only_macros(&self) -> PerNs {
+        PerNs { types: None, values: None, macros: self.macros }
+    }
+
+    pub fn or(self, other: PerNs) -> PerNs {
+        PerNs {
+            types: self.types.or(other.types),
+            values: self.values.or(other.values),
+            macros: self.macros.or(other.macros),
+        }
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 86c05d602..cb47fa317 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -14,6 +14,7 @@ use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner},
     AstNode, AstPtr, SourceFile,
 };
+use test_utils::tested_by;
 
 use crate::{attr::Attr, db::DefDatabase2, path::Path, FileAstId, HirFileId, ModuleSource, Source};
 
@@ -297,8 +298,7 @@ impl RawItemsCollector {
             self.push_item(current_module, attrs, RawItemKind::Module(item));
             return;
         }
-        // FIXME: restore this mark once we complete hir splitting
-        // tested_by!(name_res_works_for_broken_modules);
+        tested_by!(name_res_works_for_broken_modules);
     }
 
     fn add_use_item(&mut self, current_module: Option<Module>, use_item: ast::UseItem) {
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
new file mode 100644
index 000000000..52bd0aa91
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -0,0 +1,522 @@
+mod globs;
+mod incremental;
+mod macros;
+mod mod_resolution;
+mod primitives;
+
+use std::sync::Arc;
+
+use insta::assert_snapshot;
+use ra_db::{fixture::WithFixture, SourceDatabase};
+use test_utils::covers;
+
+use crate::{db::DefDatabase2, nameres::*, test_db::TestDB, CrateModuleId};
+
+fn def_map(fixtute: &str) -> String {
+    let dm = compute_crate_def_map(fixtute);
+    render_crate_def_map(&dm)
+}
+
+fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
+    let db = TestDB::with_files(fixture);
+    let krate = db.crate_graph().iter().next().unwrap();
+    db.crate_def_map(krate)
+}
+
+fn render_crate_def_map(map: &CrateDefMap) -> String {
+    let mut buf = String::new();
+    go(&mut buf, map, "\ncrate", map.root());
+    return buf.trim().to_string();
+
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+        *buf += path;
+        *buf += "\n";
+
+        let mut entries = map.modules[module]
+            .scope
+            .items
+            .iter()
+            .map(|(name, res)| (name, res.def))
+            .collect::<Vec<_>>();
+        entries.sort_by_key(|(name, _)| *name);
+
+        for (name, res) in entries {
+            *buf += &format!("{}:", name);
+
+            if res.types.is_some() {
+                *buf += " t";
+            }
+            if res.values.is_some() {
+                *buf += " v";
+            }
+            if res.macros.is_some() {
+                *buf += " m";
+            }
+            if res.is_none() {
+                *buf += " _";
+            }
+
+            *buf += "\n";
+        }
+
+        for (name, child) in map.modules[module].children.iter() {
+            let path = path.to_string() + &format!("::{}", name);
+            go(buf, map, &path, *child);
+        }
+    }
+}
+
+#[test]
+fn crate_def_map_smoke_test() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        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 }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮E: t
+        ⋮S: t v
+        ⋮V: t v
+        ⋮foo: t
+        ⋮
+        ⋮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(
+        "
+        //- /lib.rs
+        mod foo;
+        struct S;
+        use self;
+
+        //- /foo/mod.rs
+        use super;
+        use crate;
+
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮S: t v
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+    "###
+    )
+}
+
+#[test]
+fn use_as() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+
+        use crate::foo::Baz as Foo;
+
+        //- /foo/mod.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot!(map,
+        @r###"
+   ⋮crate
+   ⋮Foo: t v
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+    "###
+    );
+}
+
+#[test]
+fn use_trees() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+
+        use crate::foo::bar::{Baz, Quux};
+
+        //- /foo/mod.rs
+        pub mod bar;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        pub enum Quux {};
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮Quux: t
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+        ⋮Quux: t
+    "###);
+}
+
+#[test]
+fn re_exports() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+
+        use self::foo::Baz;
+
+        //- /foo/mod.rs
+        pub mod bar;
+
+        pub use self::bar::Baz;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn std_prelude() {
+    covers!(std_prelude);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use Foo::*;
+
+        //- /lib.rs crate:test_crate
+        mod prelude;
+        #[prelude_import]
+        use prelude::*;
+
+        //- /prelude.rs
+        pub enum Foo { Bar, Baz };
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn can_import_enum_variant() {
+    covers!(can_import_enum_variant);
+    let map = def_map(
+        "
+        //- /lib.rs
+        enum E { V }
+        use self::E::V;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮E: t
+        ⋮V: t v
+    "###
+    );
+}
+
+#[test]
+fn edition_2015_imports() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:other_crate edition:2015
+        mod foo;
+        mod bar;
+
+        //- /bar.rs
+        struct Bar;
+
+        //- /foo.rs
+        use bar::Bar;
+        use other_crate::FromLib;
+
+        //- /lib.rs crate:other_crate edition:2018
+        struct FromLib;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮bar: t
+        ⋮foo: t
+        ⋮
+        ⋮crate::bar
+        ⋮Bar: t v
+        ⋮
+        ⋮crate::foo
+        ⋮Bar: t v
+        ⋮FromLib: t v
+    "###);
+}
+
+#[test]
+fn item_map_using_self() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use crate::foo::bar::Baz::{self};
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot!(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 map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::Baz;
+
+        //- /lib.rs crate:test_crate
+        pub struct Baz;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn extern_crate_rename() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:alloc
+        extern crate alloc as alloc_crate;
+
+        mod alloc;
+        mod sync;
+
+        //- /sync.rs
+        use alloc_crate::Arc;
+
+        //- /lib.rs crate:alloc
+        struct Arc;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮alloc_crate: t
+   ⋮sync: t
+   ⋮
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###);
+}
+
+#[test]
+fn extern_crate_rename_2015_edition() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:alloc edition:2015
+        extern crate alloc as alloc_crate;
+
+        mod alloc;
+        mod sync;
+
+        //- /sync.rs
+        use alloc_crate::Arc;
+
+        //- /lib.rs crate:alloc
+        struct Arc;
+        ",
+    );
+
+    assert_snapshot!(map,
+        @r###"
+   ⋮crate
+   ⋮alloc_crate: t
+   ⋮sync: t
+   ⋮
+   ⋮crate::sync
+   ⋮Arc: t v
+    "###
+    );
+}
+
+#[test]
+fn import_across_source_roots() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::a::b::C;
+
+        //- root /test_crate/
+
+        //- /test_crate/lib.rs crate:test_crate
+        pub mod a {
+            pub mod b {
+                pub struct C;
+            }
+        }
+
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮C: t v
+    "###);
+}
+
+#[test]
+fn reexport_across_crates() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::Baz;
+
+        //- /lib.rs crate:test_crate
+        pub use foo::Baz;
+
+        mod foo;
+
+        //- /foo.rs
+        pub struct Baz;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn values_dont_shadow_extern_crates() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        fn foo() {}
+        use foo::Bar;
+
+        //- /foo/lib.rs crate:foo
+        pub struct Bar;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮foo: v
+    "###);
+}
+
+#[test]
+fn cfg_not_test() {
+    let map = def_map(
+        r#"
+        //- /main.rs crate:main deps:std
+        use {Foo, Bar, Baz};
+
+        //- /lib.rs crate:std
+        #[prelude_import]
+        pub use self::prelude::*;
+        mod prelude {
+            #[cfg(test)]
+            pub struct Foo;
+            #[cfg(not(test))]
+            pub struct Bar;
+            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+            pub struct Baz;
+        }
+        "#,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: _
+        ⋮Foo: _
+    "###);
+}
+
+#[test]
+fn cfg_test() {
+    let map = def_map(
+        r#"
+        //- /main.rs crate:main deps:std
+        use {Foo, Bar, Baz};
+
+        //- /lib.rs crate:std cfg:test,feature=foo,feature=bar,opt=42
+        #[prelude_import]
+        pub use self::prelude::*;
+        mod prelude {
+            #[cfg(test)]
+            pub struct Foo;
+            #[cfg(not(test))]
+            pub struct Bar;
+            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+            pub struct Baz;
+        }
+        "#,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: _
+        ⋮Baz: t v
+        ⋮Foo: t v
+    "###);
+}
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
new file mode 100644
index 000000000..5b03fe365
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -0,0 +1,114 @@
+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!(map, @r###"
+   ⋮crate
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮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!(map, @r###"
+   ⋮crate
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮foo: t
+   ⋮
+   ⋮crate::foo
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::foo::bar
+   ⋮Baz: t v
+   ⋮Foo: t v
+   ⋮bar: t
+    "###
+    );
+}
+
+#[test]
+fn glob_across_crates() {
+    covers!(glob_across_crates);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:test_crate
+        use test_crate::*;
+
+        //- /lib.rs crate:test_crate
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot!(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!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Baz: t v
+   ⋮Foo: t
+    "###
+    );
+}
diff --git a/crates/ra_hir_def/src/nameres/tests/incremental.rs b/crates/ra_hir_def/src/nameres/tests/incremental.rs
new file mode 100644
index 000000000..80dcec62f
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests/incremental.rs
@@ -0,0 +1,133 @@
+use std::sync::Arc;
+
+use ra_db::{SourceDatabase, SourceDatabaseExt};
+
+use super::*;
+
+fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
+    let (mut db, pos) = TestDB::with_position(initial);
+    let krate = db.crate_graph().iter().next().unwrap();
+    {
+        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;
+        ",
+    );
+}
+
+#[test]
+fn typing_inside_a_macro_should_not_invalidate_def_map() {
+    let (mut db, pos) = TestDB::with_position(
+        "
+        //- /lib.rs
+        macro_rules! m {
+            ($ident:ident) => {
+                fn f() {
+                    $ident + $ident;
+                };
+            }
+        }
+        mod foo;
+
+        //- /foo/mod.rs
+        pub mod bar;
+
+        //- /foo/bar.rs
+        <|>
+        m!(X);
+        ",
+    );
+    let krate = db.crate_graph().iter().next().unwrap();
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.items.len(), 1);
+        });
+        assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+    db.set_file_text(pos.file_id, Arc::new("m!(Y);".to_string()));
+
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.items.len(), 1);
+        });
+        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
new file mode 100644
index 000000000..704065633
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -0,0 +1,602 @@
+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!(map, @r###"
+   ⋮crate
+   ⋮Foo: t v
+   ⋮nested: t
+   ⋮
+   ⋮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);
+
+        mod m {
+            m!(n3)
+        }
+
+        //- /n1.rs
+        m!(n2)
+        //- /n1/n2.rs
+        struct X;
+        //- /m/n3.rs
+        struct Y;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+    crate
+    m: t
+    n1: t
+    
+    crate::m
+    n3: t
+    
+    crate::m::n3
+    Y: t v
+    
+    crate::n1
+    n2: t
+    
+    crate::n1::n2
+    X: t v
+    "###);
+}
+
+#[test]
+fn macro_rules_from_other_crates_are_visible() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        foo::structs!(Foo, Bar)
+        mod bar;
+
+        //- /bar.rs
+        use crate::*;
+
+        //- /lib.rs crate:foo
+        #[macro_export]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+    "###);
+}
+
+#[test]
+fn macro_rules_export_with_local_inner_macros_are_visible() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        foo::structs!(Foo, Bar)
+        mod bar;
+
+        //- /bar.rs
+        use crate::*;
+
+        //- /lib.rs crate:foo
+        #[macro_export(local_inner_macros)]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+    "###);
+}
+
+#[test]
+fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        macro_rules! baz {
+            () => {
+                use foo::bar;
+            }
+        }
+
+        foo!();
+        bar!();
+        baz!();
+
+        //- /lib.rs crate:foo
+        #[macro_export]
+        macro_rules! foo {
+            () => {
+                struct Foo { field: u32 }
+            }
+        }
+        #[macro_export]
+        macro_rules! bar {
+            () => {
+                use foo::foo;
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Foo: t v
+   ⋮bar: m
+   ⋮foo: m
+    "###);
+}
+
+#[test]
+fn macro_rules_from_other_crates_are_visible_with_macro_use() {
+    covers!(macro_rules_from_other_crates_are_visible_with_macro_use);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        structs!(Foo);
+        structs_priv!(Bar);
+        structs_not_exported!(MacroNotResolved1);
+        crate::structs!(MacroNotResolved2);
+
+        mod bar;
+
+        #[macro_use]
+        extern crate foo;
+
+        //- /bar.rs
+        structs!(Baz);
+        crate::structs!(MacroNotResolved3);
+
+        //- /lib.rs crate:foo
+        #[macro_export]
+        macro_rules! structs {
+            ($i:ident) => { struct $i; }
+        }
+
+        macro_rules! structs_not_exported {
+            ($i:ident) => { struct $i; }
+        }
+
+        mod priv_mod {
+            #[macro_export]
+            macro_rules! structs_priv {
+                ($i:ident) => { struct $i; }
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮bar: t
+   ⋮foo: t
+   ⋮
+   ⋮crate::bar
+   ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn prelude_is_macro_use() {
+    covers!(prelude_is_macro_use);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        structs!(Foo);
+        structs_priv!(Bar);
+        structs_outside!(Out);
+        crate::structs!(MacroNotResolved2);
+
+        mod bar;
+
+        //- /bar.rs
+        structs!(Baz);
+        crate::structs!(MacroNotResolved3);
+
+        //- /lib.rs crate:foo
+        #[prelude_import]
+        use self::prelude::*;
+
+        mod prelude {
+            #[macro_export]
+            macro_rules! structs {
+                ($i:ident) => { struct $i; }
+            }
+
+            mod priv_mod {
+                #[macro_export]
+                macro_rules! structs_priv {
+                    ($i:ident) => { struct $i; }
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! structs_outside {
+            ($i:ident) => { struct $i; }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Bar: t v
+   ⋮Foo: t v
+   ⋮Out: t v
+   ⋮bar: t
+   ⋮
+   ⋮crate::bar
+   ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn prelude_cycle() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        #[prelude_import]
+        use self::prelude::*;
+
+        declare_mod!();
+
+        mod prelude {
+            macro_rules! declare_mod {
+                () => (mod foo {})
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮prelude: t
+        ⋮
+        ⋮crate::prelude
+    "###);
+}
+
+#[test]
+fn plain_macros_are_legacy_textual_scoped() {
+    let map = def_map(
+        r#"
+        //- /main.rs
+        mod m1;
+        bar!(NotFoundNotMacroUse);
+
+        mod m2 {
+            foo!(NotFoundBeforeInside2);
+        }
+
+        macro_rules! foo {
+            ($x:ident) => { struct $x; }
+        }
+        foo!(Ok);
+
+        mod m3;
+        foo!(OkShadowStop);
+        bar!(NotFoundMacroUseStop);
+
+        #[macro_use]
+        mod m5 {
+            #[macro_use]
+            mod m6 {
+                macro_rules! foo {
+                    ($x:ident) => { fn $x() {} }
+                }
+            }
+        }
+        foo!(ok_double_macro_use_shadow);
+
+        baz!(NotFoundBefore);
+        #[macro_use]
+        mod m7 {
+            macro_rules! baz {
+                ($x:ident) => { struct $x; }
+            }
+        }
+        baz!(OkAfter);
+
+        //- /m1.rs
+        foo!(NotFoundBeforeInside1);
+        macro_rules! bar {
+            ($x:ident) => { struct $x; }
+        }
+
+        //- /m3/mod.rs
+        foo!(OkAfterInside);
+        macro_rules! foo {
+            ($x:ident) => { fn $x() {} }
+        }
+        foo!(ok_shadow);
+
+        #[macro_use]
+        mod m4;
+        bar!(OkMacroUse);
+
+        //- /m3/m4.rs
+        foo!(ok_shadow_deep);
+        macro_rules! bar {
+            ($x:ident) => { struct $x; }
+        }
+        "#,
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮Ok: t v
+   ⋮OkAfter: t v
+   ⋮OkShadowStop: t v
+   ⋮m1: t
+   ⋮m2: t
+   ⋮m3: t
+   ⋮m5: t
+   ⋮m7: t
+   ⋮ok_double_macro_use_shadow: v
+   ⋮
+   ⋮crate::m7
+   ⋮
+   ⋮crate::m1
+   ⋮
+   ⋮crate::m5
+   ⋮m6: t
+   ⋮
+   ⋮crate::m5::m6
+   ⋮
+   ⋮crate::m2
+   ⋮
+   ⋮crate::m3
+   ⋮OkAfterInside: t v
+   ⋮OkMacroUse: t v
+   ⋮m4: t
+   ⋮ok_shadow: v
+   ⋮
+   ⋮crate::m3::m4
+   ⋮ok_shadow_deep: v
+    "###);
+}
+
+#[test]
+fn type_value_macro_live_in_different_scopes() {
+    let map = def_map(
+        "
+        //- /main.rs
+        #[macro_export]
+        macro_rules! foo {
+            ($x:ident) => { type $x = (); }
+        }
+
+        foo!(foo);
+        use foo as bar;
+
+        use self::foo as baz;
+        fn baz() {}
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮bar: t m
+        ⋮baz: t v m
+        ⋮foo: t m
+    "###);
+}
+
+#[test]
+fn macro_use_can_be_aliased() {
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        #[macro_use]
+        extern crate foo;
+
+        foo!(Direct);
+        bar!(Alias);
+
+        //- /lib.rs crate:foo
+        use crate::foo as bar;
+
+        mod m {
+            #[macro_export]
+            macro_rules! foo {
+                ($x:ident) => { struct $x; }
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Alias: t v
+        ⋮Direct: t v
+        ⋮foo: t
+    "###);
+}
+
+#[test]
+fn path_qualified_macros() {
+    let map = def_map(
+        "
+        //- /main.rs
+        macro_rules! foo {
+            ($x:ident) => { struct $x; }
+        }
+
+        crate::foo!(NotResolved);
+
+        crate::bar!(OkCrate);
+        bar!(OkPlain);
+        alias1!(NotHere);
+        m::alias1!(OkAliasPlain);
+        m::alias2!(OkAliasSuper);
+        m::alias3!(OkAliasCrate);
+        not_found!(NotFound);
+
+        mod m {
+            #[macro_export]
+            macro_rules! bar {
+                ($x:ident) => { struct $x; }
+            }
+
+            pub use bar as alias1;
+            pub use super::bar as alias2;
+            pub use crate::bar as alias3;
+            pub use self::bar as not_found;
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮OkAliasCrate: t v
+        ⋮OkAliasPlain: t v
+        ⋮OkAliasSuper: t v
+        ⋮OkCrate: t v
+        ⋮OkPlain: t v
+        ⋮bar: m
+        ⋮m: t
+        ⋮
+        ⋮crate::m
+        ⋮alias1: m
+        ⋮alias2: m
+        ⋮alias3: m
+        ⋮not_found: _
+    "###);
+}
+
+#[test]
+fn macro_dollar_crate_is_correct_in_item() {
+    covers!(macro_dollar_crate_self);
+    covers!(macro_dollar_crate_other);
+    let map = def_map(
+        "
+        //- /main.rs crate:main deps:foo
+        #[macro_use]
+        extern crate foo;
+
+        #[macro_use]
+        mod m {
+            macro_rules! current {
+                () => {
+                    use $crate::Foo as FooSelf;
+                }
+            }
+        }
+
+        struct Foo;
+
+        current!();
+        not_current1!();
+        foo::not_current2!();
+
+        //- /lib.rs crate:foo
+        mod m {
+            #[macro_export]
+            macro_rules! not_current1 {
+                () => {
+                    use $crate::Bar;
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! not_current2 {
+            () => {
+                use $crate::Baz;
+            }
+        }
+
+        struct Bar;
+        struct Baz;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: t v
+        ⋮Foo: t v
+        ⋮FooSelf: t v
+        ⋮foo: t
+        ⋮m: t
+        ⋮
+        ⋮crate::m
+    "###);
+}
+
+#[test]
+fn macro_dollar_crate_is_correct_in_indirect_deps() {
+    covers!(macro_dollar_crate_other);
+    // From std
+    let map = def_map(
+        r#"
+        //- /main.rs crate:main deps:std
+        foo!();
+
+        //- /std.rs crate:std deps:core
+        #[prelude_import]
+        use self::prelude::*;
+
+        pub use core::foo;
+
+        mod prelude {}
+
+        #[macro_use]
+        mod std_macros;
+
+        //- /core.rs crate:core
+        #[macro_export]
+        macro_rules! foo {
+            () => {
+                use $crate::bar;
+            }
+        }
+
+        pub struct bar;
+        "#,
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮bar: t v
+    "###);
+}
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
new file mode 100644
index 000000000..dee364a14
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -0,0 +1,782 @@
+use super::*;
+
+#[test]
+fn name_res_works_for_broken_modules() {
+    covers!(name_res_works_for_broken_modules);
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo // no `;`, no body
+
+        use self::foo::Baz;
+
+        //- /foo/mod.rs
+        pub mod bar;
+
+        pub use self::bar::Baz;
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: _
+    "###);
+}
+
+#[test]
+fn nested_module_resolution() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod n1;
+
+        //- /n1.rs
+        mod n2;
+
+        //- /n1/n2.rs
+        struct X;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮n1: t
+        ⋮
+        ⋮crate::n1
+        ⋮n2: t
+        ⋮
+        ⋮crate::n1::n2
+        ⋮X: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_works_for_non_standard_filenames() {
+    let map = def_map(
+        "
+        //- /my_library.rs crate:my_library
+        mod foo;
+        use self::foo::Bar;
+
+        //- /foo/mod.rs
+        pub struct Bar;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Bar: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_works_for_raw_modules() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod r#async;
+        use self::r#async::Bar;
+
+        //- /async.rs
+        pub struct Bar;
+        ",
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮async: t
+        ⋮
+        ⋮crate::async
+        ⋮Bar: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_path() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        #[path = "bar/baz/foo.rs"]
+        mod foo;
+        use self::foo::Bar;
+
+        //- /bar/baz/foo.rs
+        pub struct Bar;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Bar: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_module_with_path_in_mod_rs() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo/mod.rs
+        #[path = "baz.rs"]
+        pub mod bar;
+
+        use self::bar::Baz;
+
+        //- /foo/baz.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_module_with_path_non_crate_root() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo.rs
+        #[path = "baz.rs"]
+        pub mod bar;
+
+        use self::bar::Baz;
+
+        //- /baz.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_module_decl_path_super() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "bar/baz/module.rs"]
+        mod foo;
+        pub struct Baz;
+
+        //- /bar/baz/module.rs
+        use super::Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_explicit_path_mod_rs() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "module/mod.rs"]
+        mod foo;
+
+        //- /module/mod.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_relative_path() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo.rs
+        #[path = "./sub.rs"]
+        pub mod foo_bar;
+
+        //- /sub.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮foo_bar: t
+        ⋮
+        ⋮crate::foo::foo_bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_relative_path_2() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo/mod.rs
+        #[path="../sub.rs"]
+        pub mod foo_bar;
+
+        //- /sub.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮foo_bar: t
+        ⋮
+        ⋮crate::foo::foo_bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_explicit_path_mod_rs_2() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "module/bar/mod.rs"]
+        mod foo;
+
+        //- /module/bar/mod.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_explicit_path_mod_rs_with_win_separator() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "module\bar\mod.rs"]
+        mod foo;
+
+        //- /module/bar/mod.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_with_path_attribute() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "models"]
+        mod foo {
+            mod bar;
+        }
+
+        //- /models/bar.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo {
+            mod bar;
+        }
+
+        //- /foo/bar.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "models/db"]
+        mod foo {
+            mod bar;
+        }
+
+        //- /models/db/bar.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_3() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "models/db"]
+        mod foo {
+            #[path = "users.rs"]
+            mod bar;
+        }
+
+        //- /models/db/users.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_empty_path() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = ""]
+        mod foo {
+            #[path = "users.rs"]
+            mod bar;
+        }
+
+        //- /users.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_empty_path() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = ""] // Should try to read `/` (a directory)
+        mod foo;
+
+        //- /foo.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_relative_path() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path = "./models"]
+        mod foo {
+            mod bar;
+        }
+
+        //- /models/bar.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_in_crate_root() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo {
+            #[path = "baz.rs"]
+            mod bar;
+        }
+        use self::foo::bar::Baz;
+
+        //- /foo/baz.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Baz: t v
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_in_mod_rs() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo/mod.rs
+        mod bar {
+            #[path = "qwe.rs"]
+            pub mod baz;
+        }
+        use self::bar::baz::Baz;
+
+        //- /foo/bar/qwe.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮baz: t
+        ⋮
+        ⋮crate::foo::bar::baz
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo.rs
+        mod bar {
+            #[path = "qwe.rs"]
+            pub mod baz;
+        }
+        use self::bar::baz::Baz;
+
+        //- /foo/bar/qwe.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮baz: t
+        ⋮
+        ⋮crate::foo::bar::baz
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        mod foo;
+
+        //- /foo.rs
+        #[path = "bar"]
+        mod bar {
+            pub mod baz;
+        }
+        use self::bar::baz::Baz;
+
+        //- /bar/baz.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮foo: t
+        ⋮
+        ⋮crate::foo
+        ⋮Baz: t v
+        ⋮bar: t
+        ⋮
+        ⋮crate::foo::bar
+        ⋮baz: t
+        ⋮
+        ⋮crate::foo::bar::baz
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn unresolved_module_diagnostics() {
+    let db = TestDB::with_files(
+        r"
+        //- /lib.rs
+        mod foo;
+        mod bar;
+        mod baz {}
+        //- /foo.rs
+        ",
+    );
+    let krate = db.crate_graph().iter().next().unwrap();
+
+    let crate_def_map = db.crate_def_map(krate);
+
+    insta::assert_debug_snapshot!(
+        crate_def_map.diagnostics,
+        @r###"
+    [
+        UnresolvedModule {
+            module: CrateModuleId(
+                0,
+            ),
+            declaration: AstId {
+                file_id: HirFileId(
+                    FileId(
+                        FileId(
+                            0,
+                        ),
+                    ),
+                ),
+                file_ast_id: FileAstId {
+                    raw: ErasedFileAstId(
+                        1,
+                    ),
+                    _ty: PhantomData,
+                },
+            },
+            candidate: "bar.rs",
+        },
+    ]
+    "###
+    );
+}
+
+#[test]
+fn module_resolution_decl_inside_module_in_non_crate_root_2() {
+    let map = def_map(
+        r###"
+        //- /main.rs
+        #[path="module/m2.rs"]
+        mod module;
+
+        //- /module/m2.rs
+        pub mod submod;
+
+        //- /module/submod.rs
+        pub struct Baz;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮module: t
+        ⋮
+        ⋮crate::module
+        ⋮submod: t
+        ⋮
+        ⋮crate::module::submod
+        ⋮Baz: t v
+    "###);
+}
+
+#[test]
+fn nested_out_of_line_module() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod a {
+            mod b {
+                mod c;
+            }
+        }
+
+        //- /a/b/c.rs
+        struct X;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+    crate
+    a: t
+    
+    crate::a
+    b: t
+    
+    crate::a::b
+    c: t
+    
+    crate::a::b::c
+    X: t v
+    "###);
+}
+
+#[test]
+fn nested_out_of_line_module_with_path() {
+    let map = def_map(
+        r###"
+        //- /lib.rs
+        mod a {
+            #[path = "d/e"]
+            mod b {
+                mod c;
+            }
+        }
+
+        //- /a/d/e/c.rs
+        struct X;
+        "###,
+    );
+
+    assert_snapshot!(map, @r###"
+    crate
+    a: t
+    
+    crate::a
+    b: t
+    
+    crate::a::b
+    c: t
+    
+    crate::a::b::c
+    X: t v
+    "###);
+}
diff --git a/crates/ra_hir_def/src/nameres/tests/primitives.rs b/crates/ra_hir_def/src/nameres/tests/primitives.rs
new file mode 100644
index 000000000..0e2708658
--- /dev/null
+++ b/crates/ra_hir_def/src/nameres/tests/primitives.rs
@@ -0,0 +1,24 @@
+use super::*;
+
+#[test]
+fn primitive_reexport() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::int;
+
+        //- /foo.rs
+        pub use i32 as int;
+        ",
+    );
+    assert_snapshot!(map, @r###"
+   ⋮crate
+   ⋮foo: t
+   ⋮int: t
+   ⋮
+   ⋮crate::foo
+   ⋮int: t
+    "###
+    );
+}
diff --git a/crates/ra_hir_def/src/test_db.rs b/crates/ra_hir_def/src/test_db.rs
new file mode 100644
index 000000000..8ee8e40d0
--- /dev/null
+++ b/crates/ra_hir_def/src/test_db.rs
@@ -0,0 +1,75 @@
+//! Database used for testing `hir_def`.
+
+use std::{
+    panic,
+    sync::{Arc, Mutex},
+};
+
+use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+
+#[salsa::database(
+    ra_db::SourceDatabaseExtStorage,
+    ra_db::SourceDatabaseStorage,
+    hir_expand::db::AstDatabaseStorage,
+    crate::db::InternDatabaseStorage,
+    crate::db::DefDatabase2Storage
+)]
+#[derive(Debug, Default)]
+pub struct TestDB {
+    runtime: salsa::Runtime<TestDB>,
+    events: Mutex<Option<Vec<salsa::Event<TestDB>>>>,
+}
+
+impl salsa::Database for TestDB {
+    fn salsa_runtime(&self) -> &salsa::Runtime<Self> {
+        &self.runtime
+    }
+
+    fn salsa_event(&self, event: impl Fn() -> salsa::Event<TestDB>) {
+        let mut events = self.events.lock().unwrap();
+        if let Some(events) = &mut *events {
+            events.push(event());
+        }
+    }
+}
+
+impl panic::RefUnwindSafe for TestDB {}
+
+impl FileLoader for TestDB {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        FileLoaderDelegate(self).file_text(file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        FileLoaderDelegate(self).relevant_crates(file_id)
+    }
+}
+
+impl TestDB {
+    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<TestDB>> {
+        *self.events.lock().unwrap() = Some(Vec::new());
+        f();
+        self.events.lock().unwrap().take().unwrap()
+    }
+
+    pub fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+        let events = self.log(f);
+        events
+            .into_iter()
+            .filter_map(|e| match e.kind {
+                // This pretty horrible, but `Debug` is the only way to inspect
+                // QueryDescriptor at the moment.
+                salsa::EventKind::WillExecute { database_key } => {
+                    Some(format!("{:?}", database_key))
+                }
+                _ => None,
+            })
+            .collect()
+    }
+}