64 files changed, 3458 insertions, 2342 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 0314735da..6f4c4f767 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -62,7 +62,7 @@ name = "backtrace-sys"
 version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -118,7 +118,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "cargo_metadata"
-version = "0.7.1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "error-chain 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -130,7 +130,7 @@ dependencies = [
 [[package]]
 name = "cc"
-version = "1.0.30"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
@@ -265,7 +265,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -338,7 +338,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -563,7 +563,7 @@ name = "jemalloc-sys"
 version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)",
 "fs_extra 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.50 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -755,7 +755,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -847,7 +847,7 @@ dependencies = [
 "pest_meta 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -1083,7 +1083,7 @@ dependencies = [
 name = "ra_project_model"
 version = "0.1.0"
 dependencies = [
- "cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cargo_metadata 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_arena 0.1.0",
@@ -1395,7 +1395,7 @@ dependencies = [
 "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -1440,7 +1440,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 [[package]]
@@ -1523,7 +1523,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "syn"
-version = "0.15.27"
+version = "0.15.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1538,7 +1538,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1905,8 +1905,8 @@ dependencies = [
 "checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
 "checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
 "checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
-"checksum cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "585784cac9b05c93a53b17a0b24a5cdd1dfdda5256f030e089b549d2390cc720"
+"checksum cargo_metadata 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "bc796c7161c220089dfc7159e13324979181532850a237576b8fb907dd087c0d"
-"checksum cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "d01c69d08ff207f231f07196e30f84c70f1c815b04f980f8b7b01ff01f05eb92"
+"checksum cc 1.0.31 (registry+https://github.com/rust-lang/crates.io-index)" = "c9ce8bb087aacff865633f0bd5aeaed910fe2fe55b55f4739527f2e023a2e53d"
 "checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"
 "checksum chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
 "checksum ci_info 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e5e881307a989a3a5e20d52a32cc05950e3c2178cccfcc9428271a6cde09f902"
@@ -2042,7 +2042,7 @@ dependencies = [
 "checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
 "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
 "checksum superslice 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
-"checksum syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
+"checksum syn 0.15.29 (registry+https://github.com/rust-lang/crates.io-index)" = "1825685f977249735d510a242a6727b46efe914bb67e38d30c071b1b72b1d5c2"
 "checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
 "checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"
 "checksum tera 0.11.20 (registry+https://github.com/rust-lang/crates.io-index)" = "4b505279e19d8f7d24b1a9dc58327c9c36174b1a2c7ebdeac70792d017cb64f3"
diff --git a/README.md b/README.md
index 15da30f2d..5bc90a3f0 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,10 @@
 Rust Analyzer is an **experimental** modular compiler frontend for the Rust
 language. It is a part of a larger rls-2.0 effort to create excellent IDE
-support for Rust. If you want to get involved, check rls-2.0 working group repository:
+support for Rust. If you want to get involved, check the rls-2.0 working group
+in the compiler-team repository:
-https://github.com/rust-analyzer/WG-rls2.0
+https://github.com/rust-lang/compiler-team/tree/master/working-groups/rls-2.0
 Work on the Rust Analyzer is sponsored by
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
new file mode 100644
index 000000000..4435c4b5d
--- /dev/null
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -0,0 +1,283 @@
+use crate::{Assist, AssistId, AssistCtx};
+use hir::Resolver;
+use hir::db::HirDatabase;
+use ra_syntax::{SmolStr, SyntaxKind, TextRange, TextUnit, TreeArc};
+use ra_syntax::ast::{self, AstNode, FnDef, ImplItem, ImplItemKind, NameOwner};
+use ra_db::FilePosition;
+use ra_fmt::{leading_indent, reindent};
+use itertools::Itertools;
+pub(crate) fn add_missing_impl_members(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let impl_node = ctx.node_at_offset::<ast::ImplBlock>()?;
+    let impl_item_list = impl_node.item_list()?;
+    let trait_def = {
+        let file_id = ctx.frange.file_id;
+        let position = FilePosition { file_id, offset: impl_node.syntax().range().start() };
+        let resolver = hir::source_binder::resolver_for_position(ctx.db, position);
+        resolve_target_trait_def(ctx.db, &resolver, impl_node)?
+    };
+    let missing_fns: Vec<_> = {
+        let fn_def_opt = |kind| if let ImplItemKind::FnDef(def) = kind { Some(def) } else { None };
+        let def_name = |def| -> Option<&SmolStr> { FnDef::name(def).map(ast::Name::text) };
+        let trait_items =
+            trait_def.syntax().descendants().find_map(ast::ItemList::cast)?.impl_items();
+        let impl_items = impl_item_list.impl_items();
+        let trait_fns = trait_items.map(ImplItem::kind).filter_map(fn_def_opt).collect::<Vec<_>>();
+        let impl_fns = impl_items.map(ImplItem::kind).filter_map(fn_def_opt).collect::<Vec<_>>();
+        trait_fns
+            .into_iter()
+            .filter(|t| def_name(t).is_some())
+            .filter(|t| impl_fns.iter().all(|i| def_name(i) != def_name(t)))
+            .collect()
+    };
+    if missing_fns.is_empty() {
+        return None;
+    }
+    ctx.add_action(AssistId("add_impl_missing_members"), "add missing impl members", |edit| {
+        let (parent_indent, indent) = {
+            // FIXME: Find a way to get the indent already used in the file.
+            // Now, we copy the indent of first item or indent with 4 spaces relative to impl block
+            const DEFAULT_INDENT: &str = "    ";
+            let first_item = impl_item_list.impl_items().next();
+            let first_item_indent =
+                first_item.and_then(|i| leading_indent(i.syntax())).map(ToOwned::to_owned);
+            let impl_block_indent = leading_indent(impl_node.syntax()).unwrap_or_default();
+            (
+                impl_block_indent.to_owned(),
+                first_item_indent.unwrap_or_else(|| impl_block_indent.to_owned() + DEFAULT_INDENT),
+            )
+        };
+        let changed_range = {
+            let children = impl_item_list.syntax().children();
+            let last_whitespace = children.filter_map(ast::Whitespace::cast).last();
+            last_whitespace.map(|w| w.syntax().range()).unwrap_or_else(|| {
+                let in_brackets = impl_item_list.syntax().range().end() - TextUnit::of_str("}");
+                TextRange::from_to(in_brackets, in_brackets)
+            })
+        };
+        let func_bodies = format!("\n{}", missing_fns.into_iter().map(build_func_body).join("\n"));
+        let trailing_whitespace = format!("\n{}", parent_indent);
+        let func_bodies = reindent(&func_bodies, &indent) + &trailing_whitespace;
+        let replaced_text_range = TextUnit::of_str(&func_bodies);
+        edit.replace(changed_range, func_bodies);
+        edit.set_cursor(
+            changed_range.start() + replaced_text_range - TextUnit::of_str(&trailing_whitespace),
+        );
+    });
+    ctx.build()
+}
+/// Given an `ast::ImplBlock`, resolves the target trait (the one being
+/// implemented) to a `ast::TraitDef`.
+fn resolve_target_trait_def(
+    db: &impl HirDatabase,
+    resolver: &Resolver,
+    impl_block: &ast::ImplBlock,
+) -> Option<TreeArc<ast::TraitDef>> {
+    let ast_path = impl_block.target_trait().map(AstNode::syntax).and_then(ast::PathType::cast)?;
+    let hir_path = ast_path.path().and_then(hir::Path::from_ast)?;
+    match resolver.resolve_path(db, &hir_path).take_types() {
+        Some(hir::Resolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).1),
+        _ => None,
+    }
+}
+fn build_func_body(def: &ast::FnDef) -> String {
+    let mut buf = String::new();
+    for child in def.syntax().children() {
+        if child.kind() == SyntaxKind::SEMI {
+            buf.push_str(" { unimplemented!() }")
+        } else {
+            child.text().push_to(&mut buf);
+        }
+    }
+    buf.trim_end().to_string()
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+    #[test]
+    fn test_add_missing_impl_members() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo {
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
+struct S;
+impl Foo for S {
+    fn bar(&self) {}
+    <|>
+}",
+            "
+trait Foo {
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
+struct S;
+impl Foo for S {
+    fn bar(&self) {}
+    fn foo(&self) { unimplemented!() }
+    fn baz(&self) { unimplemented!() }<|>
+}",
+        );
+    }
+    #[test]
+    fn test_copied_overriden_members() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo {
+    fn foo(&self);
+    fn bar(&self) -> bool { true }
+    fn baz(&self) -> u32 { 42 }
+}
+struct S;
+impl Foo for S {
+    fn bar(&self) {}
+    <|>
+}",
+            "
+trait Foo {
+    fn foo(&self);
+    fn bar(&self) -> bool { true }
+    fn baz(&self) -> u32 { 42 }
+}
+struct S;
+impl Foo for S {
+    fn bar(&self) {}
+    fn foo(&self) { unimplemented!() }
+    fn baz(&self) -> u32 { 42 }<|>
+}",
+        );
+    }
+    #[test]
+    fn test_empty_impl_block() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {<|>}",
+            "
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) { unimplemented!() }<|>
+}",
+        );
+    }
+    #[test]
+    fn test_cursor_after_empty_impl_block() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {}<|>",
+            "
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) { unimplemented!() }<|>
+}",
+        )
+    }
+    #[test]
+    fn test_empty_trait() {
+        check_assist_not_applicable(
+            add_missing_impl_members,
+            "
+trait Foo;
+struct S;
+impl Foo for S { <|> }",
+        )
+    }
+    #[test]
+    fn test_ignore_unnamed_trait_members() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo {
+    fn (arg: u32);
+    fn valid(some: u32) -> bool { false }
+}
+struct S;
+impl Foo for S { <|> }",
+            "
+trait Foo {
+    fn (arg: u32);
+    fn valid(some: u32) -> bool { false }
+}
+struct S;
+impl Foo for S {
+    fn valid(some: u32) -> bool { false }<|>
+}",
+        )
+    }
+    #[test]
+    fn test_indented_impl_block() {
+        check_assist(
+            add_missing_impl_members,
+            "
+trait Foo {
+    fn valid(some: u32) -> bool { false }
+}
+struct S;
+mod my_mod {
+    impl crate::Foo for S { <|> }
+}",
+            "
+trait Foo {
+    fn valid(some: u32) -> bool { false }
+}
+struct S;
+mod my_mod {
+    impl crate::Foo for S {
+        fn valid(some: u32) -> bool { false }<|>
+    }
+}",
+        )
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 6c3d75d79..0c4abb450 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -95,6 +95,7 @@ mod replace_if_let_with_match;
 mod split_import;
 mod remove_dbg;
 mod auto_import;
+mod add_missing_impl_members;
 fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
    &[
@@ -108,6 +109,7 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
        split_import::split_import,
        remove_dbg::remove_dbg,
        auto_import::auto_import,
+        add_missing_impl_members::add_missing_impl_members,
    ]
 }
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index e45a510b3..2b1001d48 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -124,6 +124,10 @@ impl CrateGraph {
        self.arena.is_empty()
    }
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item = CrateId> + 'a {
+        self.arena.keys().map(|it| *it)
+    }
    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
        self.arena[&crate_id].file_id
    }
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index dd7eeebd0..b00481cd5 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -8,13 +8,12 @@ use crate::{
    Name, ScopesWithSourceMap, Ty, HirFileId,
    HirDatabase, PersistentHirDatabase,
    type_ref::TypeRef,
-    nameres::{ModuleScope, Namespace, lower::ImportId},
+    nameres::{ModuleScope, Namespace, ImportId, CrateModuleId},
    expr::{Body, BodySourceMap},
    ty::InferenceResult,
    adt::{EnumVariantId, StructFieldId, VariantDef},
    generics::GenericParams,
    docs::{Documentation, Docs, docs_from_ast},
-    module_tree::ModuleId,
    ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
    impl_block::ImplBlock,
    resolve::Resolver,
@@ -65,11 +64,11 @@ impl Crate {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
    pub(crate) krate: Crate,
-    pub(crate) module_id: ModuleId,
+    pub(crate) module_id: CrateModuleId,
 }
 /// The defs which can be visible in the module.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ModuleDef {
    Module(Module),
    Function(Function),
@@ -173,7 +172,7 @@ impl Module {
    /// Returns a `ModuleScope`: a set of items, visible in this module.
    pub fn scope(&self, db: &impl HirDatabase) -> ModuleScope {
-        db.item_map(self.krate)[self.module_id].clone()
+        db.crate_def_map(self.krate)[self.module_id].scope.clone()
    }
    pub fn problems(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
@@ -181,16 +180,16 @@ impl Module {
    }
    pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
-        let item_map = db.item_map(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        Resolver::default().push_module_scope(item_map, *self)
+        Resolver::default().push_module_scope(def_map, self.module_id)
    }
    pub fn declarations(self, db: &impl HirDatabase) -> Vec<ModuleDef> {
-        let lowered_module = db.lower_module(self);
+        let def_map = db.crate_def_map(self.krate);
-        lowered_module
+        def_map[self.module_id]
-            .declarations
+            .scope
-            .values()
+            .entries()
-            .cloned()
+            .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None })
            .flat_map(|per_ns| {
                per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter())
            })
diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs
index 161ae6e18..cc87c6f14 100644
--- a/crates/ra_hir/src/code_model_impl/krate.rs
+++ b/crates/ra_hir/src/code_model_impl/krate.rs
@@ -18,9 +18,7 @@ impl Crate {
            .collect()
    }
    pub(crate) fn root_module_impl(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
-        let module_tree = db.module_tree(*self);
+        let module_id = db.crate_def_map(*self).root();
-        let module_id = module_tree.modules().next()?;
        let module = Module { krate: *self, module_id };
        Some(module)
    }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index 437f96942..f7d15c55e 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -1,33 +1,61 @@
-use ra_syntax::{ast, SyntaxNode, TreeArc};
+use ra_db::FileId;
+use ra_syntax::{ast, SyntaxNode, TreeArc, AstNode};
 use crate::{
-    Module, ModuleSource, Problem,
+    Module, ModuleSource, Problem, Name,
-    Name,
+    nameres::{CrateModuleId, ImportId},
-    module_tree::ModuleId,
-    nameres::lower::ImportId,
    HirDatabase, PersistentHirDatabase,
-    HirFileId
+    HirFileId, SourceItemId,
 };
+impl ModuleSource {
+    pub(crate) fn new(
+        db: &impl PersistentHirDatabase,
+        file_id: Option<FileId>,
+        decl_id: Option<SourceItemId>,
+    ) -> ModuleSource {
+        match (file_id, decl_id) {
+            (Some(file_id), _) => {
+                let source_file = db.parse(file_id);
+                ModuleSource::SourceFile(source_file)
+            }
+            (None, Some(item_id)) => {
+                let module = db.file_item(item_id);
+                let module = ast::Module::cast(&*module).unwrap();
+                assert!(module.item_list().is_some(), "expected inline module");
+                ModuleSource::Module(module.to_owned())
+            }
+            (None, None) => panic!(),
+        }
+    }
+}
 impl Module {
-    fn with_module_id(&self, module_id: ModuleId) -> Module {
+    fn with_module_id(&self, module_id: CrateModuleId) -> Module {
        Module { module_id, krate: self.krate }
    }
    pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Option<Name> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let link = self.module_id.parent_link(&module_tree)?;
+        let parent = def_map[self.module_id].parent?;
-        Some(link.name(&module_tree).clone())
+        def_map[parent].children.iter().find_map(|(name, module_id)| {
+            if *module_id == self.module_id {
+                Some(name.clone())
+            } else {
+                None
+            }
+        })
    }
    pub(crate) fn definition_source_impl(
        &self,
        db: &impl PersistentHirDatabase,
    ) -> (HirFileId, ModuleSource) {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let file_id = self.module_id.file_id(&module_tree);
+        let decl_id = def_map[self.module_id].declaration;
-        let decl_id = self.module_id.decl_id(&module_tree);
+        let file_id = def_map[self.module_id].definition;
        let module_source = ModuleSource::new(db, file_id, decl_id);
+        let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id);
        (file_id, module_source)
    }
@@ -35,11 +63,11 @@ impl Module {
        &self,
        db: &impl HirDatabase,
    ) -> Option<(HirFileId, TreeArc<ast::Module>)> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let link = self.module_id.parent_link(&module_tree)?;
+        let decl = def_map[self.module_id].declaration?;
-        let file_id = link.owner(&module_tree).file_id(&module_tree);
+        let syntax_node = db.file_item(decl);
-        let src = link.source(&module_tree, db);
+        let ast = ast::Module::cast(&syntax_node).unwrap().to_owned();
-        Some((file_id, src))
+        Some((decl.file_id, ast))
    }
    pub(crate) fn import_source_impl(
@@ -47,22 +75,21 @@ impl Module {
        db: &impl HirDatabase,
        import: ImportId,
    ) -> TreeArc<ast::PathSegment> {
-        let (_, source_map) = db.lower_module_with_source_map(*self);
+        let (file_id, source) = self.definition_source(db);
-        let (_, source) = self.definition_source(db);
+        let (_, source_map) = db.raw_items_with_source_map(file_id.original_file(db));
        source_map.get(&source, import)
    }
    pub(crate) fn crate_root_impl(&self, db: &impl PersistentHirDatabase) -> Module {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let module_id = self.module_id.crate_root(&module_tree);
+        self.with_module_id(def_map.root())
-        self.with_module_id(module_id)
    }
    /// Finds a child module with the specified name.
    pub(crate) fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let child_id = self.module_id.child(&module_tree, name)?;
+        let child_id = def_map[self.module_id].children.get(name)?;
-        Some(self.with_module_id(child_id))
+        Some(self.with_module_id(*child_id))
    }
    /// Iterates over all child modules.
@@ -70,18 +97,18 @@ impl Module {
        &self,
        db: &impl PersistentHirDatabase,
    ) -> impl Iterator<Item = Module> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let children = self
+        let children = def_map[self.module_id]
-            .module_id
+            .children
-            .children(&module_tree)
+            .iter()
-            .map(|(_, module_id)| self.with_module_id(module_id))
+            .map(|(_, module_id)| self.with_module_id(*module_id))
            .collect::<Vec<_>>();
        children.into_iter()
    }
    pub(crate) fn parent_impl(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        let parent_id = self.module_id.parent(&module_tree)?;
+        let parent_id = def_map[self.module_id].parent?;
        Some(self.with_module_id(parent_id))
    }
@@ -89,7 +116,14 @@ impl Module {
        &self,
        db: &impl HirDatabase,
    ) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
-        let module_tree = db.module_tree(self.krate);
+        let def_map = db.crate_def_map(self.krate);
-        self.module_id.problems(&module_tree, db)
+        let (my_file_id, _) = self.definition_source(db);
+        // FIXME: not entirely corret filterint by module
+        def_map
+            .problems()
+            .iter()
+            .filter(|(source_item_id, _problem)| my_file_id == source_item_id.file_id)
+            .map(|(source_item_id, problem)| (db.file_item(*source_item_id), problem.clone()))
+            .collect()
    }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 21d22aa7f..c7bad7e2b 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,23 +1,18 @@
 use std::sync::Arc;
 use ra_syntax::{SyntaxNode, TreeArc, SourceFile};
-use ra_db::{SourceDatabase, salsa};
+use ra_db::{SourceDatabase, salsa, FileId};
 use crate::{
-    MacroCallId, HirFileId,
+    HirFileId, SourceFileItems, SourceItemId, Crate, Module, HirInterner,
-    SourceFileItems, SourceItemId, Crate, Module, HirInterner,
    Function, FnSignature, ExprScopes, TypeAlias,
    Struct, Enum, StructField,
    Const, ConstSignature, Static,
-    macros::MacroExpansion,
+    nameres::{Namespace, ImportSourceMap, RawItems, CrateDefMap},
-    module_tree::ModuleTree,
+    ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, CallableDef, FnSig},
-    nameres::{ItemMap, lower::{LoweredModule, ImportSourceMap}},
-    ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef},
    adt::{StructData, EnumData},
    impl_block::{ModuleImplBlocks, ImplSourceMap},
    generics::{GenericParams, GenericDef},
-    ids::SourceFileItemId,
-    nameres::Namespace,
    type_ref::TypeRef,
 };
@@ -26,9 +21,6 @@ pub trait PersistentHirDatabase: SourceDatabase + AsRef<HirInterner> {
    #[salsa::invoke(HirFileId::hir_parse)]
    fn hir_parse(&self, file_id: HirFileId) -> TreeArc<SourceFile>;
-    #[salsa::invoke(crate::macros::expand_macro_invocation)]
-    fn expand_macro_invocation(&self, invoc: MacroCallId) -> Option<Arc<MacroExpansion>>;
    #[salsa::invoke(crate::adt::StructData::struct_data_query)]
    fn struct_data(&self, s: Struct) -> Arc<StructData>;
@@ -41,27 +33,14 @@ pub trait PersistentHirDatabase: SourceDatabase + AsRef<HirInterner> {
    #[salsa::invoke(crate::ids::SourceFileItems::file_item_query)]
    fn file_item(&self, source_item_id: SourceItemId) -> TreeArc<SyntaxNode>;
-    #[salsa::invoke(crate::module_tree::Submodule::submodules_query)]
+    #[salsa::invoke(RawItems::raw_items_query)]
-    fn submodules(
+    fn raw_items(&self, file_id: FileId) -> Arc<RawItems>;
-        &self,
-        file_id: HirFileId,
-        delc_id: Option<SourceFileItemId>,
-    ) -> Arc<Vec<crate::module_tree::Submodule>>;
-    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_with_source_map_query)]
+    #[salsa::invoke(RawItems::raw_items_with_source_map_query)]
-    fn lower_module_with_source_map(
+    fn raw_items_with_source_map(&self, file_id: FileId) -> (Arc<RawItems>, Arc<ImportSourceMap>);
-        &self,
-        module: Module,
-    ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>);
-    #[salsa::invoke(crate::nameres::lower::LoweredModule::lower_module_query)]
+    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
-    fn lower_module(&self, module: Module) -> Arc<LoweredModule>;
+    fn crate_def_map(&self, krate: Crate) -> Arc<CrateDefMap>;
-    #[salsa::invoke(crate::nameres::ItemMap::item_map_query)]
-    fn item_map(&self, krate: Crate) -> Arc<ItemMap>;
-    #[salsa::invoke(crate::module_tree::ModuleTree::module_tree_query)]
-    fn module_tree(&self, krate: Crate) -> Arc<ModuleTree>;
    #[salsa::invoke(crate::impl_block::impls_in_module)]
    fn impls_in_module(&self, module: Module) -> Arc<ModuleImplBlocks>;
@@ -105,6 +84,9 @@ pub trait HirDatabase: PersistentHirDatabase {
    #[salsa::invoke(crate::ty::type_for_field)]
    fn type_for_field(&self, field: StructField) -> Ty;
+    #[salsa::invoke(crate::ty::callable_item_sig)]
+    fn callable_item_signature(&self, def: CallableDef) -> FnSig;
    #[salsa::invoke(crate::expr::body_with_source_map_query)]
    fn body_with_source_map(
        &self,
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 5b00330c6..9596488d3 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -83,30 +83,37 @@ impl HirFileId {
        }
    }
-    pub(crate) fn as_macro_call_id(self) -> Option<MacroCallId> {
-        match self.0 {
-            HirFileIdRepr::Macro(it) => Some(it),
-            _ => None,
-        }
-    }
    pub(crate) fn hir_parse(
        db: &impl PersistentHirDatabase,
        file_id: HirFileId,
    ) -> TreeArc<SourceFile> {
        match file_id.0 {
            HirFileIdRepr::File(file_id) => db.parse(file_id),
-            HirFileIdRepr::Macro(m) => {
+            HirFileIdRepr::Macro(macro_call_id) => {
-                if let Some(exp) = db.expand_macro_invocation(m) {
-                    return exp.file();
-                }
                // returning an empty string looks fishy...
-                SourceFile::parse("")
+                parse_macro(db, macro_call_id).unwrap_or_else(|| SourceFile::parse(""))
            }
        }
    }
 }
+fn parse_macro(
+    db: &impl PersistentHirDatabase,
+    macro_call_id: MacroCallId,
+) -> Option<TreeArc<SourceFile>> {
+    let loc = macro_call_id.loc(db);
+    let syntax = db.file_item(loc.source_item_id);
+    let macro_call = ast::MacroCall::cast(&syntax).unwrap();
+    let (macro_arg, _) = macro_call.token_tree().and_then(mbe::ast_to_token_tree)?;
+    let def_map = db.crate_def_map(loc.module.krate);
+    let (krate, macro_id) = def_map.resolve_macro(macro_call_id)?;
+    let def_map = db.crate_def_map(krate);
+    let macro_rules = &def_map[macro_id];
+    let tt = macro_rules.expand(&macro_arg).ok()?;
+    Some(mbe::token_tree_to_ast_item_list(&tt))
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum HirFileIdRepr {
    File(FileId),
@@ -200,8 +207,14 @@ pub(crate) trait AstItemDef<N: AstNode>: ArenaId + Clone {
    fn interner(interner: &HirInterner) -> &LocationIntener<ItemLoc<N>, Self>;
    fn from_ast(ctx: LocationCtx<&impl PersistentHirDatabase>, ast: &N) -> Self {
        let items = ctx.db.file_items(ctx.file_id);
-        let raw =
+        let item_id = items.id_of(ctx.file_id, ast.syntax());
-            SourceItemId { file_id: ctx.file_id, item_id: items.id_of(ctx.file_id, ast.syntax()) };
+        Self::from_source_item_id_unchecked(ctx, item_id)
+    }
+    fn from_source_item_id_unchecked(
+        ctx: LocationCtx<&impl PersistentHirDatabase>,
+        item_id: SourceFileItemId,
+    ) -> Self {
+        let raw = SourceItemId { file_id: ctx.file_id, item_id };
        let loc = ItemLoc { module: ctx.module, raw, _ty: PhantomData };
        Self::interner(ctx.db.as_ref()).loc2id(&loc)
@@ -290,6 +303,12 @@ impl AstItemDef<ast::TypeAliasDef> for TypeId {
 pub struct SourceFileItemId(RawId);
 impl_arena_id!(SourceFileItemId);
+impl SourceFileItemId {
+    pub(crate) fn with_file_id(self, file_id: HirFileId) -> SourceItemId {
+        SourceItemId { file_id, item_id: self }
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SourceItemId {
    pub(crate) file_id: HirFileId,
@@ -309,9 +328,7 @@ impl SourceFileItems {
        file_id: HirFileId,
    ) -> Arc<SourceFileItems> {
        let source_file = db.hir_parse(file_id);
-        let mut res = SourceFileItems { file_id, arena: Arena::default() };
+        Arc::new(SourceFileItems::from_source_file(&source_file, file_id))
-        res.init(&source_file);
-        Arc::new(res)
    }
    pub(crate) fn file_item_query(
@@ -324,18 +341,23 @@ impl SourceFileItems {
            .to_owned()
    }
-    fn init(&mut self, source_file: &SourceFile) {
+    pub(crate) fn from_source_file(
+        source_file: &SourceFile,
+        file_id: HirFileId,
+    ) -> SourceFileItems {
+        let mut res = SourceFileItems { file_id, arena: Arena::default() };
        // By walking the tree in bread-first order we make sure that parents
        // get lower ids then children. That is, adding a new child does not
        // change parent's id. This means that, say, adding a new function to a
        // trait does not change ids of top-level items, which helps caching.
        bfs(source_file.syntax(), |it| {
            if let Some(module_item) = ast::ModuleItem::cast(it) {
-                self.alloc(module_item.syntax());
+                res.alloc(module_item.syntax());
            } else if let Some(macro_call) = ast::MacroCall::cast(it) {
-                self.alloc(macro_call.syntax());
+                res.alloc(macro_call.syntax());
            }
-        })
+        });
+        res
    }
    fn alloc(&mut self, item: &SyntaxNode) -> SourceFileItemId {
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index eb2d4ed8d..8807a4b56 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -4,7 +4,8 @@ use rustc_hash::FxHashMap;
 use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
 use ra_syntax::{
    AstPtr, SourceFile, TreeArc,
-ast::{self, AstNode}};
+    ast::{self, AstNode}
+};
 use crate::{
    Const, TypeAlias, Function, HirFileId,
@@ -13,7 +14,7 @@ use crate::{
    type_ref::TypeRef,
    ids::LocationCtx,
    resolve::Resolver,
-    ty::Ty, generics::GenericParams
+    ty::Ty, generics::GenericParams,
 };
 use crate::code_model_api::{Module, ModuleSource};
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index ac5f33079..75c977d32 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -24,9 +24,7 @@ mod path;
 pub mod source_binder;
 mod ids;
-mod macros;
 mod name;
-mod module_tree;
 mod nameres;
 mod adt;
 mod type_alias;
@@ -54,9 +52,8 @@ pub use self::{
    path::{Path, PathKind},
    name::Name,
    ids::{HirFileId, MacroCallId, MacroCallLoc, HirInterner},
-    macros::{MacroDef, MacroInput, MacroExpansion},
+    nameres::{PerNs, Namespace},
-    nameres::{ItemMap, PerNs, Namespace},
+    ty::{Ty, Substs, display::HirDisplay},
-    ty::{Ty, Substs},
    impl_block::{ImplBlock, ImplItem},
    docs::{Docs, Documentation},
    adt::AdtDef,
diff --git a/crates/ra_hir/src/macros.rs b/crates/ra_hir/src/macros.rs
deleted file mode 100644
index 45128c7df..000000000
--- a/crates/ra_hir/src/macros.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-/// Machinery for macro expansion.
-///
-/// One of the more complicated things about macros is managing the source code
-/// that is produced after expansion. See `HirFileId` and `MacroCallId` for how
-/// do we do that.
-///
-/// When the file-management question is resolved, all that is left is a
-/// token-tree-to-token-tree transformation plus hygiene. We don't have either of
-/// those yet, so all macros are string based at the moment!
-use std::sync::Arc;
-use ra_syntax::{
-    TextRange, TextUnit, SourceFile, AstNode, SyntaxNode, TreeArc, SyntaxNodePtr,
-    ast,
-};
-use crate::{MacroCallId, PersistentHirDatabase};
-// Hard-coded defs for now :-(
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum MacroDef {
-    Vec,
-}
-impl MacroDef {
-    /// Expands macro call, returning the expansion and offset to be used to
-    /// convert ranges between expansion and original source.
-    pub fn ast_expand(macro_call: &ast::MacroCall) -> Option<(TextUnit, MacroExpansion)> {
-        let (def, input) = MacroDef::from_call(macro_call)?;
-        let exp = def.expand(input)?;
-        let off = macro_call.token_tree()?.syntax().range().start();
-        Some((off, exp))
-    }
-    fn from_call(macro_call: &ast::MacroCall) -> Option<(MacroDef, MacroInput)> {
-        let def = {
-            let path = macro_call.path()?;
-            let name_ref = path.segment()?.name_ref()?;
-            if name_ref.text() == "vec" {
-                MacroDef::Vec
-            } else {
-                return None;
-            }
-        };
-        let input = {
-            let arg = macro_call.token_tree()?.syntax();
-            MacroInput { text: arg.text().to_string() }
-        };
-        Some((def, input))
-    }
-    fn expand(self, input: MacroInput) -> Option<MacroExpansion> {
-        match self {
-            MacroDef::Vec => self.expand_vec(input),
-        }
-    }
-    fn expand_vec(self, input: MacroInput) -> Option<MacroExpansion> {
-        let text = format!(r"fn dummy() {{ {}; }}", input.text);
-        let file = SourceFile::parse(&text);
-        let array_expr = file.syntax().descendants().find_map(ast::ArrayExpr::cast)?;
-        let ptr = SyntaxNodePtr::new(array_expr.syntax());
-        let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
-        let ranges_map = vec![(src_range, array_expr.syntax().range())];
-        let res = MacroExpansion { text, ranges_map, ptr };
-        Some(res)
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MacroInput {
-    // Should be token trees
-    pub text: String,
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MacroExpansion {
-    /// The result of macro expansion. Should be token tree as well.
-    text: String,
-    /// Correspondence between ranges in the original source code and ranges in
-    /// the macro.
-    ranges_map: Vec<(TextRange, TextRange)>,
-    /// Implementation detail: internally, a macro is expanded to the whole file,
-    /// even if it is an expression. This `ptr` selects the actual expansion from
-    /// the expanded file.
-    ptr: SyntaxNodePtr,
-}
-impl MacroExpansion {
-    // FIXME: does not really make sense, macro expansion is not necessary a
-    // whole file. See `MacroExpansion::ptr` as well.
-    pub(crate) fn file(&self) -> TreeArc<SourceFile> {
-        SourceFile::parse(&self.text)
-    }
-    pub fn syntax(&self) -> TreeArc<SyntaxNode> {
-        self.ptr.to_node(&self.file()).to_owned()
-    }
-    /// Maps range in the source code to the range in the expanded code.
-    pub fn map_range_forward(&self, src_range: TextRange) -> Option<TextRange> {
-        for (s_range, t_range) in self.ranges_map.iter() {
-            if src_range.is_subrange(&s_range) {
-                let src_at_zero_range = src_range - src_range.start();
-                let src_range_offset = src_range.start() - s_range.start();
-                let src_range = src_at_zero_range + src_range_offset + t_range.start();
-                return Some(src_range);
-            }
-        }
-        None
-    }
-    /// Maps range in the expanded code to the range in the source code.
-    pub fn map_range_back(&self, tgt_range: TextRange) -> Option<TextRange> {
-        for (s_range, t_range) in self.ranges_map.iter() {
-            if tgt_range.is_subrange(&t_range) {
-                let tgt_at_zero_range = tgt_range - tgt_range.start();
-                let tgt_range_offset = tgt_range.start() - t_range.start();
-                let src_range = tgt_at_zero_range + tgt_range_offset + s_range.start();
-                return Some(src_range);
-            }
-        }
-        None
-    }
-}
-pub(crate) fn expand_macro_invocation(
-    db: &impl PersistentHirDatabase,
-    invoc: MacroCallId,
-) -> Option<Arc<MacroExpansion>> {
-    let loc = invoc.loc(db);
-    let syntax = db.file_item(loc.source_item_id);
-    let macro_call = ast::MacroCall::cast(&syntax).unwrap();
-    let (def, input) = MacroDef::from_call(macro_call)?;
-    def.expand(input).map(Arc::new)
-}
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index 6f3e5f09d..5b6400042 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -1,6 +1,7 @@
 test_utils::marks!(
+    bogus_paths
    name_res_works_for_broken_modules
-    item_map_enum_importing
+    can_import_enum_variant
    type_var_cycles_resolve_completely
    type_var_cycles_resolve_as_possible
    type_var_resolves_to_int_var
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index 99c2115e1..e69de29bb 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -1,331 +0,0 @@
-use std::sync::Arc;
-use arrayvec::ArrayVec;
-use relative_path::RelativePathBuf;
-use ra_db::{FileId, SourceRoot};
-use ra_syntax::{
-    SyntaxNode, TreeArc,
-    algo::generate,
-    ast::{self, AstNode, NameOwner},
-};
-use ra_arena::{Arena, RawId, impl_arena_id};
-use test_utils::tested_by;
-use crate::{
-    Name, AsName, HirDatabase, SourceItemId, HirFileId, Problem, SourceFileItems, ModuleSource,
-    PersistentHirDatabase,
-    Crate,
-    ids::SourceFileItemId,
-};
-impl ModuleSource {
-    pub(crate) fn new(
-        db: &impl PersistentHirDatabase,
-        file_id: HirFileId,
-        decl_id: Option<SourceFileItemId>,
-    ) -> ModuleSource {
-        match decl_id {
-            Some(item_id) => {
-                let module = db.file_item(SourceItemId { file_id, item_id });
-                let module = ast::Module::cast(&*module).unwrap();
-                assert!(module.item_list().is_some(), "expected inline module");
-                ModuleSource::Module(module.to_owned())
-            }
-            None => {
-                let source_file = db.hir_parse(file_id);
-                ModuleSource::SourceFile(source_file)
-            }
-        }
-    }
-}
-#[derive(Clone, Hash, PartialEq, Eq, Debug)]
-pub struct Submodule {
-    name: Name,
-    is_declaration: bool,
-    decl_id: SourceFileItemId,
-}
-impl Submodule {
-    pub(crate) fn submodules_query(
-        db: &impl PersistentHirDatabase,
-        file_id: HirFileId,
-        decl_id: Option<SourceFileItemId>,
-    ) -> Arc<Vec<Submodule>> {
-        db.check_canceled();
-        let file_items = db.file_items(file_id);
-        let module_source = ModuleSource::new(db, file_id, decl_id);
-        let submodules = match module_source {
-            ModuleSource::SourceFile(source_file) => {
-                collect_submodules(file_id, &file_items, &*source_file)
-            }
-            ModuleSource::Module(module) => {
-                collect_submodules(file_id, &file_items, module.item_list().unwrap())
-            }
-        };
-        return Arc::new(submodules);
-        fn collect_submodules(
-            file_id: HirFileId,
-            file_items: &SourceFileItems,
-            root: &impl ast::ModuleItemOwner,
-        ) -> Vec<Submodule> {
-            root.items()
-                .filter_map(|item| match item.kind() {
-                    ast::ModuleItemKind::Module(m) => Some(m),
-                    _ => None,
-                })
-                .filter_map(|module| {
-                    let name = module.name()?.as_name();
-                    if !module.has_semi() && module.item_list().is_none() {
-                        tested_by!(name_res_works_for_broken_modules);
-                        return None;
-                    }
-                    let sub = Submodule {
-                        name,
-                        is_declaration: module.has_semi(),
-                        decl_id: file_items.id_of(file_id, module.syntax()),
-                    };
-                    Some(sub)
-                })
-                .collect()
-        }
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ModuleId(RawId);
-impl_arena_id!(ModuleId);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct LinkId(RawId);
-impl_arena_id!(LinkId);
-/// Physically, rust source is organized as a set of files, but logically it is
-/// organized as a tree of modules. Usually, a single file corresponds to a
-/// single module, but it is not neccessarily always the case.
-///
-/// `ModuleTree` encapsulates the logic of transitioning from the fuzzy world of files
-/// (which can have multiple parents) to the precise world of modules (which
-/// always have one parent).
-#[derive(Default, Debug, PartialEq, Eq)]
-pub struct ModuleTree {
-    mods: Arena<ModuleId, ModuleData>,
-    links: Arena<LinkId, LinkData>,
-}
-#[derive(Debug, PartialEq, Eq)]
-pub struct ModuleData {
-    file_id: HirFileId,
-    /// Points to `ast::Module`, `None` for the whole file.
-    decl_id: Option<SourceFileItemId>,
-    parent: Option<LinkId>,
-    children: Vec<LinkId>,
-}
-#[derive(Hash, Debug, PartialEq, Eq)]
-struct LinkData {
-    source: SourceItemId,
-    owner: ModuleId,
-    name: Name,
-    points_to: Vec<ModuleId>,
-    problem: Option<Problem>,
-}
-impl ModuleTree {
-    pub(crate) fn module_tree_query(
-        db: &impl PersistentHirDatabase,
-        krate: Crate,
-    ) -> Arc<ModuleTree> {
-        db.check_canceled();
-        let mut res = ModuleTree::default();
-        res.init_crate(db, krate);
-        Arc::new(res)
-    }
-    pub(crate) fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
-        self.mods.iter().map(|(id, _)| id)
-    }
-    pub(crate) fn find_module_by_source(
-        &self,
-        file_id: HirFileId,
-        decl_id: Option<SourceFileItemId>,
-    ) -> Option<ModuleId> {
-        let (res, _) =
-            self.mods.iter().find(|(_, m)| (m.file_id, m.decl_id) == (file_id, decl_id))?;
-        Some(res)
-    }
-    fn init_crate(&mut self, db: &impl PersistentHirDatabase, krate: Crate) {
-        let crate_graph = db.crate_graph();
-        let file_id = crate_graph.crate_root(krate.crate_id);
-        let source_root_id = db.file_source_root(file_id);
-        let source_root = db.source_root(source_root_id);
-        self.init_subtree(db, &source_root, None, file_id.into(), None);
-    }
-    fn init_subtree(
-        &mut self,
-        db: &impl PersistentHirDatabase,
-        source_root: &SourceRoot,
-        parent: Option<LinkId>,
-        file_id: HirFileId,
-        decl_id: Option<SourceFileItemId>,
-    ) -> ModuleId {
-        let is_root = parent.is_none();
-        let id = self.alloc_mod(ModuleData { file_id, decl_id, parent, children: Vec::new() });
-        for sub in db.submodules(file_id, decl_id).iter() {
-            let link = self.alloc_link(LinkData {
-                source: SourceItemId { file_id, item_id: sub.decl_id },
-                name: sub.name.clone(),
-                owner: id,
-                points_to: Vec::new(),
-                problem: None,
-            });
-            let (points_to, problem) = if sub.is_declaration {
-                let (points_to, problem) = resolve_submodule(db, file_id, &sub.name, is_root);
-                let points_to = points_to
-                    .into_iter()
-                    .map(|file_id| {
-                        self.init_subtree(db, source_root, Some(link), file_id.into(), None)
-                    })
-                    .collect::<Vec<_>>();
-                (points_to, problem)
-            } else {
-                let points_to =
-                    self.init_subtree(db, source_root, Some(link), file_id, Some(sub.decl_id));
-                (vec![points_to], None)
-            };
-            self.links[link].points_to = points_to;
-            self.links[link].problem = problem;
-        }
-        id
-    }
-    fn alloc_mod(&mut self, data: ModuleData) -> ModuleId {
-        self.mods.alloc(data)
-    }
-    fn alloc_link(&mut self, data: LinkData) -> LinkId {
-        let owner = data.owner;
-        let id = self.links.alloc(data);
-        self.mods[owner].children.push(id);
-        id
-    }
-}
-impl ModuleId {
-    pub(crate) fn file_id(self, tree: &ModuleTree) -> HirFileId {
-        tree.mods[self].file_id
-    }
-    pub(crate) fn decl_id(self, tree: &ModuleTree) -> Option<SourceFileItemId> {
-        tree.mods[self].decl_id
-    }
-    pub(crate) fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
-        tree.mods[self].parent
-    }
-    pub(crate) fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
-        let link = self.parent_link(tree)?;
-        Some(tree.links[link].owner)
-    }
-    pub(crate) fn crate_root(self, tree: &ModuleTree) -> ModuleId {
-        generate(Some(self), move |it| it.parent(tree)).last().unwrap()
-    }
-    pub(crate) fn child(self, tree: &ModuleTree, name: &Name) -> Option<ModuleId> {
-        let link = tree.mods[self]
-            .children
-            .iter()
-            .map(|&it| &tree.links[it])
-            .find(|it| it.name == *name)?;
-        Some(*link.points_to.first()?)
-    }
-    pub(crate) fn children<'a>(
-        self,
-        tree: &'a ModuleTree,
-    ) -> impl Iterator<Item = (Name, ModuleId)> + 'a {
-        tree.mods[self].children.iter().filter_map(move |&it| {
-            let link = &tree.links[it];
-            let module = *link.points_to.first()?;
-            Some((link.name.clone(), module))
-        })
-    }
-    pub(crate) fn problems(
-        self,
-        tree: &ModuleTree,
-        db: &impl HirDatabase,
-    ) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
-        tree.mods[self]
-            .children
-            .iter()
-            .filter_map(|&link| {
-                let p = tree.links[link].problem.clone()?;
-                let s = link.source(tree, db);
-                let s = s.name().unwrap().syntax().to_owned();
-                Some((s, p))
-            })
-            .collect()
-    }
-}
-impl LinkId {
-    pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId {
-        tree.links[self].owner
-    }
-    pub(crate) fn name(self, tree: &ModuleTree) -> &Name {
-        &tree.links[self].name
-    }
-    pub(crate) fn source(
-        self,
-        tree: &ModuleTree,
-        db: &impl PersistentHirDatabase,
-    ) -> TreeArc<ast::Module> {
-        let syntax_node = db.file_item(tree.links[self].source);
-        ast::Module::cast(&syntax_node).unwrap().to_owned()
-    }
-}
-fn resolve_submodule(
-    db: &impl PersistentHirDatabase,
-    file_id: HirFileId,
-    name: &Name,
-    is_root: bool,
-) -> (Vec<FileId>, Option<Problem>) {
-    // FIXME: handle submodules of inline modules properly
-    let file_id = file_id.original_file(db);
-    let source_root_id = db.file_source_root(file_id);
-    let path = db.file_relative_path(file_id);
-    let root = RelativePathBuf::default();
-    let dir_path = path.parent().unwrap_or(&root);
-    let mod_name = path.file_stem().unwrap_or("unknown");
-    let is_dir_owner = is_root || mod_name == "mod";
-    let file_mod = dir_path.join(format!("{}.rs", name));
-    let dir_mod = dir_path.join(format!("{}/mod.rs", name));
-    let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name));
-    let mut candidates = ArrayVec::<[_; 2]>::new();
-    if is_dir_owner {
-        candidates.push(file_mod.clone());
-        candidates.push(dir_mod);
-    } else {
-        candidates.push(file_dir_mod.clone());
-    };
-    let sr = db.source_root(source_root_id);
-    let points_to = candidates
-        .into_iter()
-        .filter_map(|path| sr.files.get(&path))
-        .map(|&it| it)
-        .collect::<Vec<_>>();
-    let problem = if points_to.is_empty() {
-        Some(Problem::UnresolvedModule {
-            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
-        })
-    } else {
-        None
-    };
-    (points_to, problem)
-}
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 8d786d2ac..06bafa6f0 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -64,6 +64,7 @@ impl Name {
            "str" => KnownName::Str,
            "Self" => KnownName::SelfType,
            "self" => KnownName::SelfParam,
+            "macro_rules" => KnownName::MacroRules,
            _ => return None,
        };
        Some(name)
@@ -122,4 +123,6 @@ pub(crate) enum KnownName {
    SelfType,
    SelfParam,
+    MacroRules,
 }
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 73919ee37..edd2f25f7 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -1,60 +1,148 @@
-//! Name resolution algorithm. The end result of the algorithm is an `ItemMap`:
+/// This module implements import-resolution/macro expansion algorithm.
-//! a map which maps each module to its scope: the set of items visible in the
+///
-//! module. That is, we only resolve imports here, name resolution of item
+/// The result of this module is `CrateDefMap`: a datastructure which contains:
-//! bodies will be done in a separate step.
+///
-//!
+///   * a tree of modules for the crate
-//! Like Rustc, we use an interactive per-crate algorithm: we start with scopes
+///   * for each module, a set of items visible in the module (directly declared
-//! containing only directly defined items, and then iteratively resolve
+///     or imported)
-//! imports.
+///
-//!
+/// Note that `CrateDefMap` contains fully macro expanded code.
-//! To make this work nicely in the IDE scenario, we place `InputModuleItems`
+///
-//! in between raw syntax and name resolution. `InputModuleItems` are computed
+/// Computing `CrateDefMap` can be partitioned into several logically
-//! using only the module's syntax, and it is all directly defined items plus
+/// independent "phases". The phases are mutually recursive though, there's no
-//! imports. The plan is to make `InputModuleItems` independent of local
+/// strict ordering.
-//! modifications (that is, typing inside a function should not change IMIs),
+///
-//! so that the results of name resolution can be preserved unless the module
+/// ## Collecting RawItems
-//! structure itself is modified.
+///
-pub(crate) mod lower;
+///  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
-use std::{time, sync::Arc};
+///  this phase. Macro calls are represented as a triple of (Path, Option<Name>,
+///  TokenTree).
-use rustc_hash::{FxHashMap, FxHashSet};
+///
+/// ## Collecting Modules
-use ra_arena::map::ArenaMap;
+///
-use ra_db::Edition;
+/// This happens in the `collector` module. In this phase, we recursively walk
+/// tree of modules, collect raw items from submodules, populate module scopes
+/// with defined items (so, we assign item ids in this phase) and record the set
+/// of unresolved imports and macros.
+///
+/// While we walk tree of modules, we also record macro_rules definitions and
+/// expand calls to macro_rules defined macros.
+///
+/// ## Resolving Imports
+///
+/// We maintain a list of currently unresolved imports. On every iteration, we
+/// try to resolve some imports from this list. If the import is resolved, we
+/// record it, by adding an item to current module scope and, if necessary, by
+/// recursively populating glob imports.
+///
+/// ## Resolving Macros
+///
+/// macro_rules from the same crate use a global mutable namespace. We expand
+/// them immediately, when we collect modules.
+///
+/// Macros from other crates (including proc-macros) can be used with
+/// `foo::bar!` syntax. We handle them similarly to imports. There's a list of
+/// unexpanded macros. On every iteration, we try to resolve each macro call
+/// path and, upon success, we run macro expansion and "collect module" phase
+/// on the result
+mod per_ns;
+mod raw;
+mod collector;
+#[cfg(test)]
+mod tests;
+use std::sync::Arc;
+use rustc_hash::FxHashMap;
+use ra_arena::{Arena, RawId, impl_arena_id};
+use ra_db::{FileId, Edition};
 use test_utils::tested_by;
 use crate::{
-    Module, ModuleDef,
+    ModuleDef, Name, Crate, Module, Problem,
-    Path, PathKind, PersistentHirDatabase,
+    PersistentHirDatabase, Path, PathKind, HirFileId,
-    Crate, Name,
+    ids::{SourceItemId, SourceFileItemId, MacroCallId},
-    module_tree::{ModuleId, ModuleTree},
-    nameres::lower::{ImportId, LoweredModule, ImportData},
 };
-/// `ItemMap` is the result of module name resolution. It contains, for each
+pub(crate) use self::raw::{RawItems, ImportId, ImportSourceMap};
-/// module, the set of visible items.
+pub use self::per_ns::{PerNs, Namespace};
+/// Contans all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
-pub struct ItemMap {
+pub struct CrateDefMap {
+    krate: Crate,
    edition: Edition,
    /// The prelude module for this crate. This either comes from an import
    /// marked with the `prelude_import` attribute, or (in the normal case) from
    /// a dependency (`std` or `core`).
-    pub(crate) prelude: Option<Module>,
+    prelude: Option<Module>,
-    pub(crate) extern_prelude: FxHashMap<Name, ModuleDef>,
+    extern_prelude: FxHashMap<Name, ModuleDef>,
-    per_module: ArenaMap<ModuleId, ModuleScope>,
+    root: CrateModuleId,
+    modules: Arena<CrateModuleId, ModuleData>,
+    macros: Arena<CrateMacroId, mbe::MacroRules>,
+    public_macros: FxHashMap<Name, CrateMacroId>,
+    macro_resolutions: FxHashMap<MacroCallId, (Crate, CrateMacroId)>,
+    problems: CrateDefMapProblems,
+}
+impl std::ops::Index<CrateModuleId> for CrateDefMap {
+    type Output = ModuleData;
+    fn index(&self, id: CrateModuleId) -> &ModuleData {
+        &self.modules[id]
+    }
+}
+impl std::ops::Index<CrateMacroId> for CrateDefMap {
+    type Output = mbe::MacroRules;
+    fn index(&self, id: CrateMacroId) -> &mbe::MacroRules {
+        &self.macros[id]
+    }
+}
+/// An ID of a macro, **local** to a specific crate
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct CrateMacroId(RawId);
+impl_arena_id!(CrateMacroId);
+/// An ID of a module, **local** to a specific crate
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct CrateModuleId(RawId);
+impl_arena_id!(CrateModuleId);
+#[derive(Default, Debug, PartialEq, Eq)]
+pub(crate) struct ModuleData {
+    pub(crate) parent: Option<CrateModuleId>,
+    pub(crate) children: FxHashMap<Name, CrateModuleId>,
+    pub(crate) scope: ModuleScope,
+    /// None for root
+    pub(crate) declaration: Option<SourceItemId>,
+    /// None for inline modules.
+    ///
+    /// Note that non-inline modules, by definition, live inside non-macro file.
+    pub(crate) definition: Option<FileId>,
+}
+#[derive(Default, Debug, PartialEq, Eq)]
+pub(crate) struct CrateDefMapProblems {
+    problems: Vec<(SourceItemId, Problem)>,
 }
-impl std::ops::Index<ModuleId> for ItemMap {
+impl CrateDefMapProblems {
-    type Output = ModuleScope;
+    fn add(&mut self, source_item_id: SourceItemId, problem: Problem) {
-    fn index(&self, id: ModuleId) -> &ModuleScope {
+        self.problems.push((source_item_id, problem))
-        &self.per_module[id]
+    }
+    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (&'a SourceItemId, &'a Problem)> + 'a {
+        self.problems.iter().map(|(s, p)| (s, p))
    }
 }
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
 pub struct ModuleScope {
-    pub(crate) items: FxHashMap<Name, Resolution>,
+    items: FxHashMap<Name, Resolution>,
 }
 impl ModuleScope {
@@ -66,8 +154,6 @@ impl ModuleScope {
    }
 }
-/// `Resolution` is basically `DefId` atm, but it should account for stuff like
-/// multiple namespaces, ambiguity and errors.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct Resolution {
    /// None for unresolved
@@ -76,372 +162,6 @@ pub struct Resolution {
    pub import: Option<ImportId>,
 }
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Namespace {
-    Types,
-    Values,
-}
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct PerNs<T> {
-    pub types: Option<T>,
-    pub values: Option<T>,
-}
-impl<T> Default for PerNs<T> {
-    fn default() -> Self {
-        PerNs { types: None, values: None }
-    }
-}
-impl<T> PerNs<T> {
-    pub fn none() -> PerNs<T> {
-        PerNs { types: None, values: None }
-    }
-    pub fn values(t: T) -> PerNs<T> {
-        PerNs { types: None, values: Some(t) }
-    }
-    pub fn types(t: T) -> PerNs<T> {
-        PerNs { types: Some(t), values: None }
-    }
-    pub fn both(types: T, values: T) -> PerNs<T> {
-        PerNs { types: Some(types), values: Some(values) }
-    }
-    pub fn is_none(&self) -> bool {
-        self.types.is_none() && self.values.is_none()
-    }
-    pub fn is_both(&self) -> bool {
-        self.types.is_some() && self.values.is_some()
-    }
-    pub fn take(self, namespace: Namespace) -> Option<T> {
-        match namespace {
-            Namespace::Types => self.types,
-            Namespace::Values => self.values,
-        }
-    }
-    pub fn take_types(self) -> Option<T> {
-        self.take(Namespace::Types)
-    }
-    pub fn take_values(self) -> Option<T> {
-        self.take(Namespace::Values)
-    }
-    pub fn get(&self, namespace: Namespace) -> Option<&T> {
-        self.as_ref().take(namespace)
-    }
-    pub fn as_ref(&self) -> PerNs<&T> {
-        PerNs { types: self.types.as_ref(), values: self.values.as_ref() }
-    }
-    pub fn or(self, other: PerNs<T>) -> PerNs<T> {
-        PerNs { types: self.types.or(other.types), values: self.values.or(other.values) }
-    }
-    pub fn and_then<U>(self, f: impl Fn(T) -> Option<U>) -> PerNs<U> {
-        PerNs { types: self.types.and_then(&f), values: self.values.and_then(&f) }
-    }
-    pub fn map<U>(self, f: impl Fn(T) -> U) -> PerNs<U> {
-        PerNs { types: self.types.map(&f), values: self.values.map(&f) }
-    }
-}
-struct Resolver<'a, DB> {
-    db: &'a DB,
-    input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-    krate: Crate,
-    module_tree: Arc<ModuleTree>,
-    processed_imports: FxHashSet<(ModuleId, ImportId)>,
-    /// If module `a` has `use b::*`, then this contains the mapping b -> a (and the import)
-    glob_imports: FxHashMap<ModuleId, Vec<(ModuleId, ImportId)>>,
-    result: ItemMap,
-}
-impl<'a, DB> Resolver<'a, DB>
-where
-    DB: PersistentHirDatabase,
-{
-    fn new(
-        db: &'a DB,
-        input: &'a FxHashMap<ModuleId, Arc<LoweredModule>>,
-        krate: Crate,
-    ) -> Resolver<'a, DB> {
-        let module_tree = db.module_tree(krate);
-        Resolver {
-            db,
-            input,
-            krate,
-            module_tree,
-            processed_imports: FxHashSet::default(),
-            glob_imports: FxHashMap::default(),
-            result: ItemMap {
-                edition: krate.edition(db),
-                prelude: None,
-                extern_prelude: FxHashMap::default(),
-                per_module: ArenaMap::default(),
-            },
-        }
-    }
-    pub(crate) fn resolve(mut self) -> ItemMap {
-        self.populate_extern_prelude();
-        for (&module_id, items) in self.input.iter() {
-            self.populate_module(module_id, Arc::clone(items));
-        }
-        let mut iter = 0;
-        loop {
-            iter += 1;
-            if iter > 1000 {
-                panic!("failed to reach fixedpoint after 1000 iters")
-            }
-            let processed_imports_count = self.processed_imports.len();
-            for &module_id in self.input.keys() {
-                self.db.check_canceled();
-                self.resolve_imports(module_id);
-            }
-            if processed_imports_count == self.processed_imports.len() {
-                // no new imports resolved
-                break;
-            }
-        }
-        self.result
-    }
-    fn populate_extern_prelude(&mut self) {
-        for dep in self.krate.dependencies(self.db) {
-            log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate);
-            if let Some(module) = dep.krate.root_module(self.db) {
-                self.result.extern_prelude.insert(dep.name.clone(), module.into());
-            }
-            // look for the prelude
-            if self.result.prelude.is_none() {
-                let item_map = self.db.item_map(dep.krate);
-                if item_map.prelude.is_some() {
-                    self.result.prelude = item_map.prelude;
-                }
-            }
-        }
-    }
-    fn populate_module(&mut self, module_id: ModuleId, input: Arc<LoweredModule>) {
-        let mut module_items = ModuleScope::default();
-        for (import_id, import_data) in input.imports.iter() {
-            if let Some(last_segment) = import_data.path.segments.iter().last() {
-                if !import_data.is_glob {
-                    let name =
-                        import_data.alias.clone().unwrap_or_else(|| last_segment.name.clone());
-                    module_items
-                        .items
-                        .insert(name, Resolution { def: PerNs::none(), import: Some(import_id) });
-                }
-            }
-        }
-        // Populate explicitly declared items, except modules
-        for (name, &def) in input.declarations.iter() {
-            let resolution = Resolution { def, import: None };
-            module_items.items.insert(name.clone(), resolution);
-        }
-        // Populate modules
-        for (name, module_id) in module_id.children(&self.module_tree) {
-            let module = Module { module_id, krate: self.krate };
-            self.add_module_item(&mut module_items, name, PerNs::types(module.into()));
-        }
-        self.result.per_module.insert(module_id, module_items);
-    }
-    fn add_module_item(&self, module_items: &mut ModuleScope, name: Name, def: PerNs<ModuleDef>) {
-        let resolution = Resolution { def, import: None };
-        module_items.items.insert(name, resolution);
-    }
-    fn resolve_imports(&mut self, module_id: ModuleId) {
-        for (import_id, import_data) in self.input[&module_id].imports.iter() {
-            if self.processed_imports.contains(&(module_id, import_id)) {
-                // already done
-                continue;
-            }
-            if self.resolve_import(module_id, import_id, import_data) == ReachedFixedPoint::Yes {
-                log::debug!("import {:?} resolved (or definite error)", import_id);
-                self.processed_imports.insert((module_id, import_id));
-            }
-        }
-    }
-    fn resolve_import(
-        &mut self,
-        module_id: ModuleId,
-        import_id: ImportId,
-        import: &ImportData,
-    ) -> ReachedFixedPoint {
-        log::debug!("resolving import: {:?} ({:?})", import, self.result.edition);
-        let original_module = Module { krate: self.krate, module_id };
-        let (def, reached_fixedpoint) = if import.is_extern_crate {
-            let res = self.result.resolve_name_in_extern_prelude(
-                &import
-                    .path
-                    .as_ident()
-                    .expect("extern crate should have been desugared to one-element path"),
-            );
-            (res, if res.is_none() { ReachedFixedPoint::No } else { ReachedFixedPoint::Yes })
-        } else {
-            let res = self.result.resolve_path_fp(
-                self.db,
-                ResolveMode::Import,
-                original_module,
-                &import.path,
-            );
-            (res.resolved_def, res.reached_fixedpoint)
-        };
-        if reached_fixedpoint != ReachedFixedPoint::Yes {
-            return reached_fixedpoint;
-        }
-        if import.is_glob {
-            log::debug!("glob import: {:?}", import);
-            match def.take_types() {
-                Some(ModuleDef::Module(m)) => {
-                    if import.is_prelude {
-                        tested_by!(std_prelude);
-                        self.result.prelude = Some(m);
-                    } else if m.krate != self.krate {
-                        tested_by!(glob_across_crates);
-                        // glob import from other crate => we can just import everything once
-                        let item_map = self.db.item_map(m.krate);
-                        let scope = &item_map[m.module_id];
-                        let items = scope
-                            .items
-                            .iter()
-                            .map(|(name, res)| (name.clone(), res.clone()))
-                            .collect::<Vec<_>>();
-                        self.update(module_id, Some(import_id), &items);
-                    } else {
-                        // glob import from same crate => we do an initial
-                        // import, and then need to propagate any further
-                        // additions
-                        let scope = &self.result[m.module_id];
-                        let items = scope
-                            .items
-                            .iter()
-                            .map(|(name, res)| (name.clone(), res.clone()))
-                            .collect::<Vec<_>>();
-                        self.update(module_id, Some(import_id), &items);
-                        // record the glob import in case we add further items
-                        self.glob_imports
-                            .entry(m.module_id)
-                            .or_default()
-                            .push((module_id, import_id));
-                    }
-                }
-                Some(ModuleDef::Enum(e)) => {
-                    tested_by!(glob_enum);
-                    // glob import from enum => just import all the variants
-                    let variants = e.variants(self.db);
-                    let resolutions = variants
-                        .into_iter()
-                        .filter_map(|variant| {
-                            let res = Resolution {
-                                def: PerNs::both(variant.into(), variant.into()),
-                                import: Some(import_id),
-                            };
-                            let name = variant.name(self.db)?;
-                            Some((name, res))
-                        })
-                        .collect::<Vec<_>>();
-                    self.update(module_id, Some(import_id), &resolutions);
-                }
-                Some(d) => {
-                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
-                }
-                None => {
-                    log::debug!("glob import {:?} didn't resolve as type", import);
-                }
-            }
-        } else {
-            let last_segment = import.path.segments.last().unwrap();
-            let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone());
-            log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
-            // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
-            if let Some(root_module) = self.krate.root_module(self.db) {
-                if import.is_extern_crate && module_id == root_module.module_id {
-                    if let Some(def) = def.take_types() {
-                        self.result.extern_prelude.insert(name.clone(), def);
-                    }
-                }
-            }
-            let resolution = Resolution { def, import: Some(import_id) };
-            self.update(module_id, None, &[(name, resolution)]);
-        }
-        reached_fixedpoint
-    }
-    fn update(
-        &mut self,
-        module_id: ModuleId,
-        import: Option<ImportId>,
-        resolutions: &[(Name, Resolution)],
-    ) {
-        self.update_recursive(module_id, import, resolutions, 0)
-    }
-    fn update_recursive(
-        &mut self,
-        module_id: ModuleId,
-        import: Option<ImportId>,
-        resolutions: &[(Name, Resolution)],
-        depth: usize,
-    ) {
-        if depth > 100 {
-            // prevent stack overflows (but this shouldn't be possible)
-            panic!("infinite recursion in glob imports!");
-        }
-        let module_items = self.result.per_module.get_mut(module_id).unwrap();
-        let mut changed = false;
-        for (name, res) in resolutions {
-            let existing = module_items.items.entry(name.clone()).or_default();
-            if existing.def.types.is_none() && res.def.types.is_some() {
-                existing.def.types = res.def.types;
-                existing.import = import.or(res.import);
-                changed = true;
-            }
-            if existing.def.values.is_none() && res.def.values.is_some() {
-                existing.def.values = res.def.values;
-                existing.import = import.or(res.import);
-                changed = true;
-            }
-        }
-        if !changed {
-            return;
-        }
-        let glob_imports = self
-            .glob_imports
-            .get(&module_id)
-            .into_iter()
-            .flat_map(|v| v.iter())
-            .cloned()
-            .collect::<Vec<_>>();
-        for (glob_importing_module, glob_import) in glob_imports {
-            // We pass the glob import so that the tracked import in those modules is that glob import
-            self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1);
-        }
-    }
-}
 #[derive(Debug, Clone)]
 struct ResolvePathResult {
    resolved_def: PerNs<ModuleDef>,
@@ -475,84 +195,85 @@ enum ReachedFixedPoint {
    No,
 }
-impl ItemMap {
+impl CrateDefMap {
-    pub(crate) fn item_map_query(db: &impl PersistentHirDatabase, krate: Crate) -> Arc<ItemMap> {
+    pub(crate) fn crate_def_map_query(
-        let start = time::Instant::now();
+        db: &impl PersistentHirDatabase,
-        let module_tree = db.module_tree(krate);
+        krate: Crate,
-        let input = module_tree
+    ) -> Arc<CrateDefMap> {
-            .modules()
+        let start = std::time::Instant::now();
-            .map(|module_id| (module_id, db.lower_module(Module { krate, module_id })))
+        let def_map = {
-            .collect::<FxHashMap<_, _>>();
+            let edition = krate.edition(db);
+            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
-        let resolver = Resolver::new(db, &input, krate);
+            let root = modules.alloc(ModuleData::default());
-        let res = resolver.resolve();
+            CrateDefMap {
-        let elapsed = start.elapsed();
+                krate,
-        log::info!("item_map: {:?}", elapsed);
+                edition,
-        Arc::new(res)
+                extern_prelude: FxHashMap::default(),
+                prelude: None,
+                root,
+                modules,
+                macros: Arena::default(),
+                public_macros: FxHashMap::default(),
+                macro_resolutions: FxHashMap::default(),
+                problems: CrateDefMapProblems::default(),
+            }
+        };
+        let def_map = collector::collect_defs(db, def_map);
+        log::info!("crate_def_map_query: {:?}", start.elapsed());
+        Arc::new(def_map)
    }
-    pub(crate) fn resolve_path(
+    pub(crate) fn root(&self) -> CrateModuleId {
-        &self,
+        self.root
-        db: &impl PersistentHirDatabase,
-        original_module: Module,
-        path: &Path,
-    ) -> (PerNs<ModuleDef>, Option<usize>) {
-        let res = self.resolve_path_fp(db, ResolveMode::Other, original_module, path);
-        (res.resolved_def, res.segment_index)
    }
-    fn resolve_in_prelude(
+    pub(crate) fn problems(&self) -> &CrateDefMapProblems {
-        &self,
+        &self.problems
-        db: &impl PersistentHirDatabase,
-        original_module: Module,
-        name: &Name,
-    ) -> PerNs<ModuleDef> {
-        if let Some(prelude) = self.prelude {
-            let resolution = if prelude.krate == original_module.krate {
-                self[prelude.module_id].items.get(name).cloned()
-            } else {
-                db.item_map(prelude.krate)[prelude.module_id].items.get(name).cloned()
-            };
-            resolution.map(|r| r.def).unwrap_or_else(PerNs::none)
-        } else {
-            PerNs::none()
-        }
    }
-    pub(crate) fn resolve_name_in_module(
+    pub(crate) fn mk_module(&self, module_id: CrateModuleId) -> Module {
-        &self,
+        Module { krate: self.krate, module_id }
-        db: &impl PersistentHirDatabase,
+    }
-        module: Module,
-        name: &Name,
-    ) -> PerNs<ModuleDef> {
-        // Resolve in:
-        //  - current module / scope
-        //  - extern prelude
-        //  - std prelude
-        let from_scope = self[module.module_id].items.get(name).map_or(PerNs::none(), |it| it.def);
-        let from_extern_prelude =
-            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
-        let from_prelude = self.resolve_in_prelude(db, module, name);
-        from_scope.or(from_extern_prelude).or(from_prelude)
+    pub(crate) fn prelude(&self) -> Option<Module> {
+        self.prelude
    }
-    fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
+    pub(crate) fn extern_prelude(&self) -> &FxHashMap<Name, ModuleDef> {
-        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+        &self.extern_prelude
    }
-    fn resolve_name_in_crate_root_or_extern_prelude(
+    pub(crate) fn resolve_macro(
        &self,
-        db: &impl PersistentHirDatabase,
+        macro_call_id: MacroCallId,
-        module: Module,
+    ) -> Option<(Crate, CrateMacroId)> {
-        name: &Name,
+        self.macro_resolutions.get(&macro_call_id).map(|&it| it)
-    ) -> PerNs<ModuleDef> {
+    }
-        let crate_root = module.crate_root(db);
-        let from_crate_root =
-            self[crate_root.module_id].items.get(name).map_or(PerNs::none(), |it| it.def);
-        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
-        from_crate_root.or(from_extern_prelude)
+    pub(crate) fn find_module_by_source(
+        &self,
+        file_id: HirFileId,
+        decl_id: Option<SourceFileItemId>,
+    ) -> Option<CrateModuleId> {
+        let decl_id = decl_id.map(|it| it.with_file_id(file_id));
+        let (module_id, _module_data) = self.modules.iter().find(|(_module_id, module_data)| {
+            if decl_id.is_some() {
+                module_data.declaration == decl_id
+            } else {
+                module_data.definition.map(|it| it.into()) == Some(file_id)
+            }
+        })?;
+        Some(module_id)
+    }
+    pub(crate) fn resolve_path(
+        &self,
+        db: &impl PersistentHirDatabase,
+        original_module: CrateModuleId,
+        path: &Path,
+    ) -> (PerNs<ModuleDef>, Option<usize>) {
+        let res = self.resolve_path_fp(db, ResolveMode::Other, original_module, path);
+        (res.resolved_def, res.segment_index)
    }
    // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
@@ -561,13 +282,17 @@ impl ItemMap {
        &self,
        db: &impl PersistentHirDatabase,
        mode: ResolveMode,
-        original_module: Module,
+        original_module: CrateModuleId,
        path: &Path,
    ) -> ResolvePathResult {
        let mut segments = path.segments.iter().enumerate();
        let mut curr_per_ns: PerNs<ModuleDef> = match path.kind {
-            PathKind::Crate => PerNs::types(original_module.crate_root(db).into()),
+            PathKind::Crate => {
-            PathKind::Self_ => PerNs::types(original_module.into()),
+                PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
+            }
+            PathKind::Self_ => {
+                PerNs::types(Module { krate: self.krate, module_id: original_module }.into())
+            }
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -581,11 +306,7 @@ impl ItemMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(
+                self.resolve_name_in_crate_root_or_extern_prelude(&segment.name)
-                    db,
-                    original_module,
-                    &segment.name,
-                )
            }
            PathKind::Plain => {
                let segment = match segments.next() {
@@ -596,8 +317,8 @@ impl ItemMap {
                self.resolve_name_in_module(db, original_module, &segment.name)
            }
            PathKind::Super => {
-                if let Some(p) = original_module.parent(db) {
+                if let Some(p) = self.modules[original_module].parent {
-                    PerNs::types(p.into())
+                    PerNs::types(Module { krate: self.krate, module_id: p }.into())
                } else {
                    log::debug!("super path in root module");
                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -634,14 +355,14 @@ impl ItemMap {
            curr_per_ns = match curr {
                ModuleDef::Module(module) => {
-                    if module.krate != original_module.krate {
+                    if module.krate != self.krate {
                        let path = Path {
                            segments: path.segments[i..].iter().cloned().collect(),
                            kind: PathKind::Self_,
                        };
                        log::debug!("resolving {:?} in other crate", path);
-                        let item_map = db.item_map(module.krate);
+                        let defp_map = db.crate_def_map(module.krate);
-                        let (def, s) = item_map.resolve_path(db, *module, &path);
+                        let (def, s) = defp_map.resolve_path(db, module.module_id, &path);
                        return ResolvePathResult::with(
                            def,
                            ReachedFixedPoint::Yes,
@@ -649,7 +370,7 @@ impl ItemMap {
                        );
                    }
-                    match self[module.module_id].items.get(&segment.name) {
+                    match self[module.module_id].scope.items.get(&segment.name) {
                        Some(res) if !res.def.is_none() => res.def,
                        _ => {
                            log::debug!("path segment {:?} not found", segment.name);
@@ -659,7 +380,7 @@ impl ItemMap {
                }
                ModuleDef::Enum(e) => {
                    // enum variant
-                    tested_by!(item_map_enum_importing);
+                    tested_by!(can_import_enum_variant);
                    match e.variant(db, &segment.name) {
                        Some(variant) => PerNs::both(variant.into(), variant.into()),
                        None => {
@@ -690,7 +411,47 @@ impl ItemMap {
        }
        ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
    }
-}
-#[cfg(test)]
+    fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
-mod tests;
+        let from_crate_root =
+            self[self.root].scope.items.get(name).map_or(PerNs::none(), |it| it.def);
+        let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
+        from_crate_root.or(from_extern_prelude)
+    }
+    pub(crate) fn resolve_name_in_module(
+        &self,
+        db: &impl PersistentHirDatabase,
+        module: CrateModuleId,
+        name: &Name,
+    ) -> PerNs<ModuleDef> {
+        // Resolve in:
+        //  - current module / scope
+        //  - extern prelude
+        //  - std prelude
+        let from_scope = self[module].scope.items.get(name).map_or(PerNs::none(), |it| it.def);
+        let from_extern_prelude =
+            self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
+        let from_prelude = self.resolve_in_prelude(db, name);
+        from_scope.or(from_extern_prelude).or(from_prelude)
+    }
+    fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs<ModuleDef> {
+        self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
+    }
+    fn resolve_in_prelude(&self, db: &impl PersistentHirDatabase, name: &Name) -> PerNs<ModuleDef> {
+        if let Some(prelude) = self.prelude {
+            let resolution = if prelude.krate == self.krate {
+                self[prelude.module_id].scope.items.get(name).cloned()
+            } else {
+                db.crate_def_map(prelude.krate)[prelude.module_id].scope.items.get(name).cloned()
+            };
+            resolution.map(|r| r.def).unwrap_or_else(PerNs::none)
+        } else {
+            PerNs::none()
+        }
+    }
+}
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
new file mode 100644
index 000000000..12ed49a0a
--- /dev/null
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -0,0 +1,564 @@
+use arrayvec::ArrayVec;
+use rustc_hash::FxHashMap;
+use relative_path::RelativePathBuf;
+use test_utils::tested_by;
+use ra_db::FileId;
+use crate::{
+    Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
+    PersistentHirDatabase, HirFileId, Name, Path, Problem, Crate,
+    KnownName,
+    nameres::{Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode, raw},
+    ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId},
+};
+use super::{CrateDefMap, CrateModuleId, ModuleData, CrateMacroId};
+pub(super) fn collect_defs(
+    db: &impl PersistentHirDatabase,
+    mut def_map: CrateDefMap,
+) -> CrateDefMap {
+    // populate external prelude
+    for dep in def_map.krate.dependencies(db) {
+        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate);
+        if let Some(module) = dep.krate.root_module(db) {
+            def_map.extern_prelude.insert(dep.name.clone(), module.into());
+        }
+        // look for the prelude
+        if def_map.prelude.is_none() {
+            let map = db.crate_def_map(dep.krate);
+            if map.prelude.is_some() {
+                def_map.prelude = map.prelude;
+            }
+        }
+    }
+    let mut collector = DefCollector {
+        db,
+        def_map,
+        glob_imports: FxHashMap::default(),
+        unresolved_imports: Vec::new(),
+        unexpanded_macros: Vec::new(),
+        global_macro_scope: FxHashMap::default(),
+    };
+    collector.collect();
+    collector.finish()
+}
+/// Walks the tree of module recursively
+struct DefCollector<DB> {
+    db: DB,
+    def_map: CrateDefMap,
+    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
+    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
+    unexpanded_macros: Vec<(CrateModuleId, MacroCallId, Path, tt::Subtree)>,
+    global_macro_scope: FxHashMap<Name, CrateMacroId>,
+}
+impl<'a, DB> DefCollector<&'a DB>
+where
+    DB: PersistentHirDatabase,
+{
+    fn collect(&mut self) {
+        let crate_graph = self.db.crate_graph();
+        let file_id = crate_graph.crate_root(self.def_map.krate.crate_id());
+        let raw_items = self.db.raw_items(file_id);
+        let module_id = self.def_map.root;
+        self.def_map.modules[module_id].definition = Some(file_id);
+        ModCollector {
+            def_collector: &mut *self,
+            module_id,
+            file_id: file_id.into(),
+            raw_items: &raw_items,
+        }
+        .collect(raw_items.items());
+        // main name resolution fixed-point loop.
+        let mut i = 0;
+        loop {
+            match (self.resolve_imports(), self.resolve_macros()) {
+                (ReachedFixedPoint::Yes, ReachedFixedPoint::Yes) => break,
+                _ => i += 1,
+            }
+            if i == 1000 {
+                log::error!("diverging name resolution");
+                break;
+            }
+        }
+        let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        // show unresolved imports in completion, etc
+        for (module_id, import, import_data) in unresolved_imports {
+            self.record_resolved_import(module_id, PerNs::none(), import, &import_data)
+        }
+    }
+    fn define_macro(&mut self, name: Name, tt: &tt::Subtree, export: bool) {
+        if let Ok(rules) = mbe::MacroRules::parse(tt) {
+            let macro_id = self.def_map.macros.alloc(rules);
+            if export {
+                self.def_map.public_macros.insert(name.clone(), macro_id);
+            }
+            self.global_macro_scope.insert(name, macro_id);
+        }
+    }
+    fn resolve_imports(&mut self) -> ReachedFixedPoint {
+        let mut imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        let mut resolved = Vec::new();
+        imports.retain(|(module_id, import, import_data)| {
+            let (def, fp) = self.resolve_import(*module_id, import_data);
+            if fp == ReachedFixedPoint::Yes {
+                resolved.push((*module_id, def, *import, import_data.clone()))
+            }
+            fp == ReachedFixedPoint::No
+        });
+        self.unresolved_imports = imports;
+        // Resolves imports, filling-in module scopes
+        let result =
+            if resolved.is_empty() { ReachedFixedPoint::Yes } else { ReachedFixedPoint::No };
+        for (module_id, def, import, import_data) in resolved {
+            self.record_resolved_import(module_id, def, import, &import_data)
+        }
+        result
+    }
+    fn resolve_import(
+        &mut self,
+        module_id: CrateModuleId,
+        import: &raw::ImportData,
+    ) -> (PerNs<ModuleDef>, ReachedFixedPoint) {
+        log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
+        if import.is_extern_crate {
+            let res = self.def_map.resolve_name_in_extern_prelude(
+                &import
+                    .path
+                    .as_ident()
+                    .expect("extern crate should have been desugared to one-element path"),
+            );
+            (res, ReachedFixedPoint::Yes)
+        } else {
+            let res =
+                self.def_map.resolve_path_fp(self.db, ResolveMode::Import, module_id, &import.path);
+            (res.resolved_def, res.reached_fixedpoint)
+        }
+    }
+    fn record_resolved_import(
+        &mut self,
+        module_id: CrateModuleId,
+        def: PerNs<ModuleDef>,
+        import_id: raw::ImportId,
+        import: &raw::ImportData,
+    ) {
+        if import.is_glob {
+            log::debug!("glob import: {:?}", import);
+            match def.take_types() {
+                Some(ModuleDef::Module(m)) => {
+                    if import.is_prelude {
+                        tested_by!(std_prelude);
+                        self.def_map.prelude = Some(m);
+                    } else if m.krate != self.def_map.krate {
+                        tested_by!(glob_across_crates);
+                        // glob import from other crate => we can just import everything once
+                        let item_map = self.db.crate_def_map(m.krate);
+                        let scope = &item_map[m.module_id].scope;
+                        let items = scope
+                            .items
+                            .iter()
+                            .map(|(name, res)| (name.clone(), res.clone()))
+                            .collect::<Vec<_>>();
+                        self.update(module_id, Some(import_id), &items);
+                    } else {
+                        // glob import from same crate => we do an initial
+                        // import, and then need to propagate any further
+                        // additions
+                        let scope = &self.def_map[m.module_id].scope;
+                        let items = scope
+                            .items
+                            .iter()
+                            .map(|(name, res)| (name.clone(), res.clone()))
+                            .collect::<Vec<_>>();
+                        self.update(module_id, Some(import_id), &items);
+                        // record the glob import in case we add further items
+                        self.glob_imports
+                            .entry(m.module_id)
+                            .or_default()
+                            .push((module_id, import_id));
+                    }
+                }
+                Some(ModuleDef::Enum(e)) => {
+                    tested_by!(glob_enum);
+                    // glob import from enum => just import all the variants
+                    let variants = e.variants(self.db);
+                    let resolutions = variants
+                        .into_iter()
+                        .filter_map(|variant| {
+                            let res = Resolution {
+                                def: PerNs::both(variant.into(), variant.into()),
+                                import: Some(import_id),
+                            };
+                            let name = variant.name(self.db)?;
+                            Some((name, res))
+                        })
+                        .collect::<Vec<_>>();
+                    self.update(module_id, Some(import_id), &resolutions);
+                }
+                Some(d) => {
+                    log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
+                }
+                None => {
+                    log::debug!("glob import {:?} didn't resolve as type", import);
+                }
+            }
+        } else {
+            match import.path.segments.last() {
+                Some(last_segment) => {
+                    let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone());
+                    log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
+                    // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
+                    if import.is_extern_crate && module_id == self.def_map.root {
+                        if let Some(def) = def.take_types() {
+                            self.def_map.extern_prelude.insert(name.clone(), def);
+                        }
+                    }
+                    let resolution = Resolution { def, import: Some(import_id) };
+                    self.update(module_id, Some(import_id), &[(name, resolution)]);
+                }
+                None => tested_by!(bogus_paths),
+            }
+        }
+    }
+    fn update(
+        &mut self,
+        module_id: CrateModuleId,
+        import: Option<raw::ImportId>,
+        resolutions: &[(Name, Resolution)],
+    ) {
+        self.update_recursive(module_id, import, resolutions, 0)
+    }
+    fn update_recursive(
+        &mut self,
+        module_id: CrateModuleId,
+        import: Option<raw::ImportId>,
+        resolutions: &[(Name, Resolution)],
+        depth: usize,
+    ) {
+        if depth > 100 {
+            // prevent stack overflows (but this shouldn't be possible)
+            panic!("infinite recursion in glob imports!");
+        }
+        let module_items = &mut self.def_map.modules[module_id].scope;
+        let mut changed = false;
+        for (name, res) in resolutions {
+            let existing = module_items.items.entry(name.clone()).or_default();
+            if existing.def.types.is_none() && res.def.types.is_some() {
+                existing.def.types = res.def.types;
+                existing.import = import.or(res.import);
+                changed = true;
+            }
+            if existing.def.values.is_none() && res.def.values.is_some() {
+                existing.def.values = res.def.values;
+                existing.import = import.or(res.import);
+                changed = true;
+            }
+            if existing.def.is_none()
+                && res.def.is_none()
+                && existing.import.is_none()
+                && res.import.is_some()
+            {
+                existing.import = res.import;
+            }
+        }
+        if !changed {
+            return;
+        }
+        let glob_imports = self
+            .glob_imports
+            .get(&module_id)
+            .into_iter()
+            .flat_map(|v| v.iter())
+            .cloned()
+            .collect::<Vec<_>>();
+        for (glob_importing_module, glob_import) in glob_imports {
+            // We pass the glob import so that the tracked import in those modules is that glob import
+            self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1);
+        }
+    }
+    // XXX: this is just a pile of hacks now, because `PerNs` does not handle
+    // macro namespace.
+    fn resolve_macros(&mut self) -> ReachedFixedPoint {
+        let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new());
+        let mut resolved = Vec::new();
+        let mut res = ReachedFixedPoint::Yes;
+        macros.retain(|(module_id, call_id, path, tt)| {
+            if path.segments.len() != 2 {
+                return true;
+            }
+            let crate_name = &path.segments[0].name;
+            let krate = match self.def_map.resolve_name_in_extern_prelude(crate_name).take_types() {
+                Some(ModuleDef::Module(m)) => m.krate(self.db),
+                _ => return true,
+            };
+            let krate = match krate {
+                Some(it) => it,
+                _ => return true,
+            };
+            res = ReachedFixedPoint::No;
+            let def_map = self.db.crate_def_map(krate);
+            if let Some(macro_id) = def_map.public_macros.get(&path.segments[1].name).cloned() {
+                resolved.push((*module_id, *call_id, (krate, macro_id), tt.clone()));
+            }
+            false
+        });
+        for (module_id, macro_call_id, macro_def_id, arg) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id, arg);
+        }
+        res
+    }
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: CrateModuleId,
+        macro_call_id: MacroCallId,
+        macro_def_id: (Crate, CrateMacroId),
+        macro_arg: tt::Subtree,
+    ) {
+        let (macro_krate, macro_id) = macro_def_id;
+        let dm;
+        let rules = if macro_krate == self.def_map.krate {
+            &self.def_map[macro_id]
+        } else {
+            dm = self.db.crate_def_map(macro_krate);
+            &dm[macro_id]
+        };
+        if let Ok(expansion) = rules.expand(&macro_arg) {
+            self.def_map.macro_resolutions.insert(macro_call_id, macro_def_id);
+            // XXX: this **does not** go through a database, because we can't
+            // identify macro_call without adding the whole state of name resolution
+            // as a parameter to the query.
+            //
+            // So, we run the queries "manually" and we must ensure that
+            // `db.hir_parse(macro_call_id)` returns the same source_file.
+            let file_id: HirFileId = macro_call_id.into();
+            let source_file = mbe::token_tree_to_ast_item_list(&expansion);
+            let raw_items = raw::RawItems::from_source_file(&source_file, file_id);
+            ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items }
+                .collect(raw_items.items())
+        }
+    }
+    fn finish(self) -> CrateDefMap {
+        self.def_map
+    }
+}
+/// Walks a single module, populating defs, imports and macros
+struct ModCollector<'a, D> {
+    def_collector: D,
+    module_id: CrateModuleId,
+    file_id: HirFileId,
+    raw_items: &'a raw::RawItems,
+}
+impl<DB> ModCollector<'_, &'_ mut DefCollector<&'_ DB>>
+where
+    DB: PersistentHirDatabase,
+{
+    fn collect(&mut self, items: &[raw::RawItem]) {
+        for item in items {
+            match *item {
+                raw::RawItem::Module(m) => self.collect_module(&self.raw_items[m]),
+                raw::RawItem::Import(import) => self.def_collector.unresolved_imports.push((
+                    self.module_id,
+                    import,
+                    self.raw_items[import].clone(),
+                )),
+                raw::RawItem::Def(def) => self.define_def(&self.raw_items[def]),
+                raw::RawItem::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+            }
+        }
+    }
+    fn collect_module(&mut self, module: &raw::ModuleData) {
+        match module {
+            // inline module, just recurse
+            raw::ModuleData::Definition { name, items, source_item_id } => {
+                let module_id = self.push_child_module(
+                    name.clone(),
+                    source_item_id.with_file_id(self.file_id),
+                    None,
+                );
+                ModCollector {
+                    def_collector: &mut *self.def_collector,
+                    module_id,
+                    file_id: self.file_id,
+                    raw_items: self.raw_items,
+                }
+                .collect(&*items);
+            }
+            // out of line module, resovle, parse and recurse
+            raw::ModuleData::Declaration { name, source_item_id } => {
+                let source_item_id = source_item_id.with_file_id(self.file_id);
+                let is_root = self.def_collector.def_map.modules[self.module_id].parent.is_none();
+                let (file_ids, problem) =
+                    resolve_submodule(self.def_collector.db, self.file_id, name, is_root);
+                if let Some(problem) = problem {
+                    self.def_collector.def_map.problems.add(source_item_id, problem)
+                }
+                if let Some(&file_id) = file_ids.first() {
+                    let module_id =
+                        self.push_child_module(name.clone(), source_item_id, Some(file_id));
+                    let raw_items = self.def_collector.db.raw_items(file_id);
+                    ModCollector {
+                        def_collector: &mut *self.def_collector,
+                        module_id,
+                        file_id: file_id.into(),
+                        raw_items: &raw_items,
+                    }
+                    .collect(raw_items.items())
+                }
+            }
+        }
+    }
+    fn push_child_module(
+        &mut self,
+        name: Name,
+        declaration: SourceItemId,
+        definition: Option<FileId>,
+    ) -> CrateModuleId {
+        let modules = &mut self.def_collector.def_map.modules;
+        let res = modules.alloc(ModuleData::default());
+        modules[res].parent = Some(self.module_id);
+        modules[res].declaration = Some(declaration);
+        modules[res].definition = definition;
+        modules[self.module_id].children.insert(name.clone(), res);
+        let resolution = Resolution {
+            def: PerNs::types(
+                Module { krate: self.def_collector.def_map.krate, module_id: res }.into(),
+            ),
+            import: None,
+        };
+        self.def_collector.update(self.module_id, None, &[(name, resolution)]);
+        res
+    }
+    fn define_def(&mut self, def: &raw::DefData) {
+        let module = Module { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id.into());
+        macro_rules! id {
+            () => {
+                AstItemDef::from_source_item_id_unchecked(ctx, def.source_item_id)
+            };
+        }
+        let name = def.name.clone();
+        let def: PerNs<ModuleDef> = match def.kind {
+            raw::DefKind::Function => PerNs::values(Function { id: id!() }.into()),
+            raw::DefKind::Struct => {
+                let s = Struct { id: id!() }.into();
+                PerNs::both(s, s)
+            }
+            raw::DefKind::Enum => PerNs::types(Enum { id: id!() }.into()),
+            raw::DefKind::Const => PerNs::values(Const { id: id!() }.into()),
+            raw::DefKind::Static => PerNs::values(Static { id: id!() }.into()),
+            raw::DefKind::Trait => PerNs::types(Trait { id: id!() }.into()),
+            raw::DefKind::TypeAlias => PerNs::types(TypeAlias { id: id!() }.into()),
+        };
+        let resolution = Resolution { def, import: None };
+        self.def_collector.update(self.module_id, None, &[(name, resolution)])
+    }
+    fn collect_macro(&mut self, mac: &raw::MacroData) {
+        // Case 1: macro rules, define a macro in crate-global mutable scope
+        if is_macro_rules(&mac.path) {
+            if let Some(name) = &mac.name {
+                self.def_collector.define_macro(name.clone(), &mac.arg, mac.export)
+            }
+            return;
+        }
+        let source_item_id = SourceItemId { file_id: self.file_id, item_id: mac.source_item_id };
+        let macro_call_id = MacroCallLoc {
+            module: Module { krate: self.def_collector.def_map.krate, module_id: self.module_id },
+            source_item_id,
+        }
+        .id(self.def_collector.db);
+        // Case 2: try to expand macro_rules from this crate, triggering
+        // recursive item collection.
+        if let Some(&macro_id) =
+            mac.path.as_ident().and_then(|name| self.def_collector.global_macro_scope.get(name))
+        {
+            self.def_collector.collect_macro_expansion(
+                self.module_id,
+                macro_call_id,
+                (self.def_collector.def_map.krate, macro_id),
+                mac.arg.clone(),
+            );
+            return;
+        }
+        // Case 3: path to a macro from another crate, expand during name resolution
+        self.def_collector.unexpanded_macros.push((
+            self.module_id,
+            macro_call_id,
+            mac.path.clone(),
+            mac.arg.clone(),
+        ))
+    }
+}
+fn is_macro_rules(path: &Path) -> bool {
+    path.as_ident().and_then(Name::as_known_name) == Some(KnownName::MacroRules)
+}
+fn resolve_submodule(
+    db: &impl PersistentHirDatabase,
+    file_id: HirFileId,
+    name: &Name,
+    is_root: bool,
+) -> (Vec<FileId>, Option<Problem>) {
+    // FIXME: handle submodules of inline modules properly
+    let file_id = file_id.original_file(db);
+    let source_root_id = db.file_source_root(file_id);
+    let path = db.file_relative_path(file_id);
+    let root = RelativePathBuf::default();
+    let dir_path = path.parent().unwrap_or(&root);
+    let mod_name = path.file_stem().unwrap_or("unknown");
+    let is_dir_owner = is_root || mod_name == "mod";
+    let file_mod = dir_path.join(format!("{}.rs", name));
+    let dir_mod = dir_path.join(format!("{}/mod.rs", name));
+    let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name));
+    let mut candidates = ArrayVec::<[_; 2]>::new();
+    if is_dir_owner {
+        candidates.push(file_mod.clone());
+        candidates.push(dir_mod);
+    } else {
+        candidates.push(file_dir_mod.clone());
+    };
+    let sr = db.source_root(source_root_id);
+    let points_to = candidates
+        .into_iter()
+        .filter_map(|path| sr.files.get(&path))
+        .map(|&it| it)
+        .collect::<Vec<_>>();
+    let problem = if points_to.is_empty() {
+        Some(Problem::UnresolvedModule {
+            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
+        })
+    } else {
+        None
+    };
+    (points_to, problem)
+}
diff --git a/crates/ra_hir/src/nameres/lower.rs b/crates/ra_hir/src/nameres/lower.rs
deleted file mode 100644
index 56262ad6d..000000000
--- a/crates/ra_hir/src/nameres/lower.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-use std::sync::Arc;
-use ra_syntax::{
-    AstNode, SourceFile, TreeArc, AstPtr,
-    ast::{self, ModuleItemOwner, NameOwner, AttrsOwner},
-};
-use ra_arena::{Arena, RawId, impl_arena_id, map::ArenaMap};
-use rustc_hash::FxHashMap;
-use crate::{
-    SourceItemId, Path, ModuleSource, Name,
-    HirFileId, MacroCallLoc, AsName, PerNs, Function,
-    ModuleDef, Module, Struct, Enum, Const, Static, Trait, TypeAlias,
-    ids::LocationCtx, PersistentHirDatabase,
-};
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImportId(RawId);
-impl_arena_id!(ImportId);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct ImportData {
-    pub(super) path: Path,
-    pub(super) alias: Option<Name>,
-    pub(super) is_glob: bool,
-    pub(super) is_prelude: bool,
-    pub(super) is_extern_crate: bool,
-}
-/// A set of items and imports declared inside a module, without relation to
-/// other modules.
-///
-/// This sits in-between raw syntax and name resolution and allows us to avoid
-/// recomputing name res: if two instance of `InputModuleItems` are the same, we
-/// can avoid redoing name resolution.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct LoweredModule {
-    pub(crate) declarations: FxHashMap<Name, PerNs<ModuleDef>>,
-    pub(super) imports: Arena<ImportId, ImportData>,
-}
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, AstPtr<ast::PathSegment>>,
-}
-impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
-        self.map.insert(import, AstPtr::new(segment))
-    }
-    pub fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
-        let file = match source {
-            ModuleSource::SourceFile(file) => &*file,
-            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
-        };
-        self.map[import].to_node(file).to_owned()
-    }
-}
-impl LoweredModule {
-    pub(crate) fn lower_module_query(
-        db: &impl PersistentHirDatabase,
-        module: Module,
-    ) -> Arc<LoweredModule> {
-        db.lower_module_with_source_map(module).0
-    }
-    pub(crate) fn lower_module_with_source_map_query(
-        db: &impl PersistentHirDatabase,
-        module: Module,
-    ) -> (Arc<LoweredModule>, Arc<ImportSourceMap>) {
-        let (file_id, source) = module.definition_source(db);
-        let file_id: HirFileId = file_id.into();
-        let mut source_map = ImportSourceMap::default();
-        let mut res = LoweredModule::default();
-        match source {
-            ModuleSource::SourceFile(it) => {
-                res.fill(&mut source_map, db, module, file_id, &mut it.items_with_macros())
-            }
-            ModuleSource::Module(it) => {
-                if let Some(item_list) = it.item_list() {
-                    res.fill(
-                        &mut source_map,
-                        db,
-                        module,
-                        file_id,
-                        &mut item_list.items_with_macros(),
-                    )
-                }
-            }
-        };
-        (Arc::new(res), Arc::new(source_map))
-    }
-    fn fill(
-        &mut self,
-        source_map: &mut ImportSourceMap,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        file_id: HirFileId,
-        items: &mut Iterator<Item = ast::ItemOrMacro>,
-    ) {
-        let file_items = db.file_items(file_id);
-        for item in items {
-            match item {
-                ast::ItemOrMacro::Item(it) => {
-                    self.add_def_id(source_map, db, module, file_id, it);
-                }
-                ast::ItemOrMacro::Macro(macro_call) => {
-                    let item_id = file_items.id_of_unchecked(macro_call.syntax());
-                    let loc =
-                        MacroCallLoc { module, source_item_id: SourceItemId { file_id, item_id } };
-                    let id = loc.id(db);
-                    let file_id = HirFileId::from(id);
-                    //FIXME: expand recursively
-                    for item in db.hir_parse(file_id).items() {
-                        self.add_def_id(source_map, db, module, file_id, item);
-                    }
-                }
-            }
-        }
-    }
-    fn add_def_id(
-        &mut self,
-        source_map: &mut ImportSourceMap,
-        db: &impl PersistentHirDatabase,
-        module: Module,
-        file_id: HirFileId,
-        item: &ast::ModuleItem,
-    ) {
-        let ctx = LocationCtx::new(db, module, file_id);
-        match item.kind() {
-            ast::ModuleItemKind::StructDef(it) => {
-                if let Some(name) = it.name() {
-                    let s = Struct { id: ctx.to_def(it) };
-                    let s: ModuleDef = s.into();
-                    self.declarations.insert(name.as_name(), PerNs::both(s, s));
-                }
-            }
-            ast::ModuleItemKind::EnumDef(it) => {
-                if let Some(name) = it.name() {
-                    let e = Enum { id: ctx.to_def(it) };
-                    let e: ModuleDef = e.into();
-                    self.declarations.insert(name.as_name(), PerNs::types(e));
-                }
-            }
-            ast::ModuleItemKind::FnDef(it) => {
-                if let Some(name) = it.name() {
-                    let func = Function { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(func.into()));
-                }
-            }
-            ast::ModuleItemKind::TraitDef(it) => {
-                if let Some(name) = it.name() {
-                    let t = Trait { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::types(t.into()));
-                }
-            }
-            ast::ModuleItemKind::TypeAliasDef(it) => {
-                if let Some(name) = it.name() {
-                    let t = TypeAlias { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::types(t.into()));
-                }
-            }
-            ast::ModuleItemKind::ImplBlock(_) => {
-                // impls don't define items
-            }
-            ast::ModuleItemKind::UseItem(it) => {
-                self.add_use_item(source_map, it);
-            }
-            ast::ModuleItemKind::ExternCrateItem(it) => {
-                if let Some(name_ref) = it.name_ref() {
-                    let path = Path::from_name_ref(name_ref);
-                    let alias = it.alias().and_then(|a| a.name()).map(AsName::as_name);
-                    self.imports.alloc(ImportData {
-                        path,
-                        alias,
-                        is_glob: false,
-                        is_prelude: false,
-                        is_extern_crate: true,
-                    });
-                }
-            }
-            ast::ModuleItemKind::ConstDef(it) => {
-                if let Some(name) = it.name() {
-                    let c = Const { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(c.into()));
-                }
-            }
-            ast::ModuleItemKind::StaticDef(it) => {
-                if let Some(name) = it.name() {
-                    let s = Static { id: ctx.to_def(it) };
-                    self.declarations.insert(name.as_name(), PerNs::values(s.into()));
-                }
-            }
-            ast::ModuleItemKind::Module(_) => {
-                // modules are handled separately directly by name res
-            }
-        };
-    }
-    fn add_use_item(&mut self, source_map: &mut ImportSourceMap, item: &ast::UseItem) {
-        let is_prelude =
-            item.attrs().any(|attr| attr.as_atom().map(|s| s == "prelude_import").unwrap_or(false));
-        Path::expand_use_item(item, |path, segment, alias| {
-            let import = self.imports.alloc(ImportData {
-                path,
-                alias,
-                is_glob: segment.is_none(),
-                is_prelude,
-                is_extern_crate: false,
-            });
-            if let Some(segment) = segment {
-                source_map.insert(import, segment)
-            }
-        })
-    }
-}
diff --git a/crates/ra_hir/src/nameres/per_ns.rs b/crates/ra_hir/src/nameres/per_ns.rs
new file mode 100644
index 000000000..c40a3ff9d
--- /dev/null
+++ b/crates/ra_hir/src/nameres/per_ns.rs
@@ -0,0 +1,78 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Namespace {
+    Types,
+    Values,
+}
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct PerNs<T> {
+    pub types: Option<T>,
+    pub values: Option<T>,
+}
+impl<T> Default for PerNs<T> {
+    fn default() -> Self {
+        PerNs { types: None, values: None }
+    }
+}
+impl<T> PerNs<T> {
+    pub fn none() -> PerNs<T> {
+        PerNs { types: None, values: None }
+    }
+    pub fn values(t: T) -> PerNs<T> {
+        PerNs { types: None, values: Some(t) }
+    }
+    pub fn types(t: T) -> PerNs<T> {
+        PerNs { types: Some(t), values: None }
+    }
+    pub fn both(types: T, values: T) -> PerNs<T> {
+        PerNs { types: Some(types), values: Some(values) }
+    }
+    pub fn is_none(&self) -> bool {
+        self.types.is_none() && self.values.is_none()
+    }
+    pub fn is_both(&self) -> bool {
+        self.types.is_some() && self.values.is_some()
+    }
+    pub fn take(self, namespace: Namespace) -> Option<T> {
+        match namespace {
+            Namespace::Types => self.types,
+            Namespace::Values => self.values,
+        }
+    }
+    pub fn take_types(self) -> Option<T> {
+        self.take(Namespace::Types)
+    }
+    pub fn take_values(self) -> Option<T> {
+        self.take(Namespace::Values)
+    }
+    pub fn get(&self, namespace: Namespace) -> Option<&T> {
+        self.as_ref().take(namespace)
+    }
+    pub fn as_ref(&self) -> PerNs<&T> {
+        PerNs { types: self.types.as_ref(), values: self.values.as_ref() }
+    }
+    pub fn or(self, other: PerNs<T>) -> PerNs<T> {
+        PerNs { types: self.types.or(other.types), values: self.values.or(other.values) }
+    }
+    pub fn and_then<U>(self, f: impl Fn(T) -> Option<U>) -> PerNs<U> {
+        PerNs { types: self.types.and_then(&f), values: self.values.and_then(&f) }
+    }
+    pub fn map<U>(self, f: impl Fn(T) -> U) -> PerNs<U> {
+        PerNs { types: self.types.map(&f), values: self.values.map(&f) }
+    }
+}
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
new file mode 100644
index 000000000..3226bbf0d
--- /dev/null
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -0,0 +1,322 @@
+use std::{
+    sync::Arc,
+    ops::Index,
+};
+use test_utils::tested_by;
+use ra_db::FileId;
+use ra_arena::{Arena, impl_arena_id, RawId, map::ArenaMap};
+use ra_syntax::{
+    AstNode, SourceFile, AstPtr, TreeArc,
+    ast::{self, NameOwner, AttrsOwner},
+};
+use crate::{
+    PersistentHirDatabase, Name, AsName, Path, HirFileId, ModuleSource,
+    ids::{SourceFileItemId, SourceFileItems},
+};
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct RawItems {
+    modules: Arena<Module, ModuleData>,
+    imports: Arena<ImportId, ImportData>,
+    defs: Arena<Def, DefData>,
+    macros: Arena<Macro, MacroData>,
+    /// items for top-level module
+    items: Vec<RawItem>,
+}
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ImportSourceMap {
+    map: ArenaMap<ImportId, AstPtr<ast::PathSegment>>,
+}
+impl ImportSourceMap {
+    pub(crate) fn insert(&mut self, import: ImportId, segment: &ast::PathSegment) {
+        self.map.insert(import, AstPtr::new(segment))
+    }
+    pub fn get(&self, source: &ModuleSource, import: ImportId) -> TreeArc<ast::PathSegment> {
+        let file = match source {
+            ModuleSource::SourceFile(file) => &*file,
+            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
+        };
+        self.map[import].to_node(file).to_owned()
+    }
+}
+impl RawItems {
+    pub(crate) fn raw_items_query(
+        db: &impl PersistentHirDatabase,
+        file_id: FileId,
+    ) -> Arc<RawItems> {
+        db.raw_items_with_source_map(file_id).0
+    }
+    pub(crate) fn raw_items_with_source_map_query(
+        db: &impl PersistentHirDatabase,
+        file_id: FileId,
+    ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
+        let mut collector = RawItemsCollector {
+            raw_items: RawItems::default(),
+            source_file_items: db.file_items(file_id.into()),
+            source_map: ImportSourceMap::default(),
+        };
+        let source_file = db.parse(file_id);
+        collector.process_module(None, &*source_file);
+        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
+    }
+    pub(crate) fn items(&self) -> &[RawItem] {
+        &self.items
+    }
+    // We can't use queries during name resolution for fear of cycles, so this
+    // is a query-less variant of the above function.
+    pub(crate) fn from_source_file(source_file: &SourceFile, file_id: HirFileId) -> RawItems {
+        let source_file_items = SourceFileItems::from_source_file(source_file, file_id);
+        let mut collector = RawItemsCollector {
+            raw_items: RawItems::default(),
+            source_file_items: Arc::new(source_file_items),
+            source_map: ImportSourceMap::default(),
+        };
+        collector.process_module(None, &*source_file);
+        collector.raw_items
+    }
+}
+impl Index<Module> for RawItems {
+    type Output = ModuleData;
+    fn index(&self, idx: Module) -> &ModuleData {
+        &self.modules[idx]
+    }
+}
+impl Index<ImportId> for RawItems {
+    type Output = ImportData;
+    fn index(&self, idx: ImportId) -> &ImportData {
+        &self.imports[idx]
+    }
+}
+impl Index<Def> for RawItems {
+    type Output = DefData;
+    fn index(&self, idx: Def) -> &DefData {
+        &self.defs[idx]
+    }
+}
+impl Index<Macro> for RawItems {
+    type Output = MacroData;
+    fn index(&self, idx: Macro) -> &MacroData {
+        &self.macros[idx]
+    }
+}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(crate) enum RawItem {
+    Module(Module),
+    Import(ImportId),
+    Def(Def),
+    Macro(Macro),
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Module(RawId);
+impl_arena_id!(Module);
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum ModuleData {
+    Declaration { name: Name, source_item_id: SourceFileItemId },
+    Definition { name: Name, source_item_id: SourceFileItemId, items: Vec<RawItem> },
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ImportId(RawId);
+impl_arena_id!(ImportId);
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportData {
+    pub(crate) path: Path,
+    pub(crate) alias: Option<Name>,
+    pub(crate) is_glob: bool,
+    pub(crate) is_prelude: bool,
+    pub(crate) is_extern_crate: bool,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Def(RawId);
+impl_arena_id!(Def);
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct DefData {
+    pub(crate) source_item_id: SourceFileItemId,
+    pub(crate) name: Name,
+    pub(crate) kind: DefKind,
+}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(crate) enum DefKind {
+    Function,
+    Struct,
+    Enum,
+    Const,
+    Static,
+    Trait,
+    TypeAlias,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) struct Macro(RawId);
+impl_arena_id!(Macro);
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct MacroData {
+    pub(crate) source_item_id: SourceFileItemId,
+    pub(crate) path: Path,
+    pub(crate) name: Option<Name>,
+    pub(crate) arg: tt::Subtree,
+    pub(crate) export: bool,
+}
+struct RawItemsCollector {
+    raw_items: RawItems,
+    source_file_items: Arc<SourceFileItems>,
+    source_map: ImportSourceMap,
+}
+impl RawItemsCollector {
+    fn process_module(&mut self, current_module: Option<Module>, body: &impl ast::ModuleItemOwner) {
+        for item_or_macro in body.items_with_macros() {
+            match item_or_macro {
+                ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m),
+                ast::ItemOrMacro::Item(item) => self.add_item(current_module, item),
+            }
+        }
+    }
+    fn add_item(&mut self, current_module: Option<Module>, item: &ast::ModuleItem) {
+        let (kind, name) = match item.kind() {
+            ast::ModuleItemKind::Module(module) => {
+                self.add_module(current_module, module);
+                return;
+            }
+            ast::ModuleItemKind::UseItem(use_item) => {
+                self.add_use_item(current_module, use_item);
+                return;
+            }
+            ast::ModuleItemKind::ExternCrateItem(extern_crate) => {
+                self.add_extern_crate_item(current_module, extern_crate);
+                return;
+            }
+            ast::ModuleItemKind::ImplBlock(_) => {
+                // impls don't participate in name resolution
+                return;
+            }
+            ast::ModuleItemKind::StructDef(it) => (DefKind::Struct, it.name()),
+            ast::ModuleItemKind::EnumDef(it) => (DefKind::Enum, it.name()),
+            ast::ModuleItemKind::FnDef(it) => (DefKind::Function, it.name()),
+            ast::ModuleItemKind::TraitDef(it) => (DefKind::Trait, it.name()),
+            ast::ModuleItemKind::TypeAliasDef(it) => (DefKind::TypeAlias, it.name()),
+            ast::ModuleItemKind::ConstDef(it) => (DefKind::Const, it.name()),
+            ast::ModuleItemKind::StaticDef(it) => (DefKind::Static, it.name()),
+        };
+        if let Some(name) = name {
+            let name = name.as_name();
+            let source_item_id = self.source_file_items.id_of_unchecked(item.syntax());
+            let def = self.raw_items.defs.alloc(DefData { name, kind, source_item_id });
+            self.push_item(current_module, RawItem::Def(def))
+        }
+    }
+    fn add_module(&mut self, current_module: Option<Module>, module: &ast::Module) {
+        let name = match module.name() {
+            Some(it) => it.as_name(),
+            None => return,
+        };
+        let source_item_id = self.source_file_items.id_of_unchecked(module.syntax());
+        if module.has_semi() {
+            let item =
+                self.raw_items.modules.alloc(ModuleData::Declaration { name, source_item_id });
+            self.push_item(current_module, RawItem::Module(item));
+            return;
+        }
+        if let Some(item_list) = module.item_list() {
+            let item = self.raw_items.modules.alloc(ModuleData::Definition {
+                name,
+                source_item_id,
+                items: Vec::new(),
+            });
+            self.process_module(Some(item), item_list);
+            self.push_item(current_module, RawItem::Module(item));
+            return;
+        }
+        tested_by!(name_res_works_for_broken_modules);
+    }
+    fn add_use_item(&mut self, current_module: Option<Module>, use_item: &ast::UseItem) {
+        let is_prelude = use_item.has_atom_attr("prelude_import");
+        Path::expand_use_item(use_item, |path, segment, alias| {
+            let import = self.raw_items.imports.alloc(ImportData {
+                path,
+                alias,
+                is_glob: segment.is_none(),
+                is_prelude,
+                is_extern_crate: false,
+            });
+            if let Some(segment) = segment {
+                self.source_map.insert(import, segment)
+            }
+            self.push_item(current_module, RawItem::Import(import))
+        })
+    }
+    fn add_extern_crate_item(
+        &mut self,
+        current_module: Option<Module>,
+        extern_crate: &ast::ExternCrateItem,
+    ) {
+        if let Some(name_ref) = extern_crate.name_ref() {
+            let path = Path::from_name_ref(name_ref);
+            let alias = extern_crate.alias().and_then(|a| a.name()).map(AsName::as_name);
+            let import = self.raw_items.imports.alloc(ImportData {
+                path,
+                alias,
+                is_glob: false,
+                is_prelude: false,
+                is_extern_crate: true,
+            });
+            self.push_item(current_module, RawItem::Import(import))
+        }
+    }
+    fn add_macro(&mut self, current_module: Option<Module>, m: &ast::MacroCall) {
+        let (path, arg) = match (
+            m.path().and_then(Path::from_ast),
+            m.token_tree().and_then(mbe::ast_to_token_tree),
+        ) {
+            (Some(path), Some((token_tree, _token_map))) => (path, token_tree),
+            _ => return,
+        };
+        let name = m.name().map(|it| it.as_name());
+        let source_item_id = self.source_file_items.id_of_unchecked(m.syntax());
+        let export = m.has_atom_attr("macro_export");
+        let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, arg, name, export });
+        self.push_item(current_module, RawItem::Macro(m));
+    }
+    fn push_item(&mut self, current_module: Option<Module>, item: RawItem) {
+        match current_module {
+            Some(module) => match &mut self.raw_items.modules[module] {
+                ModuleData::Definition { items, .. } => items,
+                ModuleData::Declaration { .. } => unreachable!(),
+            },
+            None => &mut self.raw_items.items,
+        }
+        .push(item)
+    }
+}
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 9b151bb0c..ac9b88520 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -1,34 +1,43 @@
+mod macros;
+mod globs;
+mod incremental;
 use std::sync::Arc;
 use ra_db::SourceDatabase;
-use test_utils::{assert_eq_text, covers};
+use test_utils::covers;
+use insta::assert_snapshot_matches;
-use crate::{
-    ItemMap,
+use crate::{Crate, mock::{MockDatabase, CrateGraphFixture}, nameres::Resolution};
-    PersistentHirDatabase,
-    mock::MockDatabase,
+use super::*;
-    module_tree::ModuleId,
-};
+fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> {
-use super::Resolution;
+    let mut db = MockDatabase::with_files(fixture);
+    if let Some(graph) = graph {
-fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
+        db.set_crate_graph_from_fixture(graph);
-    let (db, pos) = MockDatabase::with_position(fixture);
+    }
-    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
+    let crate_id = db.crate_graph().iter().next().unwrap();
-    let krate = module.krate(&db).unwrap();
+    let krate = Crate { crate_id };
-    let module_id = module.module_id;
+    db.crate_def_map(krate)
-    (db.item_map(krate), module_id)
 }
-fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
+fn render_crate_def_map(map: &CrateDefMap) -> String {
-    let mut lines = map[module_id]
+    let mut buf = String::new();
-        .items
+    go(&mut buf, map, "\ncrate", map.root);
-        .iter()
+    return buf;
-        .map(|(name, res)| format!("{}: {}", name, dump_resolution(res)))
-        .collect::<Vec<_>>();
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
-    lines.sort();
+        *buf += path;
-    let actual = lines.join("\n");
+        *buf += "\n";
-    let expected = expected.trim().lines().map(|it| it.trim()).collect::<Vec<_>>().join("\n");
+        for (name, res) in map.modules[module].scope.items.iter() {
-    assert_eq_text!(&expected, &actual);
+            *buf += &format!("{}: {}\n", name, dump_resolution(res))
+        }
+        for (name, child) in map.modules[module].children.iter() {
+            let path = path.to_string() + &format!("::{}", name);
+            go(buf, map, &path, *child);
+        }
+    }
    fn dump_resolution(resolution: &Resolution) -> &'static str {
        match (resolution.def.types.is_some(), resolution.def.values.is_some()) {
@@ -40,66 +49,112 @@ fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
    }
 }
+fn def_map(fixtute: &str) -> String {
+    let dm = compute_crate_def_map(fixtute, None);
+    render_crate_def_map(&dm)
+}
+fn def_map_with_crate_graph(fixtute: &str, graph: CrateGraphFixture) -> String {
+    let dm = compute_crate_def_map(fixtute, Some(graph));
+    render_crate_def_map(&dm)
+}
 #[test]
-fn item_map_smoke_test() {
+fn crate_def_map_smoke_test() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
        "
        //- /lib.rs
        mod foo;
+        struct S;
-        use crate::foo::bar::Baz;
+        use crate::foo::bar::E;
-        <|>
+        use self::E::V;
        //- /foo/mod.rs
        pub mod bar;
+        fn f() {}
        //- /foo/bar.rs
        pub struct Baz;
-    ",
+        enum E { V }
+        ",
    );
-    check_module_item_map(
+    assert_snapshot_matches!(map, @r###"
-        &item_map,
+crate
-        module_id,
+V: t v
+E: t
+foo: t
+S: t v
+crate::foo
+bar: t
+f: v
+crate::foo::bar
+Baz: t v
+E: t
+"###
+    )
+}
+#[test]
+fn bogus_paths() {
+    covers!(bogus_paths);
+    let map = def_map(
        "
-            Baz: t v
+        //- /lib.rs
-            foo: t
+        mod foo;
+        struct S;
+        use self;
+        //- /foo/mod.rs
+        use super;
+        use crate;
        ",
    );
+    assert_snapshot_matches!(map, @r###"
+crate
+foo: t
+S: t v
+crate::foo
+"###
+    )
 }
 #[test]
 fn use_as() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
        "
        //- /lib.rs
        mod foo;
        use crate::foo::Baz as Foo;
-        <|>
        //- /foo/mod.rs
        pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Foo: t v
-            foo: t
        ",
    );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Foo: t v
+foo: t
+crate::foo
+Baz: t v
+"###
+    );
 }
 #[test]
 fn use_trees() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
        "
        //- /lib.rs
        mod foo;
        use crate::foo::bar::{Baz, Quux};
-        <|>
        //- /foo/mod.rs
        pub mod bar;
@@ -107,28 +162,33 @@ fn use_trees() {
        //- /foo/bar.rs
        pub struct Baz;
        pub enum Quux {};
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Quux: t
-            foo: t
        ",
    );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Quux: t
+Baz: t v
+foo: t
+crate::foo
+bar: t
+crate::foo::bar
+Quux: t
+Baz: t v
+"###
+    );
 }
 #[test]
 fn re_exports() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
        "
        //- /lib.rs
        mod foo;
        use self::foo::Baz;
-        <|>
        //- /foo/mod.rs
        pub mod bar;
@@ -137,137 +197,73 @@ fn re_exports() {
        //- /foo/bar.rs
        pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
        ",
    );
-}
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+foo: t
-#[test]
+crate::foo
-fn glob_1() {
+bar: t
-    let (item_map, module_id) = item_map(
+Baz: t v
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        <|>
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::Baz;
-        pub struct Foo;
-        //- /foo/bar.rs
+crate::foo::bar
-        pub struct Baz;
+Baz: t v
-    ",
+"###
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Foo: t v
-            bar: t
-            foo: t
-        ",
    );
 }
 #[test]
-fn glob_2() {
+fn std_prelude() {
-    let (item_map, module_id) = item_map(
+    covers!(std_prelude);
-        "
+    let map = def_map_with_crate_graph(
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        <|>
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::*;
-        pub struct Foo;
-        //- /foo/bar.rs
-        pub struct Baz;
-        pub use super::*;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
        "
-            Baz: t v
+        //- /main.rs
-            Foo: t v
+        use Foo::*;
-            bar: t
-            foo: t
-        ",
-    );
-}
-#[test]
-fn glob_enum() {
-    covers!(glob_enum);
-    let (item_map, module_id) = item_map(
-        "
        //- /lib.rs
-        enum Foo {
+        mod prelude;
-            Bar, Baz
+        #[prelude_import]
-        }
+        use prelude::*;
-        use self::Foo::*;
-        <|>
+        //- /prelude.rs
-    ",
+        pub enum Foo { Bar, Baz };
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Bar: t v
-            Baz: t v
-            Foo: t
        ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
    );
+    assert_snapshot_matches!(map, @r###"
+crate
+Bar: t v
+Baz: t v
+"###);
 }
 #[test]
-fn glob_across_crates() {
+fn can_import_enum_variant() {
-    covers!(glob_across_crates);
+    covers!(can_import_enum_variant);
-    let mut db = MockDatabase::with_files(
+    let map = def_map(
        "
-        //- /main.rs
-        use test_crate::*;
        //- /lib.rs
-        pub struct Baz;
+        enum E { V }
+        use self::E::V;
        ",
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
+    assert_snapshot_matches!(map, @r###"
-        "main": ("/main.rs", ["test_crate"]),
+crate
-        "test_crate": ("/lib.rs", []),
+V: t v
-    });
+E: t
-    let main_id = db.file_id_of("/main.rs");
+"###
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Baz: t v
-        ",
    );
 }
 #[test]
 fn edition_2015_imports() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        mod foo;
@@ -282,31 +278,32 @@ fn edition_2015_imports() {
        //- /lib.rs
        struct FromLib;
-    ",
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["other_crate"]),
-        "other_crate": ("/lib.rs", "2018", []),
-    });
-    let foo_id = db.file_id_of("/foo.rs");
-    let module = crate::source_binder::module_from_file_id(&db, foo_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            FromLib: t v
        ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["other_crate"]),
+            "other_crate": ("/lib.rs", "2018", []),
+        },
+    );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+bar: t
+foo: t
+crate::bar
+Bar: t v
+crate::foo
+FromLib: t v
+Bar: t v
+"###
    );
 }
 #[test]
 fn module_resolution_works_for_non_standard_filenames() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /my_library.rs
        mod foo;
@@ -315,73 +312,32 @@ fn module_resolution_works_for_non_standard_filenames() {
        //- /foo/mod.rs
        pub struct Bar;
        ",
+        crate_graph! {
+            "my_library": ("/my_library.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "my_library": ("/my_library.rs", []),
-    });
-    let file_id = db.file_id_of("/my_library.rs");
-    let module = crate::source_binder::module_from_file_id(&db, file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let module_id = module.module_id;
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-        Bar: t v
-        foo: t
-        ",
-    );
-}
-#[test]
+    assert_snapshot_matches!(map,
-fn std_prelude() {
+        @r###"
-    covers!(std_prelude);
+crate
-    let mut db = MockDatabase::with_files(
+Bar: t v
-        "
+foo: t
-        //- /main.rs
-        use Foo::*;
-        //- /lib.rs
-        mod prelude;
-        #[prelude_import]
-        use prelude::*;
-        //- /prelude.rs
+crate::foo
-        pub enum Foo { Bar, Baz };
+Bar: t v
-    ",
+"###
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            Baz: t v
-        ",
    );
 }
 #[test]
 fn name_res_works_for_broken_modules() {
    covers!(name_res_works_for_broken_modules);
-    let (item_map, module_id) = item_map(
+    let map = def_map(
        "
        //- /lib.rs
        mod foo // no `;`, no body
        use self::foo::Baz;
-        <|>
        //- /foo/mod.rs
        pub mod bar;
@@ -390,65 +346,47 @@ fn name_res_works_for_broken_modules() {
        //- /foo/bar.rs
        pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: _
        ",
    );
-}
+    assert_snapshot_matches!(map,
+        @r###"
-#[test]
+crate
-fn item_map_using_self() {
+Baz: _
-    let (item_map, module_id) = item_map(
+"###
-        "
-            //- /lib.rs
-            mod foo;
-            use crate::foo::bar::Baz::{self};
-            <|>
-            //- /foo/mod.rs
-            pub mod bar;
-            //- /foo/bar.rs
-            pub struct Baz;
-        ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
-        ",
    );
 }
 #[test]
-fn item_map_enum_importing() {
+fn item_map_using_self() {
-    covers!(item_map_enum_importing);
+    let map = def_map(
-    let (item_map, module_id) = item_map(
        "
        //- /lib.rs
-        enum E { V }
+        mod foo;
-        use self::E::V;
+        use crate::foo::bar::Baz::{self};
-        <|>
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
        ",
    );
-    check_module_item_map(
+    assert_snapshot_matches!(map,
-        &item_map,
+        @r###"
-        module_id,
+crate
-        "
+Baz: t v
-        E: t
+foo: t
-        V: t v
-        ",
+crate::foo
+bar: t
+crate::foo::bar
+Baz: t v
+"###
    );
 }
 #[test]
 fn item_map_across_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        use test_crate::Baz;
@@ -456,29 +394,23 @@ fn item_map_across_crates() {
        //- /lib.rs
        pub struct Baz;
        ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
+    assert_snapshot_matches!(map,
-        "test_crate": ("/lib.rs", []),
+        @r###"
-    });
+crate
-    let main_id = db.file_id_of("/main.rs");
+Baz: t v
+"###
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
    );
 }
 #[test]
 fn extern_crate_rename() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        extern crate alloc as alloc_crate;
@@ -492,29 +424,23 @@ fn extern_crate_rename() {
        //- /lib.rs
        struct Arc;
        ",
+        crate_graph! {
+            "main": ("/main.rs", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["alloc"]),
+    assert_snapshot_matches!(map,
-        "alloc": ("/lib.rs", []),
+        @r###"
-    });
+crate
-    let sync_id = db.file_id_of("/sync.rs");
+Arc: t v
+"###
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
    );
 }
 #[test]
 fn extern_crate_rename_2015_edition() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        extern crate alloc as alloc_crate;
@@ -528,29 +454,23 @@ fn extern_crate_rename_2015_edition() {
        //- /lib.rs
        struct Arc;
        ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["alloc"]),
+    assert_snapshot_matches!(map,
-        "alloc": ("/lib.rs", []),
+        @r###"
-    });
+crate
-    let sync_id = db.file_id_of("/sync.rs");
+Arc: t v
+"###
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
    );
 }
 #[test]
 fn import_across_source_roots() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /lib.rs
        pub mod a {
@@ -564,29 +484,23 @@ fn import_across_source_roots() {
        //- /main/main.rs
        use test_crate::a::b::C;
        ",
+        crate_graph! {
+            "main": ("/main/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main/main.rs", ["test_crate"]),
+    assert_snapshot_matches!(map,
-        "test_crate": ("/lib.rs", []),
+        @r###"
-    });
+crate
-    let main_id = db.file_id_of("/main/main.rs");
+C: t v
+"###
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            C: t v
-        ",
    );
 }
 #[test]
 fn reexport_across_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        use test_crate::Baz;
@@ -599,29 +513,23 @@ fn reexport_across_crates() {
        //- /foo.rs
        pub struct Baz;
        ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
+    assert_snapshot_matches!(map,
-        "test_crate": ("/lib.rs", []),
+        @r###"
-    });
+crate
-    let main_id = db.file_id_of("/main.rs");
+Baz: t v
+"###
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
    );
 }
 #[test]
 fn values_dont_shadow_extern_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
        "
        //- /main.rs
        fn foo() {}
@@ -630,139 +538,17 @@ fn values_dont_shadow_extern_crates() {
        //- /foo/lib.rs
        pub struct Bar;
        ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/foo/lib.rs", []),
+        },
    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["foo"]),
-        "foo": ("/foo/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Bar: t v
-        foo: v
-        ",
-    );
-}
-fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
-    let (mut db, pos) = MockDatabase::with_position(initial);
-    let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(format!("{:?}", events).contains("item_map"))
-    }
-    db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(!format!("{:?}", events).contains("item_map"), "{:#?}", events)
-    }
-}
-#[test]
-fn typing_inside_a_function_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        mod foo;<|>
-        use crate::foo::bar::Baz;
-        fn foo() -> i32 {
-            1 + 1
-        }
-        //- /foo/mod.rs
-        pub mod bar;
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        mod foo;
-        use crate::foo::bar::Baz;
-        fn foo() -> i32 { 92 }
-        ",
-    );
-}
-#[test]
-fn adding_inner_items_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        struct S { a: i32}
-        enum E { A }
-        trait T {
-            fn a() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-        }
-        use crate::foo::bar::Baz;
-        //- /foo/mod.rs
-        pub mod bar;
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        struct S { a: i32, b: () }
-        enum E { A, B }
-        trait T {
-            fn a() {}
-            fn b() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-            fn b() {}
-        }
-        use crate::foo::bar::Baz;
-        ",
-    );
-}
-#[test]
+    assert_snapshot_matches!(map,
-fn typing_inside_a_function_inside_a_macro_should_not_invalidate_item_map() {
+        @r###"
-    check_item_map_is_not_recomputed(
+crate
-        "
+Bar: t v
-        //- /lib.rs
+foo: v
-        mod foo;
+"###
-        use crate::foo::bar::Baz;
-        //- /foo/mod.rs
-        pub mod bar;
-        //- /foo/bar.rs
-        <|>
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 1 + 1 }
-            }
-        }
-        ",
-        "
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 92 }
-            }
-        }
-        ",
    );
 }
diff --git a/crates/ra_hir/src/nameres/tests/globs.rs b/crates/ra_hir/src/nameres/tests/globs.rs
new file mode 100644
index 000000000..6e50c7ff6
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/globs.rs
@@ -0,0 +1,118 @@
+use super::*;
+#[test]
+fn glob_1() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::Baz;
+        pub struct Foo;
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Baz: t v
+foo: t
+crate::foo
+bar: t
+Foo: t v
+Baz: t v
+crate::foo::bar
+Baz: t v
+"###
+    );
+}
+#[test]
+fn glob_2() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod foo;
+        use foo::*;
+        //- /foo/mod.rs
+        pub mod bar;
+        pub use self::bar::*;
+        pub struct Foo;
+        //- /foo/bar.rs
+        pub struct Baz;
+        pub use super::*;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Baz: t v
+foo: t
+crate::foo
+bar: t
+Foo: t v
+Baz: t v
+crate::foo::bar
+bar: t
+Foo: t v
+Baz: t v
+"###
+    );
+}
+#[test]
+fn glob_across_crates() {
+    covers!(glob_across_crates);
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        use test_crate::*;
+        //- /lib.rs
+        pub struct Baz;
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+Baz: t v
+"###
+    );
+}
+#[test]
+fn glob_enum() {
+    covers!(glob_enum);
+    let map = def_map(
+        "
+        //- /lib.rs
+        enum Foo {
+            Bar, Baz
+        }
+        use self::Foo::*;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+Foo: t
+Bar: t v
+Baz: t v
+"###
+    );
+}
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
new file mode 100644
index 000000000..698781923
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -0,0 +1,123 @@
+use super::*;
+use std::sync::Arc;
+use ra_db::SourceDatabase;
+fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
+    let (mut db, pos) = MockDatabase::with_position(initial);
+    let crate_id = db.crate_graph().iter().next().unwrap();
+    let krate = Crate { crate_id };
+    {
+        let events = db.log_executed(|| {
+            db.crate_def_map(krate);
+        });
+        assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+    db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
+    {
+        let events = db.log_executed(|| {
+            db.crate_def_map(krate);
+        });
+        assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events)
+    }
+}
+#[test]
+fn typing_inside_a_function_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        mod foo;<|>
+        use crate::foo::bar::Baz;
+        fn foo() -> i32 {
+            1 + 1
+        }
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+        "
+        mod foo;
+        use crate::foo::bar::Baz;
+        fn foo() -> i32 { 92 }
+        ",
+    );
+}
+#[test]
+fn adding_inner_items_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        struct S { a: i32}
+        enum E { A }
+        trait T {
+            fn a() {}
+        }
+        mod foo;<|>
+        impl S {
+            fn a() {}
+        }
+        use crate::foo::bar::Baz;
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
+        ",
+        "
+        struct S { a: i32, b: () }
+        enum E { A, B }
+        trait T {
+            fn a() {}
+            fn b() {}
+        }
+        mod foo;<|>
+        impl S {
+            fn a() {}
+            fn b() {}
+        }
+        use crate::foo::bar::Baz;
+        ",
+    );
+}
+// It would be awesome to make this work, but it's unclear how
+#[test]
+#[ignore]
+fn typing_inside_a_function_inside_a_macro_should_not_invalidate_def_map() {
+    check_def_map_is_not_recomputed(
+        "
+        //- /lib.rs
+        mod foo;
+        use crate::foo::bar::Baz;
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        <|>
+        salsa::query_group! {
+            trait Baz {
+                fn foo() -> i32 { 1 + 1 }
+            }
+        }
+        ",
+        "
+        salsa::query_group! {
+            trait Baz {
+                fn foo() -> i32 { 92 }
+            }
+        }
+        ",
+    );
+}
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
new file mode 100644
index 000000000..8781b026b
--- /dev/null
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -0,0 +1,94 @@
+use super::*;
+#[test]
+fn macro_rules_are_globally_visible() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        structs!(Foo);
+        mod nested;
+        //- /nested.rs
+        structs!(Bar, Baz);
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+nested: t
+Foo: t v
+crate::nested
+Bar: t v
+Baz: t v
+"###);
+}
+#[test]
+fn macro_rules_can_define_modules() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        macro_rules! m {
+            ($name:ident) => { mod $name;  }
+        }
+        m!(n1);
+        //- /n1.rs
+        m!(n2)
+        //- /n1/n2.rs
+        struct X;
+        ",
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+n1: t
+crate::n1
+n2: t
+crate::n1::n2
+X: t v
+"###);
+}
+#[test]
+fn macro_rules_from_other_crates_are_visible() {
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        foo::structs!(Foo, Bar)
+        mod bar;
+        //- /bar.rs
+        use crate::*;
+        //- /lib.rs
+        #[macro_export]
+        macro_rules! structs {
+            ($($i:ident),*) => {
+                $(struct $i { field: u32 } )*
+            }
+        }
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot_matches!(map, @r###"
+crate
+bar: t
+Foo: t v
+Bar: t v
+crate::bar
+bar: t
+Foo: t v
+Bar: t v
+"###);
+}
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 57e7d0b9a..59af4ec60 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -4,10 +4,10 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 use crate::{
-    ModuleDef, Module,
+    ModuleDef,
    db::HirDatabase,
    name::{Name, KnownName},
-    nameres::{PerNs, ItemMap},
+    nameres::{PerNs, CrateDefMap, CrateModuleId},
    generics::GenericParams,
    expr::{scope::{ExprScopes, ScopeId}, PatId, Body},
    impl_block::ImplBlock,
@@ -22,8 +22,8 @@ pub struct Resolver {
 // TODO how to store these best
 #[derive(Debug, Clone)]
 pub(crate) struct ModuleItemMap {
-    item_map: Arc<ItemMap>,
+    crate_def_map: Arc<CrateDefMap>,
-    module: Module,
+    module_id: CrateModuleId,
 }
 #[derive(Debug, Clone)]
@@ -175,9 +175,9 @@ impl Resolver {
        names
    }
-    fn module(&self) -> Option<(&ItemMap, Module)> {
+    fn module(&self) -> Option<(&CrateDefMap, CrateModuleId)> {
        self.scopes.iter().rev().find_map(|scope| match scope {
-            Scope::ModuleScope(m) => Some((&*m.item_map, m.module.clone())),
+            Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
            _ => None,
        })
@@ -206,8 +206,12 @@ impl Resolver {
        self.push_scope(Scope::ImplBlockScope(impl_block))
    }
-    pub(crate) fn push_module_scope(self, item_map: Arc<ItemMap>, module: Module) -> Resolver {
+    pub(crate) fn push_module_scope(
-        self.push_scope(Scope::ModuleScope(ModuleItemMap { item_map, module }))
+        self,
+        crate_def_map: Arc<CrateDefMap>,
+        module_id: CrateModuleId,
+    ) -> Resolver {
+        self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
    }
    pub(crate) fn push_expr_scope(
@@ -224,9 +228,11 @@ impl Scope {
        match self {
            Scope::ModuleScope(m) => {
                if let Some(KnownName::SelfParam) = name.as_known_name() {
-                    PerNs::types(Resolution::Def(m.module.into()))
+                    PerNs::types(Resolution::Def(m.crate_def_map.mk_module(m.module_id).into()))
                } else {
-                    m.item_map.resolve_name_in_module(db, m.module, name).map(Resolution::Def)
+                    m.crate_def_map
+                        .resolve_name_in_module(db, m.module_id, name)
+                        .map(Resolution::Def)
                }
            }
            Scope::GenericParams(gp) => match gp.find_by_name(name) {
@@ -261,15 +267,15 @@ impl Scope {
                //         def: m.module.into(),
                //     }),
                // );
-                m.item_map[m.module.module_id].entries().for_each(|(name, res)| {
+                m.crate_def_map[m.module_id].scope.entries().for_each(|(name, res)| {
                    f(name.clone(), res.def.map(Resolution::Def));
                });
-                m.item_map.extern_prelude.iter().for_each(|(name, def)| {
+                m.crate_def_map.extern_prelude().iter().for_each(|(name, def)| {
                    f(name.clone(), PerNs::types(Resolution::Def(*def)));
                });
-                if let Some(prelude) = m.item_map.prelude {
+                if let Some(prelude) = m.crate_def_map.prelude() {
-                    let prelude_item_map = db.item_map(prelude.krate);
+                    let prelude_def_map = db.crate_def_map(prelude.krate);
-                    prelude_item_map[prelude.module_id].entries().for_each(|(name, res)| {
+                    prelude_def_map[prelude.module_id].scope.entries().for_each(|(name, res)| {
                        f(name.clone(), res.def.map(Resolution::Def));
                    });
                }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 4a9921a85..902110913 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -7,13 +7,13 @@
 /// purely for "IDE needs".
 use ra_db::{FileId, FilePosition};
 use ra_syntax::{
-    SmolStr, TextRange, SyntaxNode,
+    SyntaxNode,
    ast::{self, AstNode, NameOwner},
    algo::{find_node_at_offset, find_leaf_at_offset},
 };
 use crate::{
-    HirDatabase, Function, ModuleDef, Struct, Enum,
+    HirDatabase, Function, Struct, Enum,
    AsName, Module, HirFileId, Crate, Trait, Resolver,
    ids::{LocationCtx, SourceFileItemId},
    expr
@@ -80,8 +80,8 @@ fn module_from_source(
    let source_root_id = db.file_source_root(file_id.as_original_file());
    db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
        |krate| {
-            let module_tree = db.module_tree(krate);
+            let def_map = db.crate_def_map(krate);
-            let module_id = module_tree.find_module_by_source(file_id, decl_id)?;
+            let module_id = def_map.find_module_by_source(file_id, decl_id)?;
            Some(Module { krate, module_id })
        },
    )
@@ -152,44 +152,6 @@ pub fn trait_from_module(
    Trait { id: ctx.to_def(trait_def) }
 }
-pub fn macro_symbols(db: &impl HirDatabase, file_id: FileId) -> Vec<(SmolStr, TextRange)> {
-    let module = match module_from_file_id(db, file_id) {
-        Some(it) => it,
-        None => return Vec::new(),
-    };
-    let items = db.lower_module(module);
-    let mut res = Vec::new();
-    for macro_call_id in items
-        .declarations
-        .iter()
-        .filter_map(|(_, it)| it.clone().take_types())
-        .filter_map(|it| match it {
-            ModuleDef::Trait(it) => Some(it),
-            _ => None,
-        })
-        .filter_map(|it| it.source(db).0.as_macro_call_id())
-    {
-        if let Some(exp) = db.expand_macro_invocation(macro_call_id) {
-            let loc = macro_call_id.loc(db);
-            let syntax = db.file_item(loc.source_item_id);
-            let macro_call = ast::MacroCall::cast(&syntax).unwrap();
-            let off = macro_call.token_tree().unwrap().syntax().range().start();
-            let file = exp.file();
-            for trait_def in file.syntax().descendants().filter_map(ast::TraitDef::cast) {
-                if let Some(name) = trait_def.name() {
-                    let dst_range = name.syntax().range();
-                    if let Some(src_range) = exp.map_range_back(dst_range) {
-                        res.push((name.text().clone(), src_range + off))
-                    }
-                }
-            }
-        }
-    }
-    res
-}
 pub fn resolver_for_position(db: &impl HirDatabase, position: FilePosition) -> Resolver {
    let file_id = position.file_id;
    let file = db.parse(file_id);
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index bad811a56..2ea3b341f 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -9,16 +9,16 @@ pub(crate) mod method_resolution;
 mod op;
 mod lower;
 mod infer;
+pub(crate) mod display;
 use std::sync::Arc;
 use std::{fmt, mem};
-use join_to_string::join;
+use crate::{Name, AdtDef, type_ref::Mutability, db::HirDatabase};
-use crate::{Name, AdtDef, type_ref::Mutability};
+pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field, callable_item_sig};
-pub(crate) use lower::{TypableDef, CallableDef, type_for_def, type_for_field};
 pub(crate) use infer::{infer, InferenceResult, InferTy};
+use display::{HirDisplay, HirFormatter};
 /// A type. This is based on the `TyKind` enum in rustc (librustc/ty/sty.rs).
 ///
@@ -42,8 +42,6 @@ pub enum Ty {
    Adt {
        /// The definition of the struct/enum.
        def_id: AdtDef,
-        /// The name, for displaying.
-        name: Name,
        /// Substitutions for the generic parameters of the type.
        substs: Substs,
    },
@@ -79,10 +77,6 @@ pub enum Ty {
    FnDef {
        /// The definition of the function / constructor.
        def: CallableDef,
-        /// For display
-        name: Name,
-        /// Parameters and return type
-        sig: Arc<FnSig>,
        /// Substitutions for the generic parameters of the type
        substs: Substs,
    },
@@ -95,7 +89,7 @@ pub enum Ty {
    /// fn foo() -> i32 { 1 }
    /// let bar: fn() -> i32 = foo;
    /// ```
-    FnPtr(Arc<FnSig>),
+    FnPtr(FnSig),
    /// The never type `!`.
    Never,
@@ -132,13 +126,44 @@ impl Substs {
    pub fn empty() -> Substs {
        Substs(Arc::new([]))
    }
+    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        let mut v: Vec<_> = self.0.iter().cloned().collect();
+        for t in &mut v {
+            t.walk_mut(f);
+        }
+        self.0 = v.into();
+    }
 }
 /// A function signature.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct FnSig {
-    input: Vec<Ty>,
+    params_and_return: Arc<[Ty]>,
-    output: Ty,
+}
+impl FnSig {
+    pub fn from_params_and_return(mut params: Vec<Ty>, ret: Ty) -> FnSig {
+        params.push(ret);
+        FnSig { params_and_return: params.into() }
+    }
+    pub fn params(&self) -> &[Ty] {
+        &self.params_and_return[0..self.params_and_return.len() - 1]
+    }
+    pub fn ret(&self) -> &Ty {
+        &self.params_and_return[self.params_and_return.len() - 1]
+    }
+    pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Ty)) {
+        // Without an Arc::make_mut_slice, we can't avoid the clone here:
+        let mut v: Vec<_> = self.params_and_return.iter().cloned().collect();
+        for t in &mut v {
+            t.walk_mut(f);
+        }
+        self.params_and_return = v.into();
+    }
 }
 impl Ty {
@@ -157,16 +182,12 @@ impl Ty {
                }
            }
            Ty::FnPtr(sig) => {
-                for input in &sig.input {
+                for input in sig.params() {
                    input.walk(f);
                }
-                sig.output.walk(f);
+                sig.ret().walk(f);
            }
-            Ty::FnDef { substs, sig, .. } => {
+            Ty::FnDef { substs, .. } => {
-                for input in &sig.input {
-                    input.walk(f);
-                }
-                sig.output.walk(f);
                for t in substs.0.iter() {
                    t.walk(f);
                }
@@ -203,32 +224,13 @@ impl Ty {
                *ts = v.into();
            }
            Ty::FnPtr(sig) => {
-                let sig_mut = Arc::make_mut(sig);
+                sig.walk_mut(f);
-                for input in &mut sig_mut.input {
-                    input.walk_mut(f);
-                }
-                sig_mut.output.walk_mut(f);
            }
-            Ty::FnDef { substs, sig, .. } => {
+            Ty::FnDef { substs, .. } => {
-                let sig_mut = Arc::make_mut(sig);
+                substs.walk_mut(f);
-                for input in &mut sig_mut.input {
-                    input.walk_mut(f);
-                }
-                sig_mut.output.walk_mut(f);
-                // Without an Arc::make_mut_slice, we can't avoid the clone here:
-                let mut v: Vec<_> = substs.0.iter().cloned().collect();
-                for t in &mut v {
-                    t.walk_mut(f);
-                }
-                substs.0 = v.into();
            }
            Ty::Adt { substs, .. } => {
-                // Without an Arc::make_mut_slice, we can't avoid the clone here:
+                substs.walk_mut(f);
-                let mut v: Vec<_> = substs.0.iter().cloned().collect();
-                for t in &mut v {
-                    t.walk_mut(f);
-                }
-                substs.0 = v.into();
            }
            Ty::Bool
            | Ty::Char
@@ -265,8 +267,8 @@ impl Ty {
    /// `Option<u32>` afterwards.)
    pub fn apply_substs(self, substs: Substs) -> Ty {
        match self {
-            Ty::Adt { def_id, name, .. } => Ty::Adt { def_id, name, substs },
+            Ty::Adt { def_id, .. } => Ty::Adt { def_id, substs },
-            Ty::FnDef { def, name, sig, .. } => Ty::FnDef { def, name, sig, substs },
+            Ty::FnDef { def, .. } => Ty::FnDef { def, substs },
            _ => self,
        }
    }
@@ -297,50 +299,81 @@ impl Ty {
    }
 }
-impl fmt::Display for Ty {
+impl HirDisplay for &Ty {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
+        HirDisplay::hir_fmt(*self, f)
+    }
+}
+impl HirDisplay for Ty {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        match self {
-            Ty::Bool => write!(f, "bool"),
+            Ty::Bool => write!(f, "bool")?,
-            Ty::Char => write!(f, "char"),
+            Ty::Char => write!(f, "char")?,
-            Ty::Int(t) => write!(f, "{}", t.ty_to_string()),
+            Ty::Int(t) => write!(f, "{}", t)?,
-            Ty::Float(t) => write!(f, "{}", t.ty_to_string()),
+            Ty::Float(t) => write!(f, "{}", t)?,
-            Ty::Str => write!(f, "str"),
+            Ty::Str => write!(f, "str")?,
-            Ty::Slice(t) | Ty::Array(t) => write!(f, "[{}]", t),
+            Ty::Slice(t) | Ty::Array(t) => {
-            Ty::RawPtr(t, m) => write!(f, "*{}{}", m.as_keyword_for_ptr(), t),
+                write!(f, "[{}]", t.display(f.db))?;
-            Ty::Ref(t, m) => write!(f, "&{}{}", m.as_keyword_for_ref(), t),
+            }
-            Ty::Never => write!(f, "!"),
+            Ty::RawPtr(t, m) => {
+                write!(f, "*{}{}", m.as_keyword_for_ptr(), t.display(f.db))?;
+            }
+            Ty::Ref(t, m) => {
+                write!(f, "&{}{}", m.as_keyword_for_ref(), t.display(f.db))?;
+            }
+            Ty::Never => write!(f, "!")?,
            Ty::Tuple(ts) => {
                if ts.len() == 1 {
-                    write!(f, "({},)", ts[0])
+                    write!(f, "({},)", ts[0].display(f.db))?;
                } else {
-                    join(ts.iter()).surround_with("(", ")").separator(", ").to_fmt(f)
+                    write!(f, "(")?;
+                    f.write_joined(&**ts, ", ")?;
+                    write!(f, ")")?;
                }
            }
            Ty::FnPtr(sig) => {
-                join(sig.input.iter()).surround_with("fn(", ")").separator(", ").to_fmt(f)?;
+                write!(f, "fn(")?;
-                write!(f, " -> {}", sig.output)
+                f.write_joined(sig.params(), ", ")?;
+                write!(f, ") -> {}", sig.ret().display(f.db))?;
            }
-            Ty::FnDef { def, name, substs, sig, .. } => {
+            Ty::FnDef { def, substs, .. } => {
+                let sig = f.db.callable_item_signature(*def);
+                let name = match def {
+                    CallableDef::Function(ff) => ff.name(f.db),
+                    CallableDef::Struct(s) => s.name(f.db).unwrap_or_else(Name::missing),
+                    CallableDef::EnumVariant(e) => e.name(f.db).unwrap_or_else(Name::missing),
+                };
                match def {
                    CallableDef::Function(_) => write!(f, "fn {}", name)?,
                    CallableDef::Struct(_) | CallableDef::EnumVariant(_) => write!(f, "{}", name)?,
                }
                if substs.0.len() > 0 {
-                    join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?;
+                    write!(f, "<")?;
+                    f.write_joined(&*substs.0, ", ")?;
+                    write!(f, ">")?;
                }
-                join(sig.input.iter()).surround_with("(", ")").separator(", ").to_fmt(f)?;
+                write!(f, "(")?;
-                write!(f, " -> {}", sig.output)
+                f.write_joined(sig.params(), ", ")?;
+                write!(f, ") -> {}", sig.ret().display(f.db))?;
            }
-            Ty::Adt { name, substs, .. } => {
+            Ty::Adt { def_id, substs, .. } => {
+                let name = match def_id {
+                    AdtDef::Struct(s) => s.name(f.db),
+                    AdtDef::Enum(e) => e.name(f.db),
+                }
+                .unwrap_or_else(Name::missing);
                write!(f, "{}", name)?;
                if substs.0.len() > 0 {
-                    join(substs.0.iter()).surround_with("<", ">").separator(", ").to_fmt(f)?;
+                    write!(f, "<")?;
+                    f.write_joined(&*substs.0, ", ")?;
+                    write!(f, ">")?;
                }
-                Ok(())
            }
-            Ty::Param { name, .. } => write!(f, "{}", name),
+            Ty::Param { name, .. } => write!(f, "{}", name)?,
-            Ty::Unknown => write!(f, "{{unknown}}"),
+            Ty::Unknown => write!(f, "{{unknown}}")?,
-            Ty::Infer(..) => write!(f, "_"),
+            Ty::Infer(..) => write!(f, "_")?,
        }
+        Ok(())
    }
 }
diff --git a/crates/ra_hir/src/ty/display.rs b/crates/ra_hir/src/ty/display.rs
new file mode 100644
index 000000000..63ec9d7e1
--- /dev/null
+++ b/crates/ra_hir/src/ty/display.rs
@@ -0,0 +1,56 @@
+use std::fmt;
+use crate::db::HirDatabase;
+pub struct HirFormatter<'a, 'b, DB> {
+    pub db: &'a DB,
+    fmt: &'a mut fmt::Formatter<'b>,
+}
+pub trait HirDisplay {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result;
+    fn display<'a, DB>(&'a self, db: &'a DB) -> HirDisplayWrapper<'a, DB, Self>
+    where
+        Self: Sized,
+    {
+        HirDisplayWrapper(db, self)
+    }
+}
+impl<'a, 'b, DB> HirFormatter<'a, 'b, DB>
+where
+    DB: HirDatabase,
+{
+    pub fn write_joined<T: HirDisplay>(
+        &mut self,
+        iter: impl IntoIterator<Item = T>,
+        sep: &str,
+    ) -> fmt::Result {
+        let mut first = true;
+        for e in iter {
+            if !first {
+                write!(self, "{}", sep)?;
+            }
+            first = false;
+            e.hir_fmt(self)?;
+        }
+        Ok(())
+    }
+    /// This allows using the `write!` macro directly with a `HirFormatter`.
+    pub fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self.fmt, args)
+    }
+}
+pub struct HirDisplayWrapper<'a, DB, T>(&'a DB, &'a T);
+impl<'a, DB, T> fmt::Display for HirDisplayWrapper<'a, DB, T>
+where
+    DB: HirDatabase,
+    T: HirDisplay,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.1.hir_fmt(&mut HirFormatter { db: self.0, fmt: f })
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 0a698988c..735cdecb9 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -789,11 +789,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            Expr::Call { callee, args } => {
                let callee_ty = self.infer_expr(*callee, &Expectation::none());
                let (param_tys, ret_ty) = match &callee_ty {
-                    Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()),
+                    Ty::FnPtr(sig) => (sig.params().to_vec(), sig.ret().clone()),
-                    Ty::FnDef { substs, sig, .. } => {
+                    Ty::FnDef { substs, def, .. } => {
-                        let ret_ty = sig.output.clone().subst(&substs);
+                        let sig = self.db.callable_item_signature(*def);
+                        let ret_ty = sig.ret().clone().subst(&substs);
                        let param_tys =
-                            sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect();
+                            sig.params().iter().map(|ty| ty.clone().subst(&substs)).collect();
                        (param_tys, ret_ty)
                    }
                    _ => {
@@ -827,19 +828,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let method_ty = self.insert_type_vars(method_ty);
                let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
                    Ty::FnPtr(sig) => {
-                        if !sig.input.is_empty() {
+                        if !sig.params().is_empty() {
-                            (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone())
+                            (sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
                        } else {
-                            (Ty::Unknown, Vec::new(), sig.output.clone())
+                            (Ty::Unknown, Vec::new(), sig.ret().clone())
                        }
                    }
-                    Ty::FnDef { substs, sig, .. } => {
+                    Ty::FnDef { substs, def, .. } => {
-                        let ret_ty = sig.output.clone().subst(&substs);
+                        let sig = self.db.callable_item_signature(*def);
+                        let ret_ty = sig.ret().clone().subst(&substs);
-                        if !sig.input.is_empty() {
-                            let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs));
+                        if !sig.params().is_empty() {
-                            let receiver_ty = arg_iter.next().unwrap();
+                            let mut params_iter =
-                            (receiver_ty, arg_iter.collect(), ret_ty)
+                                sig.params().iter().map(|ty| ty.clone().subst(&substs));
+                            let receiver_ty = params_iter.next().unwrap();
+                            (receiver_ty, params_iter.collect(), ret_ty)
                        } else {
                            (Ty::Unknown, Vec::new(), ret_ty)
                        }
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index f4e055feb..278f592d3 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -9,7 +9,7 @@
 use std::sync::Arc;
 use crate::{
-    Function, Struct, StructField, Enum, EnumVariant, Path, Name,
+    Function, Struct, StructField, Enum, EnumVariant, Path,
    ModuleDef, TypeAlias,
    Const, Static,
    HirDatabase,
@@ -51,12 +51,10 @@ impl Ty {
            }
            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params) => {
-                let mut inner_tys =
+                let inner_tys =
                    params.iter().map(|tr| Ty::from_hir(db, resolver, tr)).collect::<Vec<_>>();
-                let return_ty =
+                let sig = FnSig { params_and_return: inner_tys.into() };
-                    inner_tys.pop().expect("TypeRef::Fn should always have at least return type");
+                Ty::FnPtr(sig)
-                let sig = FnSig { input: inner_tys, output: return_ty };
-                Ty::FnPtr(Arc::new(sig))
            }
            TypeRef::Error => Ty::Unknown,
        }
@@ -214,6 +212,15 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
    }
 }
+/// Build the signature of a callable item (function, struct or enum variant).
+pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
+    match def {
+        CallableDef::Function(f) => fn_sig_for_fn(db, f),
+        CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e),
+    }
+}
 /// Build the type of a specific field of a struct or enum variant.
 pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
    let parent_def = field.parent_def(db);
@@ -226,19 +233,21 @@ pub(crate) fn type_for_field(db: &impl HirDatabase, field: StructField) -> Ty {
    Ty::from_hir(db, &resolver, type_ref)
 }
+fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
+    let signature = def.signature(db);
+    let resolver = def.resolver(db);
+    let params =
+        signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
+    let ret = Ty::from_hir(db, &resolver, signature.ret_type());
+    FnSig::from_params_and_return(params, ret)
+}
 /// Build the declared type of a function. This should not need to look at the
 /// function body.
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
-    let signature = def.signature(db);
-    let resolver = def.resolver(db);
    let generics = def.generic_params(db);
-    let name = def.name(db);
-    let input =
-        signature.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
-    let output = Ty::from_hir(db, &resolver, signature.ret_type());
-    let sig = Arc::new(FnSig { input, output });
    let substs = make_substs(&generics);
-    Ty::FnDef { def: def.into(), sig, name, substs }
+    Ty::FnDef { def: def.into(), substs }
 }
 /// Build the declared type of a const.
@@ -257,44 +266,58 @@ fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty {
    Ty::from_hir(db, &resolver, signature.type_ref())
 }
-/// Build the type of a tuple struct constructor.
+fn fn_sig_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> FnSig {
-fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
    let var_data = def.variant_data(db);
    let fields = match var_data.fields() {
        Some(fields) => fields,
-        None => return type_for_struct(db, def), // Unit struct
+        None => panic!("fn_sig_for_struct_constructor called on unit struct"),
    };
    let resolver = def.resolver(db);
-    let generics = def.generic_params(db);
+    let params = fields
-    let name = def.name(db).unwrap_or_else(Name::missing);
-    let input = fields
        .iter()
        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
        .collect::<Vec<_>>();
-    let output = type_for_struct(db, def);
+    let ret = type_for_struct(db, def);
-    let sig = Arc::new(FnSig { input, output });
+    FnSig::from_params_and_return(params, ret)
+}
+/// Build the type of a tuple struct constructor.
+fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
+    let var_data = def.variant_data(db);
+    if var_data.fields().is_none() {
+        return type_for_struct(db, def); // Unit struct
+    }
+    let generics = def.generic_params(db);
    let substs = make_substs(&generics);
-    Ty::FnDef { def: def.into(), sig, name, substs }
+    Ty::FnDef { def: def.into(), substs }
 }
-/// Build the type of a tuple enum variant constructor.
+fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> FnSig {
-fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
    let var_data = def.variant_data(db);
    let fields = match var_data.fields() {
        Some(fields) => fields,
-        None => return type_for_enum(db, def.parent_enum(db)), // Unit variant
+        None => panic!("fn_sig_for_enum_variant_constructor called for unit variant"),
    };
    let resolver = def.parent_enum(db).resolver(db);
-    let generics = def.parent_enum(db).generic_params(db);
+    let params = fields
-    let name = def.name(db).unwrap_or_else(Name::missing);
-    let input = fields
        .iter()
        .map(|(_, field)| Ty::from_hir(db, &resolver, &field.type_ref))
        .collect::<Vec<_>>();
+    let generics = def.parent_enum(db).generic_params(db);
+    let substs = make_substs(&generics);
+    let ret = type_for_enum(db, def.parent_enum(db)).subst(&substs);
+    FnSig::from_params_and_return(params, ret)
+}
+/// Build the type of a tuple enum variant constructor.
+fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) -> Ty {
+    let var_data = def.variant_data(db);
+    if var_data.fields().is_none() {
+        return type_for_enum(db, def.parent_enum(db)); // Unit variant
+    }
+    let generics = def.parent_enum(db).generic_params(db);
    let substs = make_substs(&generics);
-    let output = type_for_enum(db, def.parent_enum(db)).subst(&substs);
+    Ty::FnDef { def: def.into(), substs }
-    let sig = Arc::new(FnSig { input, output });
-    Ty::FnDef { def: def.into(), sig, name, substs }
 }
 fn make_substs(generics: &GenericParams) -> Substs {
@@ -310,20 +333,12 @@ fn make_substs(generics: &GenericParams) -> Substs {
 fn type_for_struct(db: &impl HirDatabase, s: Struct) -> Ty {
    let generics = s.generic_params(db);
-    Ty::Adt {
+    Ty::Adt { def_id: s.into(), substs: make_substs(&generics) }
-        def_id: s.into(),
-        name: s.name(db).unwrap_or_else(Name::missing),
-        substs: make_substs(&generics),
-    }
 }
 fn type_for_enum(db: &impl HirDatabase, s: Enum) -> Ty {
    let generics = s.generic_params(db);
-    Ty::Adt {
+    Ty::Adt { def_id: s.into(), substs: make_substs(&generics) }
-        def_id: s.into(),
-        name: s.name(db).unwrap_or_else(Name::missing),
-        substs: make_substs(&generics),
-    }
 }
 fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty {
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 94b757af2..804824868 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -7,10 +7,12 @@ use std::sync::Arc;
 use rustc_hash::FxHashMap;
 use crate::{
-    HirDatabase, module_tree::ModuleId, Module, Crate, Name, Function, Trait,
+    HirDatabase, Module, Crate, Name, Function, Trait,
    ids::TraitId,
    impl_block::{ImplId, ImplBlock, ImplItem},
    ty::{AdtDef, Ty},
+    nameres::CrateModuleId,
 };
 /// This is used as a key for indexing impls.
@@ -33,10 +35,10 @@ impl TyFingerprint {
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplBlocks {
-    /// To make sense of the ModuleIds, we need the source root.
+    /// To make sense of the CrateModuleIds, we need the source root.
    krate: Crate,
-    impls: FxHashMap<TyFingerprint, Vec<(ModuleId, ImplId)>>,
+    impls: FxHashMap<TyFingerprint, Vec<(CrateModuleId, ImplId)>>,
-    impls_by_trait: FxHashMap<TraitId, Vec<(ModuleId, ImplId)>>,
+    impls_by_trait: FxHashMap<TraitId, Vec<(CrateModuleId, ImplId)>>,
 }
 impl CrateImplBlocks {
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 5741ca90d..30aeac48e 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -10,14 +10,6 @@ pub enum UncertainIntTy {
 }
 impl UncertainIntTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
-            UncertainIntTy::Unknown => "{integer}",
-            UncertainIntTy::Signed(ty) => ty.ty_to_string(),
-            UncertainIntTy::Unsigned(ty) => ty.ty_to_string(),
-        }
-    }
    pub fn from_name(name: &Name) -> Option<UncertainIntTy> {
        if let Some(ty) = IntTy::from_name(name) {
            Some(UncertainIntTy::Signed(ty))
@@ -29,6 +21,16 @@ impl UncertainIntTy {
    }
 }
+impl fmt::Display for UncertainIntTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            UncertainIntTy::Unknown => write!(f, "{{integer}}"),
+            UncertainIntTy::Signed(ty) => write!(f, "{}", ty),
+            UncertainIntTy::Unsigned(ty) => write!(f, "{}", ty),
+        }
+    }
+}
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Copy)]
 pub enum UncertainFloatTy {
    Unknown,
@@ -36,13 +38,6 @@ pub enum UncertainFloatTy {
 }
 impl UncertainFloatTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
-            UncertainFloatTy::Unknown => "{float}",
-            UncertainFloatTy::Known(ty) => ty.ty_to_string(),
-        }
-    }
    pub fn from_name(name: &Name) -> Option<UncertainFloatTy> {
        if let Some(ty) = FloatTy::from_name(name) {
            Some(UncertainFloatTy::Known(ty))
@@ -52,6 +47,15 @@ impl UncertainFloatTy {
    }
 }
+impl fmt::Display for UncertainFloatTy {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            UncertainFloatTy::Unknown => write!(f, "{{float}}"),
+            UncertainFloatTy::Known(ty) => write!(f, "{}", ty),
+        }
+    }
+}
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
 pub enum IntTy {
    Isize,
@@ -70,22 +74,19 @@ impl fmt::Debug for IntTy {
 impl fmt::Display for IntTy {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
+        let s = match *self {
-    }
-}
-impl IntTy {
-    pub fn ty_to_string(&self) -> &'static str {
-        match *self {
            IntTy::Isize => "isize",
            IntTy::I8 => "i8",
            IntTy::I16 => "i16",
            IntTy::I32 => "i32",
            IntTy::I64 => "i64",
            IntTy::I128 => "i128",
-        }
+        };
+        write!(f, "{}", s)
    }
+}
+impl IntTy {
    pub fn from_name(name: &Name) -> Option<IntTy> {
        match name.as_known_name()? {
            KnownName::Isize => Some(IntTy::Isize),
@@ -109,18 +110,21 @@ pub enum UintTy {
    U128,
 }
-impl UintTy {
+impl fmt::Display for UintTy {
-    pub fn ty_to_string(&self) -> &'static str {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        let s = match *self {
            UintTy::Usize => "usize",
            UintTy::U8 => "u8",
            UintTy::U16 => "u16",
            UintTy::U32 => "u32",
            UintTy::U64 => "u64",
            UintTy::U128 => "u128",
-        }
+        };
+        write!(f, "{}", s)
    }
+}
+impl UintTy {
    pub fn from_name(name: &Name) -> Option<UintTy> {
        match name.as_known_name()? {
            KnownName::Usize => Some(UintTy::Usize),
@@ -140,12 +144,6 @@ impl fmt::Debug for UintTy {
    }
 }
-impl fmt::Display for UintTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.ty_to_string())
-    }
-}
 #[derive(Clone, PartialEq, Eq, Hash, Copy, PartialOrd, Ord)]
 pub enum FloatTy {
    F32,
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 0f8551a9d..0f2172ddf 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -10,6 +10,7 @@ use test_utils::covers;
 use crate::{
    source_binder,
    mock::MockDatabase,
+    ty::display::HirDisplay,
 };
 // These tests compare the inference results for all expressions in a file
@@ -2196,7 +2197,7 @@ fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
    let node = algo::find_node_at_offset::<ast::Expr>(syntax.syntax(), pos.offset).unwrap();
    let expr = body_source_map.node_expr(node).unwrap();
    let ty = &inference_result[expr];
-    ty.to_string()
+    ty.display(db).to_string()
 }
 fn infer(content: &str) -> String {
@@ -2232,7 +2233,7 @@ fn infer(content: &str) -> String {
                "{} '{}': {}\n",
                syntax_ptr.range(),
                ellipsize(node.text().to_string().replace("\n", " "), 15),
-                ty
+                ty.display(&db)
            )
            .unwrap();
        }
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 0c90ed5b5..26fde91bc 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -223,7 +223,7 @@ impl RootDatabase {
        self.query(hir::db::FileItemsQuery).sweep(sweep);
        self.query(hir::db::FileItemQuery).sweep(sweep);
-        self.query(hir::db::LowerModuleWithSourceMapQuery).sweep(sweep);
+        self.query(hir::db::RawItemsWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
    }
 }
diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs
index 71003104b..28c8f83ab 100644
--- a/crates/ra_ide_api/src/completion/presentation.rs
+++ b/crates/ra_ide_api/src/completion/presentation.rs
@@ -1,7 +1,7 @@
 //! This modules takes care of rendering various defenitions as completion items.
 use join_to_string::join;
 use test_utils::tested_by;
-use hir::{Docs, PerNs, Resolution};
+use hir::{Docs, PerNs, Resolution, HirDisplay};
 use ra_syntax::ast::NameOwner;
 use crate::completion::{
@@ -22,7 +22,7 @@ impl Completions {
            field.name(ctx.db).to_string(),
        )
        .kind(CompletionItemKind::Field)
-        .detail(field.ty(ctx.db).subst(substs).to_string())
+        .detail(field.ty(ctx.db).subst(substs).display(ctx.db).to_string())
        .set_documentation(field.docs(ctx.db))
        .add_to(self);
    }
@@ -30,7 +30,7 @@ impl Completions {
    pub(crate) fn add_pos_field(&mut self, ctx: &CompletionContext, field: usize, ty: &hir::Ty) {
        CompletionItem::new(CompletionKind::Reference, ctx.source_range(), field.to_string())
            .kind(CompletionItemKind::Field)
-            .detail(ty.to_string())
+            .detail(ty.display(ctx.db).to_string())
            .add_to(self);
    }
@@ -154,7 +154,10 @@ impl Completions {
            None => return,
        };
        let detail_types = variant.fields(ctx.db).into_iter().map(|field| field.ty(ctx.db));
-        let detail = join(detail_types).separator(", ").surround_with("(", ")").to_string();
+        let detail = join(detail_types.map(|t| t.display(ctx.db).to_string()))
+            .separator(", ")
+            .surround_with("(", ")")
+            .to_string();
        CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
            .kind(CompletionItemKind::EnumVariant)
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index 4051728e1..d23290b74 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -1,55 +1,13 @@
 use ra_db::SourceDatabase;
-use ra_syntax::{
+use ra_syntax::AstNode;
-    SyntaxNode, AstNode, SourceFile,
-    ast, algo::find_covering_node,
-};
 use crate::{
    TextRange, FileRange,
    db::RootDatabase,
 };
+// FIXME: restore macro support
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
    let source_file = db.parse(frange.file_id);
-    if let Some(range) = extend_selection_in_macro(db, &source_file, frange) {
-        return range;
-    }
    ra_ide_api_light::extend_selection(source_file.syntax(), frange.range).unwrap_or(frange.range)
 }
-fn extend_selection_in_macro(
-    _db: &RootDatabase,
-    source_file: &SourceFile,
-    frange: FileRange,
-) -> Option<TextRange> {
-    let macro_call = find_macro_call(source_file.syntax(), frange.range)?;
-    let (off, exp) = hir::MacroDef::ast_expand(macro_call)?;
-    let dst_range = exp.map_range_forward(frange.range - off)?;
-    let dst_range = ra_ide_api_light::extend_selection(&exp.syntax(), dst_range)?;
-    let src_range = exp.map_range_back(dst_range)? + off;
-    Some(src_range)
-}
-fn find_macro_call(node: &SyntaxNode, range: TextRange) -> Option<&ast::MacroCall> {
-    find_covering_node(node, range).ancestors().find_map(ast::MacroCall::cast)
-}
-#[cfg(test)]
-mod tests {
-    use ra_syntax::TextRange;
-    use crate::mock_analysis::single_file_with_range;
-    #[test]
-    fn extend_selection_inside_macros() {
-        let (analysis, frange) = single_file_with_range(
-            "
-            fn main() {
-                vec![foo(|x| <|>x<|>)];
-            }
-        ",
-        );
-        let r = analysis.extend_selection(frange).unwrap();
-        assert_eq!(r, TextRange::from_to(50.into(), 55.into()));
-    }
-}
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 66a625c6c..f6a83dd93 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -3,6 +3,7 @@ use ra_syntax::{
    AstNode, SyntaxNode, TreeArc, ast::{self, NameOwner, VisibilityOwner, TypeAscriptionOwner},
    algo::{find_covering_node, find_node_at_offset, find_leaf_at_offset, visit::{visitor, Visitor}},
 };
+use hir::HirDisplay;
 use crate::{db::RootDatabase, RangeInfo, FilePosition, FileRange, NavigationTarget};
@@ -134,9 +135,9 @@ pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
    let infer = function.infer(db);
    let source_map = function.body_source_map(db);
    if let Some(expr) = ast::Expr::cast(node).and_then(|e| source_map.node_expr(e)) {
-        Some(infer[expr].to_string())
+        Some(infer[expr].display(db).to_string())
    } else if let Some(pat) = ast::Pat::cast(node).and_then(|p| source_map.node_pat(p)) {
-        Some(infer[pat].to_string())
+        Some(infer[pat].display(db).to_string())
    } else {
        None
    }
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
index 896b47f10..ee9220a15 100644
--- a/crates/ra_ide_api/src/impls.rs
+++ b/crates/ra_ide_api/src/impls.rs
@@ -81,8 +81,9 @@ mod tests {
    fn check_goto(fixture: &str, expected: &[&str]) {
        let (analysis, pos) = analysis_and_position(fixture);
-        let navs = analysis.goto_implementation(pos).unwrap().unwrap().info;
+        let mut navs = analysis.goto_implementation(pos).unwrap().unwrap().info;
        assert_eq!(navs.len(), expected.len());
+        navs.sort_by_key(|nav| (nav.file_id(), nav.full_range().start()));
        navs.into_iter().enumerate().for_each(|(i, nav)| nav.assert_match(expected[i]));
    }
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index d64b5a4e0..2395930f0 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use ra_syntax::{
    TextRange, SyntaxNode,
-    ast::{self, AstNode, NameOwner, ModuleItemOwner},
+    ast::{self, AstNode, NameOwner, ModuleItemOwner, AttrsOwner},
 };
 use ra_db::SourceDatabase;
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
index 94fe1d6d7..23c743bef 100644
--- a/crates/ra_ide_api/src/symbol_index.rs
+++ b/crates/ra_ide_api/src/symbol_index.rs
@@ -30,7 +30,7 @@ use std::{
 use fst::{self, Streamer};
 use ra_syntax::{
    SyntaxNode, SyntaxNodePtr, SourceFile, SmolStr, TreeArc, AstNode,
-    algo::{visit::{visitor, Visitor}, find_covering_node},
+    algo::{visit::{visitor, Visitor}},
    SyntaxKind::{self, *},
    ast::{self, NameOwner},
    WalkEvent,
@@ -66,14 +66,9 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
    db.check_canceled();
    let source_file = db.parse(file_id);
-    let mut symbols = source_file_to_file_symbols(&source_file, file_id);
+    let symbols = source_file_to_file_symbols(&source_file, file_id);
-    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id) {
+    // TODO: add macros here
-        let node = find_covering_node(source_file.syntax(), text_range);
-        let ptr = SyntaxNodePtr::new(node);
-        // TODO: Should we get container name for macro symbols?
-        symbols.push(FileSymbol { file_id, name, ptr, name_range: None, container_name: None })
-    }
    Arc::new(SymbolIndex::new(symbols))
 }
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 345b6653d..fdd87bcff 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -1,4 +1,4 @@
-use ra_syntax::{ast, AstNode,};
+use ra_syntax::AstNode;
 use ra_db::SourceDatabase;
 use crate::{
@@ -8,37 +8,5 @@ use crate::{
 pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
    let source_file = db.parse(file_id);
-    let mut res = ra_ide_api_light::highlight(source_file.syntax());
+    ra_ide_api_light::highlight(source_file.syntax())
-    for macro_call in source_file.syntax().descendants().filter_map(ast::MacroCall::cast) {
-        if let Some((off, exp)) = hir::MacroDef::ast_expand(macro_call) {
-            let mapped_ranges =
-                ra_ide_api_light::highlight(&exp.syntax()).into_iter().filter_map(|r| {
-                    let mapped_range = exp.map_range_back(r.range)?;
-                    let res = HighlightedRange { range: mapped_range + off, tag: r.tag };
-                    Some(res)
-                });
-            res.extend(mapped_ranges);
-        }
-    }
-    res
-}
-#[cfg(test)]
-mod tests {
-    use crate::mock_analysis::single_file;
-    use insta::assert_debug_snapshot_matches;
-    #[test]
-    fn highlights_code_inside_macros() {
-        let (analysis, file_id) = single_file(
-            "
-            fn main() {
-                vec![{ let x = 92; x}];
-            }
-            ",
-        );
-        let highlights = analysis.highlight(file_id).unwrap();
-        assert_debug_snapshot_matches!("highlights_code_inside_macros", &highlights);
-    }
 }
diff --git a/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap b/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
index d258820af..5bb953892 100644
--- a/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
+++ b/crates/ra_ide_api/tests/test/snapshots/test__unresolved_module_diagnostic.snap
@@ -7,7 +7,7 @@ source: "crates\\ra_ide_api\\tests\\test\\main.rs"
 [
    Diagnostic {
        message: "unresolved module",
-        range: [4; 7),
+        range: [0; 8),
        fix: Some(
            SourceChange {
                label: "create module",
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 2c75b7b4f..989308626 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -42,7 +42,7 @@ pub use crate::syntax_bridge::{ast_to_token_tree, token_tree_to_ast_item_list};
 /// be very confusing is that AST has almost exactly the same shape as
 /// `tt::TokenTree`, but there's a crucial difference: in macro rules, `$ident`
 /// and `$()*` have special meaning (see `Var` and `Repeat` data structures)
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct MacroRules {
    pub(crate) rules: Vec<Rule>,
 }
@@ -56,13 +56,13 @@ impl MacroRules {
    }
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Rule {
    pub(crate) lhs: Subtree,
    pub(crate) rhs: Subtree,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum TokenTree {
    Leaf(Leaf),
    Subtree(Subtree),
@@ -70,7 +70,7 @@ pub(crate) enum TokenTree {
 }
 impl_froms!(TokenTree: Leaf, Subtree, Repeat);
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum Leaf {
    Literal(Literal),
    Punct(Punct),
@@ -79,37 +79,37 @@ pub(crate) enum Leaf {
 }
 impl_froms!(Leaf: Literal, Punct, Ident, Var);
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Subtree {
    pub(crate) delimiter: Delimiter,
    pub(crate) token_trees: Vec<TokenTree>,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Repeat {
    pub(crate) subtree: Subtree,
    pub(crate) kind: RepeatKind,
    pub(crate) separator: Option<char>,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum RepeatKind {
    ZeroOrMore,
    OneOrMore,
    ZeroOrOne,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Literal {
    pub(crate) text: SmolStr,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Ident {
    pub(crate) text: SmolStr,
 }
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Var {
    pub(crate) text: SmolStr,
    pub(crate) kind: Option<SmolStr>,
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index 2dd97b665..2dafd68f6 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -155,7 +155,14 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                _ => return Err(ExpandError::UnexpectedToken),
            },
            crate::TokenTree::Repeat(crate::Repeat { subtree, kind: _, separator }) => {
+                // Dirty hack to make macro-expansion terminate.
+                // This should be replaced by a propper macro-by-example implementation
+                let mut limit = 128;
                while let Ok(nested) = match_lhs(subtree, input) {
+                    limit -= 1;
+                    if limit == 0 {
+                        break;
+                    }
                    res.push_nested(nested)?;
                    if let Some(separator) = *separator {
                        if !input.is_eof() {
@@ -196,7 +203,14 @@ fn expand_tt(
        crate::TokenTree::Repeat(repeat) => {
            let mut token_trees = Vec::new();
            nesting.push(0);
+            // Dirty hack to make macro-expansion terminate.
+            // This should be replaced by a propper macro-by-example implementation
+            let mut limit = 128;
            while let Ok(t) = expand_subtree(&repeat.subtree, bindings, nesting) {
+                limit -= 1;
+                if limit == 0 {
+                    break;
+                }
                let idx = nesting.pop().unwrap();
                nesting.push(idx + 1);
                token_trees.push(t.into())
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 70c71a8e1..5a3b9f589 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -43,65 +43,64 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
    attributes::inner_attributes(p);
    while !p.at(EOF) && !p.at(R_CURLY) {
-        match p.current() {
+        // test nocontentexpr
-            // test nocontentexpr
+        // fn foo(){
-            // fn foo(){
+        //     ;;;some_expr();;;;{;;;};;;;Ok(())
-            //     ;;;some_expr();;;;{;;;};;;;Ok(())
+        // }
-            // }
+        if p.current() == SEMI {
-            SEMI => p.bump(),
+            p.bump();
-            _ => {
+            continue;
-                // test block_items
+        }
-                // fn a() { fn b() {} }
-                let m = p.start();
+        // test block_items
-                let has_attrs = p.at(POUND);
+        // fn a() { fn b() {} }
-                attributes::outer_attributes(p);
+        let m = p.start();
-                if p.at(LET_KW) {
+        let has_attrs = p.at(POUND);
-                    let_stmt(p, m);
+        attributes::outer_attributes(p);
+        if p.at(LET_KW) {
+            let_stmt(p, m);
+            continue;
+        }
+        match items::maybe_item(p, items::ItemFlavor::Mod) {
+            items::MaybeItem::Item(kind) => {
+                m.complete(p, kind);
+            }
+            items::MaybeItem::Modifiers => {
+                m.abandon(p);
+                p.error("expected an item");
+            }
+            // test pub_expr
+            // fn foo() { pub 92; } //FIXME
+            items::MaybeItem::None => {
+                if has_attrs {
+                    m.abandon(p);
+                    p.error("expected a let statement or an item after attributes in block");
                } else {
-                    match items::maybe_item(p, items::ItemFlavor::Mod) {
+                    let is_blocklike = expressions::expr_stmt(p) == BlockLike::Block;
-                        items::MaybeItem::Item(kind) => {
+                    if p.at(R_CURLY) {
-                            m.complete(p, kind);
+                        m.abandon(p);
-                        }
+                    } else {
-                        items::MaybeItem::Modifiers => {
+                        // test no_semi_after_block
-                            m.abandon(p);
+                        // fn foo() {
-                            p.error("expected an item");
+                        //     if true {}
-                        }
+                        //     loop {}
-                        // test pub_expr
+                        //     match () {}
-                        // fn foo() { pub 92; } //FIXME
+                        //     while true {}
-                        items::MaybeItem::None => {
+                        //     for _ in () {}
-                            if has_attrs {
+                        //     {}
-                                m.abandon(p);
+                        //     {}
-                                p.error(
+                        //     macro_rules! test {
-                                    "expected a let statement or an item after attributes in block",
+                        //          () => {}
-                                );
+                        //     }
-                            } else {
+                        //     test!{}
-                                let is_blocklike = expressions::expr_stmt(p) == BlockLike::Block;
+                        // }
-                                if p.at(R_CURLY) {
+                        if is_blocklike {
-                                    m.abandon(p);
+                            p.eat(SEMI);
-                                } else {
+                        } else {
-                                    // test no_semi_after_block
+                            p.expect(SEMI);
-                                    // fn foo() {
-                                    //     if true {}
-                                    //     loop {}
-                                    //     match () {}
-                                    //     while true {}
-                                    //     for _ in () {}
-                                    //     {}
-                                    //     {}
-                                    //     macro_rules! test {
-                                    //          () => {}
-                                    //     }
-                                    //     test!{}
-                                    // }
-                                    if is_blocklike {
-                                        p.eat(SEMI);
-                                    } else {
-                                        p.expect(SEMI);
-                                    }
-                                    m.complete(p, EXPR_STMT);
-                                }
-                            }
                        }
+                        m.complete(p, EXPR_STMT);
                    }
                }
            }
@@ -155,6 +154,7 @@ fn current_op(p: &Parser) -> (u8, Op) {
            (PLUS, EQ) => return (1, Op::Composite(PLUSEQ, 2)),
            (MINUS, EQ) => return (1, Op::Composite(MINUSEQ, 2)),
            (STAR, EQ) => return (1, Op::Composite(STAREQ, 2)),
+            (PERCENT, EQ) => return (1, Op::Composite(PERCENTEQ, 2)),
            (SLASH, EQ) => return (1, Op::Composite(SLASHEQ, 2)),
            (PIPE, EQ) => return (1, Op::Composite(PIPEEQ, 2)),
            (AMP, EQ) => return (1, Op::Composite(AMPEQ, 2)),
@@ -453,8 +453,13 @@ pub(crate) fn named_field_list(p: &mut Parser) {
    p.bump();
    while !p.at(EOF) && !p.at(R_CURLY) {
        match p.current() {
-            IDENT => {
+            // test struct_literal_field_with_attr
+            // fn main() {
+            //     S { #[cfg(test)] field: 1 }
+            // }
+            IDENT | POUND => {
                let m = p.start();
+                attributes::outer_attributes(p);
                name_ref(p);
                if p.eat(COLON) {
                    expr(p);
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 53bb26c5f..d933288cd 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -342,21 +342,6 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
            continue;
        }
-        // test match_arms_outer_attributes
-        // fn foo() {
-        //     match () {
-        //         #[cfg(feature = "some")]
-        //         _ => (),
-        //         #[cfg(feature = "other")]
-        //         _ => (),
-        //         #[cfg(feature = "many")]
-        //         #[cfg(feature = "attributes")]
-        //         #[cfg(feature = "before")]
-        //         _ => (),
-        //     }
-        // }
-        attributes::outer_attributes(p);
        // test match_arms_commas
        // fn foo() {
        //     match () {
@@ -387,6 +372,21 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 // }
 fn match_arm(p: &mut Parser) -> BlockLike {
    let m = p.start();
+    // test match_arms_outer_attributes
+    // fn foo() {
+    //     match () {
+    //         #[cfg(feature = "some")]
+    //         _ => (),
+    //         #[cfg(feature = "other")]
+    //         _ => (),
+    //         #[cfg(feature = "many")]
+    //         #[cfg(feature = "attributes")]
+    //         #[cfg(feature = "before")]
+    //         _ => (),
+    //     }
+    // }
+    attributes::outer_attributes(p);
    patterns::pattern_list_r(p, TokenSet::empty());
    if p.at(IF_KW) {
        match_guard(p);
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index befe6687d..9a307559b 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -2,7 +2,7 @@ use super::*;
 pub(super) const PATTERN_FIRST: TokenSet = expressions::LITERAL_FIRST
    .union(paths::PATH_FIRST)
-    .union(token_set![REF_KW, MUT_KW, L_PAREN, L_BRACK, AMP, UNDERSCORE]);
+    .union(token_set![REF_KW, MUT_KW, L_PAREN, L_BRACK, AMP, UNDERSCORE, MINUS]);
 pub(super) fn pattern(p: &mut Parser) {
    pattern_r(p, PAT_RECOVERY_SET)
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 81c709bfb..d8c2cb063 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -114,6 +114,9 @@ pub trait AttrsOwner: AstNode {
    fn attrs(&self) -> AstChildren<Attr> {
        children(self)
    }
+    fn has_atom_attr(&self, atom: &str) -> bool {
+        self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
+    }
 }
 pub trait DocCommentsOwner: AstNode {
@@ -153,12 +156,6 @@ pub trait DocCommentsOwner: AstNode {
    }
 }
-impl FnDef {
-    pub fn has_atom_attr(&self, atom: &str) -> bool {
-        self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
-    }
-}
 impl Attr {
    pub fn is_inner(&self) -> bool {
        let tt = match self.value() {
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 7572225b8..54b72f8c5 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -2108,6 +2108,7 @@ impl ToOwned for MacroCall {
 impl ast::NameOwner for MacroCall {}
+impl ast::AttrsOwner for MacroCall {}
 impl MacroCall {
    pub fn token_tree(&self) -> Option<&TokenTree> {
        super::child_opt(self)
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 66f1339c1..4f8e19bd0 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -557,7 +557,7 @@ Grammar(
        "Name": (),
        "NameRef": (),
        "MacroCall": (
-            traits: [ "NameOwner" ],
+            traits: [ "NameOwner", "AttrsOwner" ],
            options: [ "TokenTree", "Path" ],
        ),
        "Attr": ( options: [ ["value", "TokenTree"] ] ),
diff --git a/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt b/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
index b7543abc9..ed5735a63 100644
--- a/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0032_match_arms_inner_attrs.txt
@@ -33,11 +33,11 @@ SOURCE_FILE@[0; 293)
                R_PAREN@[40; 41)
            COMMA@[41; 42)
            WHITESPACE@[42; 51)
-            ATTR@[51; 52)
+            MATCH_ARM@[51; 78)
-              POUND@[51; 52)
+              ATTR@[51; 52)
-              err: `expected `[``
+                POUND@[51; 52)
-              err: `expected pattern`
+                err: `expected `[``
-            MATCH_ARM@[52; 78)
+                err: `expected pattern`
              ERROR@[52; 53)
                EXCL@[52; 53)
                err: `expected FAT_ARROW`
@@ -103,11 +103,11 @@ SOURCE_FILE@[0; 293)
                R_PAREN@[149; 150)
            COMMA@[150; 151)
            WHITESPACE@[151; 160)
-            ATTR@[160; 161)
+            MATCH_ARM@[160; 179)
-              POUND@[160; 161)
+              ATTR@[160; 161)
-              err: `expected `[``
+                POUND@[160; 161)
-              err: `expected pattern`
+                err: `expected `[``
-            MATCH_ARM@[161; 179)
+                err: `expected pattern`
              ERROR@[161; 162)
                EXCL@[161; 162)
                err: `expected FAT_ARROW`
@@ -138,22 +138,22 @@ SOURCE_FILE@[0; 293)
        MATCH_ARM_LIST@[200; 290)
          L_CURLY@[200; 201)
          WHITESPACE@[201; 210)
-          ATTR@[210; 222)
+          MATCH_ARM@[210; 250)
-            POUND@[210; 211)
+            ATTR@[210; 222)
-            TOKEN_TREE@[211; 222)
+              POUND@[210; 211)
-              L_BRACK@[211; 212)
+              TOKEN_TREE@[211; 222)
-              IDENT@[212; 215) "cfg"
+                L_BRACK@[211; 212)
-              TOKEN_TREE@[215; 221)
+                IDENT@[212; 215) "cfg"
-                L_PAREN@[215; 216)
+                TOKEN_TREE@[215; 221)
-                IDENT@[216; 220) "test"
+                  L_PAREN@[215; 216)
-                R_PAREN@[220; 221)
+                  IDENT@[216; 220) "test"
-              R_BRACK@[221; 222)
+                  R_PAREN@[220; 221)
-          WHITESPACE@[222; 231)
+                R_BRACK@[221; 222)
-          ATTR@[231; 232)
+            WHITESPACE@[222; 231)
-            POUND@[231; 232)
+            ATTR@[231; 232)
-            err: `expected `[``
+              POUND@[231; 232)
-            err: `expected pattern`
+              err: `expected `[``
-          MATCH_ARM@[232; 250)
+              err: `expected pattern`
            ERROR@[232; 233)
              EXCL@[232; 233)
              err: `expected FAT_ARROW`
diff --git a/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt b/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
index 7f8767001..f540409bc 100644
--- a/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0033_match_arms_outer_attrs.txt
@@ -43,21 +43,21 @@ SOURCE_FILE@[0; 89)
              R_PAREN@[57; 58)
          COMMA@[58; 59)
          WHITESPACE@[59; 68)
-          ATTR@[68; 80)
+          MATCH_ARM@[68; 80)
-            POUND@[68; 69)
+            ATTR@[68; 80)
-            TOKEN_TREE@[69; 80)
+              POUND@[68; 69)
-              L_BRACK@[69; 70)
+              TOKEN_TREE@[69; 80)
-              IDENT@[70; 73) "cfg"
+                L_BRACK@[69; 70)
-              TOKEN_TREE@[73; 79)
+                IDENT@[70; 73) "cfg"
-                L_PAREN@[73; 74)
+                TOKEN_TREE@[73; 79)
-                IDENT@[74; 78) "test"
+                  L_PAREN@[73; 74)
-                R_PAREN@[78; 79)
+                  IDENT@[74; 78) "test"
-              R_BRACK@[79; 80)
+                  R_PAREN@[78; 79)
+                R_BRACK@[79; 80)
+                err: `expected pattern`
+                err: `expected FAT_ARROW`
+                err: `expected expression`
          WHITESPACE@[80; 85)
-          err: `expected pattern`
-          err: `expected FAT_ARROW`
-          err: `expected expression`
-          MATCH_ARM@[85; 85)
          R_CURLY@[85; 86)
      WHITESPACE@[86; 87)
      R_CURLY@[87; 88)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
index c888fb8f0..e52a290bf 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0121_match_arms_outer_attributes.txt
@@ -21,22 +21,22 @@ SOURCE_FILE@[0; 259)
        MATCH_ARM_LIST@[24; 256)
          L_CURLY@[24; 25)
          WHITESPACE@[25; 34)
-          ATTR@[34; 58)
+          MATCH_ARM@[34; 74)
-            POUND@[34; 35)
+            ATTR@[34; 58)
-            TOKEN_TREE@[35; 58)
+              POUND@[34; 35)
-              L_BRACK@[35; 36)
+              TOKEN_TREE@[35; 58)
-              IDENT@[36; 39) "cfg"
+                L_BRACK@[35; 36)
-              TOKEN_TREE@[39; 57)
+                IDENT@[36; 39) "cfg"
-                L_PAREN@[39; 40)
+                TOKEN_TREE@[39; 57)
-                IDENT@[40; 47) "feature"
+                  L_PAREN@[39; 40)
-                WHITESPACE@[47; 48)
+                  IDENT@[40; 47) "feature"
-                EQ@[48; 49)
+                  WHITESPACE@[47; 48)
-                WHITESPACE@[49; 50)
+                  EQ@[48; 49)
-                STRING@[50; 56)
+                  WHITESPACE@[49; 50)
-                R_PAREN@[56; 57)
+                  STRING@[50; 56)
-              R_BRACK@[57; 58)
+                  R_PAREN@[56; 57)
-          WHITESPACE@[58; 67)
+                R_BRACK@[57; 58)
-          MATCH_ARM@[67; 74)
+            WHITESPACE@[58; 67)
            PLACEHOLDER_PAT@[67; 68)
              UNDERSCORE@[67; 68)
            WHITESPACE@[68; 69)
@@ -47,22 +47,22 @@ SOURCE_FILE@[0; 259)
              R_PAREN@[73; 74)
          COMMA@[74; 75)
          WHITESPACE@[75; 84)
-          ATTR@[84; 109)
+          MATCH_ARM@[84; 125)
-            POUND@[84; 85)
+            ATTR@[84; 109)
-            TOKEN_TREE@[85; 109)
+              POUND@[84; 85)
-              L_BRACK@[85; 86)
+              TOKEN_TREE@[85; 109)
-              IDENT@[86; 89) "cfg"
+                L_BRACK@[85; 86)
-              TOKEN_TREE@[89; 108)
+                IDENT@[86; 89) "cfg"
-                L_PAREN@[89; 90)
+                TOKEN_TREE@[89; 108)
-                IDENT@[90; 97) "feature"
+                  L_PAREN@[89; 90)
-                WHITESPACE@[97; 98)
+                  IDENT@[90; 97) "feature"
-                EQ@[98; 99)
+                  WHITESPACE@[97; 98)
-                WHITESPACE@[99; 100)
+                  EQ@[98; 99)
-                STRING@[100; 107)
+                  WHITESPACE@[99; 100)
-                R_PAREN@[107; 108)
+                  STRING@[100; 107)
-              R_BRACK@[108; 109)
+                  R_PAREN@[107; 108)
-          WHITESPACE@[109; 118)
+                R_BRACK@[108; 109)
-          MATCH_ARM@[118; 125)
+            WHITESPACE@[109; 118)
            PLACEHOLDER_PAT@[118; 119)
              UNDERSCORE@[118; 119)
            WHITESPACE@[119; 120)
@@ -73,52 +73,52 @@ SOURCE_FILE@[0; 259)
              R_PAREN@[124; 125)
          COMMA@[125; 126)
          WHITESPACE@[126; 135)
-          ATTR@[135; 159)
+          MATCH_ARM@[135; 249)
-            POUND@[135; 136)
+            ATTR@[135; 159)
-            TOKEN_TREE@[136; 159)
+              POUND@[135; 136)
-              L_BRACK@[136; 137)
+              TOKEN_TREE@[136; 159)
-              IDENT@[137; 140) "cfg"
+                L_BRACK@[136; 137)
-              TOKEN_TREE@[140; 158)
+                IDENT@[137; 140) "cfg"
-                L_PAREN@[140; 141)
+                TOKEN_TREE@[140; 158)
-                IDENT@[141; 148) "feature"
+                  L_PAREN@[140; 141)
-                WHITESPACE@[148; 149)
+                  IDENT@[141; 148) "feature"
-                EQ@[149; 150)
+                  WHITESPACE@[148; 149)
-                WHITESPACE@[150; 151)
+                  EQ@[149; 150)
-                STRING@[151; 157)
+                  WHITESPACE@[150; 151)
-                R_PAREN@[157; 158)
+                  STRING@[151; 157)
-              R_BRACK@[158; 159)
+                  R_PAREN@[157; 158)
-          WHITESPACE@[159; 168)
+                R_BRACK@[158; 159)
-          ATTR@[168; 198)
+            WHITESPACE@[159; 168)
-            POUND@[168; 169)
+            ATTR@[168; 198)
-            TOKEN_TREE@[169; 198)
+              POUND@[168; 169)
-              L_BRACK@[169; 170)
+              TOKEN_TREE@[169; 198)
-              IDENT@[170; 173) "cfg"
+                L_BRACK@[169; 170)
-              TOKEN_TREE@[173; 197)
+                IDENT@[170; 173) "cfg"
-                L_PAREN@[173; 174)
+                TOKEN_TREE@[173; 197)
-                IDENT@[174; 181) "feature"
+                  L_PAREN@[173; 174)
-                WHITESPACE@[181; 182)
+                  IDENT@[174; 181) "feature"
-                EQ@[182; 183)
+                  WHITESPACE@[181; 182)
-                WHITESPACE@[183; 184)
+                  EQ@[182; 183)
-                STRING@[184; 196)
+                  WHITESPACE@[183; 184)
-                R_PAREN@[196; 197)
+                  STRING@[184; 196)
-              R_BRACK@[197; 198)
+                  R_PAREN@[196; 197)
-          WHITESPACE@[198; 207)
+                R_BRACK@[197; 198)
-          ATTR@[207; 233)
+            WHITESPACE@[198; 207)
-            POUND@[207; 208)
+            ATTR@[207; 233)
-            TOKEN_TREE@[208; 233)
+              POUND@[207; 208)
-              L_BRACK@[208; 209)
+              TOKEN_TREE@[208; 233)
-              IDENT@[209; 212) "cfg"
+                L_BRACK@[208; 209)
-              TOKEN_TREE@[212; 232)
+                IDENT@[209; 212) "cfg"
-                L_PAREN@[212; 213)
+                TOKEN_TREE@[212; 232)
-                IDENT@[213; 220) "feature"
+                  L_PAREN@[212; 213)
-                WHITESPACE@[220; 221)
+                  IDENT@[213; 220) "feature"
-                EQ@[221; 222)
+                  WHITESPACE@[220; 221)
-                WHITESPACE@[222; 223)
+                  EQ@[221; 222)
-                STRING@[223; 231)
+                  WHITESPACE@[222; 223)
-                R_PAREN@[231; 232)
+                  STRING@[223; 231)
-              R_BRACK@[232; 233)
+                  R_PAREN@[231; 232)
-          WHITESPACE@[233; 242)
+                R_BRACK@[232; 233)
-          MATCH_ARM@[242; 249)
+            WHITESPACE@[233; 242)
            PLACEHOLDER_PAT@[242; 243)
              UNDERSCORE@[242; 243)
            WHITESPACE@[243; 244)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.rs
new file mode 100644
index 000000000..a6c7760c7
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.rs
@@ -0,0 +1,3 @@
+fn main() {
+    S { #[cfg(test)] field: 1 }
+}
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.txt
new file mode 100644
index 000000000..34c80500a
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0125_struct_literal_field_with_attr.txt
@@ -0,0 +1,45 @@
+SOURCE_FILE@[0; 46)
+  FN_DEF@[0; 45)
+    FN_KW@[0; 2)
+    WHITESPACE@[2; 3)
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8)
+      R_PAREN@[8; 9)
+    WHITESPACE@[9; 10)
+    BLOCK@[10; 45)
+      L_CURLY@[10; 11)
+      WHITESPACE@[11; 16)
+      STRUCT_LIT@[16; 43)
+        PATH@[16; 17)
+          PATH_SEGMENT@[16; 17)
+            NAME_REF@[16; 17)
+              IDENT@[16; 17) "S"
+        WHITESPACE@[17; 18)
+        NAMED_FIELD_LIST@[18; 43)
+          L_CURLY@[18; 19)
+          WHITESPACE@[19; 20)
+          NAMED_FIELD@[20; 41)
+            ATTR@[20; 32)
+              POUND@[20; 21)
+              TOKEN_TREE@[21; 32)
+                L_BRACK@[21; 22)
+                IDENT@[22; 25) "cfg"
+                TOKEN_TREE@[25; 31)
+                  L_PAREN@[25; 26)
+                  IDENT@[26; 30) "test"
+                  R_PAREN@[30; 31)
+                R_BRACK@[31; 32)
+            WHITESPACE@[32; 33)
+            NAME_REF@[33; 38)
+              IDENT@[33; 38) "field"
+            COLON@[38; 39)
+            WHITESPACE@[39; 40)
+            LITERAL@[40; 41)
+              INT_NUMBER@[40; 41) "1"
+          WHITESPACE@[41; 42)
+          R_CURLY@[42; 43)
+      WHITESPACE@[43; 44)
+      R_CURLY@[44; 45)
+  WHITESPACE@[45; 46)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.rs b/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.rs
new file mode 100644
index 000000000..bbd6b0f6e
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.rs
@@ -0,0 +1,27 @@
+// https://github.com/rust-analyzer/rust-analyzer/issues/972
+fn main() {
+    match Some(-1) {
+        Some(-1) => (),
+        _ => (),
+    }
+    match Some((-1, -1)) {
+        Some((-1, -1)) => (),
+        _ => (),
+    }
+    match A::B(-1, -1) {
+        A::B(-1, -1) => (),
+        _ => (),
+    }
+    if let Some(-1) = Some(-1) {
+    }
+}
+enum A {
+    B(i8, i8)
+}
+fn foo(-128..=127: i8) {}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.txt b/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.txt
new file mode 100644
index 000000000..ca66b44bb
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0047_minus_in_inner_pattern.txt
@@ -0,0 +1,320 @@
+SOURCE_FILE@[0; 395)
+  COMMENT@[0; 60)
+  WHITESPACE@[60; 62)
+  FN_DEF@[62; 341)
+    FN_KW@[62; 64)
+    WHITESPACE@[64; 65)
+    NAME@[65; 69)
+      IDENT@[65; 69) "main"
+    PARAM_LIST@[69; 71)
+      L_PAREN@[69; 70)
+      R_PAREN@[70; 71)
+    WHITESPACE@[71; 72)
+    BLOCK@[72; 341)
+      L_CURLY@[72; 73)
+      WHITESPACE@[73; 78)
+      EXPR_STMT@[78; 141)
+        MATCH_EXPR@[78; 141)
+          MATCH_KW@[78; 83)
+          WHITESPACE@[83; 84)
+          CALL_EXPR@[84; 92)
+            PATH_EXPR@[84; 88)
+              PATH@[84; 88)
+                PATH_SEGMENT@[84; 88)
+                  NAME_REF@[84; 88)
+                    IDENT@[84; 88) "Some"
+            ARG_LIST@[88; 92)
+              L_PAREN@[88; 89)
+              PREFIX_EXPR@[89; 91)
+                MINUS@[89; 90)
+                LITERAL@[90; 91)
+                  INT_NUMBER@[90; 91) "1"
+              R_PAREN@[91; 92)
+          WHITESPACE@[92; 93)
+          MATCH_ARM_LIST@[93; 141)
+            L_CURLY@[93; 94)
+            WHITESPACE@[94; 103)
+            MATCH_ARM@[103; 117)
+              TUPLE_STRUCT_PAT@[103; 111)
+                PATH@[103; 107)
+                  PATH_SEGMENT@[103; 107)
+                    NAME_REF@[103; 107)
+                      IDENT@[103; 107) "Some"
+                L_PAREN@[107; 108)
+                LITERAL_PAT@[108; 110)
+                  MINUS@[108; 109)
+                  LITERAL@[109; 110)
+                    INT_NUMBER@[109; 110) "1"
+                R_PAREN@[110; 111)
+              WHITESPACE@[111; 112)
+              FAT_ARROW@[112; 114)
+              WHITESPACE@[114; 115)
+              TUPLE_EXPR@[115; 117)
+                L_PAREN@[115; 116)
+                R_PAREN@[116; 117)
+            COMMA@[117; 118)
+            WHITESPACE@[118; 127)
+            MATCH_ARM@[127; 134)
+              PLACEHOLDER_PAT@[127; 128)
+                UNDERSCORE@[127; 128)
+              WHITESPACE@[128; 129)
+              FAT_ARROW@[129; 131)
+              WHITESPACE@[131; 132)
+              TUPLE_EXPR@[132; 134)
+                L_PAREN@[132; 133)
+                R_PAREN@[133; 134)
+            COMMA@[134; 135)
+            WHITESPACE@[135; 140)
+            R_CURLY@[140; 141)
+      WHITESPACE@[141; 147)
+      EXPR_STMT@[147; 222)
+        MATCH_EXPR@[147; 222)
+          MATCH_KW@[147; 152)
+          WHITESPACE@[152; 153)
+          CALL_EXPR@[153; 167)
+            PATH_EXPR@[153; 157)
+              PATH@[153; 157)
+                PATH_SEGMENT@[153; 157)
+                  NAME_REF@[153; 157)
+                    IDENT@[153; 157) "Some"
+            ARG_LIST@[157; 167)
+              L_PAREN@[157; 158)
+              TUPLE_EXPR@[158; 166)
+                L_PAREN@[158; 159)
+                PREFIX_EXPR@[159; 161)
+                  MINUS@[159; 160)
+                  LITERAL@[160; 161)
+                    INT_NUMBER@[160; 161) "1"
+                COMMA@[161; 162)
+                WHITESPACE@[162; 163)
+                PREFIX_EXPR@[163; 165)
+                  MINUS@[163; 164)
+                  LITERAL@[164; 165)
+                    INT_NUMBER@[164; 165) "1"
+                R_PAREN@[165; 166)
+              R_PAREN@[166; 167)
+          WHITESPACE@[167; 168)
+          MATCH_ARM_LIST@[168; 222)
+            L_CURLY@[168; 169)
+            WHITESPACE@[169; 178)
+            MATCH_ARM@[178; 198)
+              TUPLE_STRUCT_PAT@[178; 192)
+                PATH@[178; 182)
+                  PATH_SEGMENT@[178; 182)
+                    NAME_REF@[178; 182)
+                      IDENT@[178; 182) "Some"
+                L_PAREN@[182; 183)
+                TUPLE_PAT@[183; 191)
+                  L_PAREN@[183; 184)
+                  LITERAL_PAT@[184; 186)
+                    MINUS@[184; 185)
+                    LITERAL@[185; 186)
+                      INT_NUMBER@[185; 186) "1"
+                  COMMA@[186; 187)
+                  WHITESPACE@[187; 188)
+                  LITERAL_PAT@[188; 190)
+                    MINUS@[188; 189)
+                    LITERAL@[189; 190)
+                      INT_NUMBER@[189; 190) "1"
+                  R_PAREN@[190; 191)
+                R_PAREN@[191; 192)
+              WHITESPACE@[192; 193)
+              FAT_ARROW@[193; 195)
+              WHITESPACE@[195; 196)
+              TUPLE_EXPR@[196; 198)
+                L_PAREN@[196; 197)
+                R_PAREN@[197; 198)
+            COMMA@[198; 199)
+            WHITESPACE@[199; 208)
+            MATCH_ARM@[208; 215)
+              PLACEHOLDER_PAT@[208; 209)
+                UNDERSCORE@[208; 209)
+              WHITESPACE@[209; 210)
+              FAT_ARROW@[210; 212)
+              WHITESPACE@[212; 213)
+              TUPLE_EXPR@[213; 215)
+                L_PAREN@[213; 214)
+                R_PAREN@[214; 215)
+            COMMA@[215; 216)
+            WHITESPACE@[216; 221)
+            R_CURLY@[221; 222)
+      WHITESPACE@[222; 228)
+      EXPR_STMT@[228; 299)
+        MATCH_EXPR@[228; 299)
+          MATCH_KW@[228; 233)
+          WHITESPACE@[233; 234)
+          CALL_EXPR@[234; 246)
+            PATH_EXPR@[234; 238)
+              PATH@[234; 238)
+                PATH@[234; 235)
+                  PATH_SEGMENT@[234; 235)
+                    NAME_REF@[234; 235)
+                      IDENT@[234; 235) "A"
+                COLONCOLON@[235; 237)
+                PATH_SEGMENT@[237; 238)
+                  NAME_REF@[237; 238)
+                    IDENT@[237; 238) "B"
+            ARG_LIST@[238; 246)
+              L_PAREN@[238; 239)
+              PREFIX_EXPR@[239; 241)
+                MINUS@[239; 240)
+                LITERAL@[240; 241)
+                  INT_NUMBER@[240; 241) "1"
+              COMMA@[241; 242)
+              WHITESPACE@[242; 243)
+              PREFIX_EXPR@[243; 245)
+                MINUS@[243; 244)
+                LITERAL@[244; 245)
+                  INT_NUMBER@[244; 245) "1"
+              R_PAREN@[245; 246)
+          WHITESPACE@[246; 247)
+          MATCH_ARM_LIST@[247; 299)
+            L_CURLY@[247; 248)
+            WHITESPACE@[248; 257)
+            MATCH_ARM@[257; 275)
+              TUPLE_STRUCT_PAT@[257; 269)
+                PATH@[257; 261)
+                  PATH@[257; 258)
+                    PATH_SEGMENT@[257; 258)
+                      NAME_REF@[257; 258)
+                        IDENT@[257; 258) "A"
+                  COLONCOLON@[258; 260)
+                  PATH_SEGMENT@[260; 261)
+                    NAME_REF@[260; 261)
+                      IDENT@[260; 261) "B"
+                L_PAREN@[261; 262)
+                LITERAL_PAT@[262; 264)
+                  MINUS@[262; 263)
+                  LITERAL@[263; 264)
+                    INT_NUMBER@[263; 264) "1"
+                COMMA@[264; 265)
+                WHITESPACE@[265; 266)
+                LITERAL_PAT@[266; 268)
+                  MINUS@[266; 267)
+                  LITERAL@[267; 268)
+                    INT_NUMBER@[267; 268) "1"
+                R_PAREN@[268; 269)
+              WHITESPACE@[269; 270)
+              FAT_ARROW@[270; 272)
+              WHITESPACE@[272; 273)
+              TUPLE_EXPR@[273; 275)
+                L_PAREN@[273; 274)
+                R_PAREN@[274; 275)
+            COMMA@[275; 276)
+            WHITESPACE@[276; 285)
+            MATCH_ARM@[285; 292)
+              PLACEHOLDER_PAT@[285; 286)
+                UNDERSCORE@[285; 286)
+              WHITESPACE@[286; 287)
+              FAT_ARROW@[287; 289)
+              WHITESPACE@[289; 290)
+              TUPLE_EXPR@[290; 292)
+                L_PAREN@[290; 291)
+                R_PAREN@[291; 292)
+            COMMA@[292; 293)
+            WHITESPACE@[293; 298)
+            R_CURLY@[298; 299)
+      WHITESPACE@[299; 305)
+      IF_EXPR@[305; 339)
+        IF_KW@[305; 307)
+        WHITESPACE@[307; 308)
+        CONDITION@[308; 331)
+          LET_KW@[308; 311)
+          WHITESPACE@[311; 312)
+          TUPLE_STRUCT_PAT@[312; 320)
+            PATH@[312; 316)
+              PATH_SEGMENT@[312; 316)
+                NAME_REF@[312; 316)
+                  IDENT@[312; 316) "Some"
+            L_PAREN@[316; 317)
+            LITERAL_PAT@[317; 319)
+              MINUS@[317; 318)
+              LITERAL@[318; 319)
+                INT_NUMBER@[318; 319) "1"
+            R_PAREN@[319; 320)
+          WHITESPACE@[320; 321)
+          EQ@[321; 322)
+          WHITESPACE@[322; 323)
+          CALL_EXPR@[323; 331)
+            PATH_EXPR@[323; 327)
+              PATH@[323; 327)
+                PATH_SEGMENT@[323; 327)
+                  NAME_REF@[323; 327)
+                    IDENT@[323; 327) "Some"
+            ARG_LIST@[327; 331)
+              L_PAREN@[327; 328)
+              PREFIX_EXPR@[328; 330)
+                MINUS@[328; 329)
+                LITERAL@[329; 330)
+                  INT_NUMBER@[329; 330) "1"
+              R_PAREN@[330; 331)
+        WHITESPACE@[331; 332)
+        BLOCK@[332; 339)
+          L_CURLY@[332; 333)
+          WHITESPACE@[333; 338)
+          R_CURLY@[338; 339)
+      WHITESPACE@[339; 340)
+      R_CURLY@[340; 341)
+  WHITESPACE@[341; 343)
+  ENUM_DEF@[343; 367)
+    ENUM_KW@[343; 347)
+    WHITESPACE@[347; 348)
+    NAME@[348; 349)
+      IDENT@[348; 349) "A"
+    WHITESPACE@[349; 350)
+    ENUM_VARIANT_LIST@[350; 367)
+      L_CURLY@[350; 351)
+      WHITESPACE@[351; 356)
+      ENUM_VARIANT@[356; 365)
+        NAME@[356; 357)
+          IDENT@[356; 357) "B"
+        POS_FIELD_DEF_LIST@[357; 365)
+          L_PAREN@[357; 358)
+          POS_FIELD_DEF@[358; 360)
+            PATH_TYPE@[358; 360)
+              PATH@[358; 360)
+                PATH_SEGMENT@[358; 360)
+                  NAME_REF@[358; 360)
+                    IDENT@[358; 360) "i8"
+          COMMA@[360; 361)
+          WHITESPACE@[361; 362)
+          POS_FIELD_DEF@[362; 364)
+            PATH_TYPE@[362; 364)
+              PATH@[362; 364)
+                PATH_SEGMENT@[362; 364)
+                  NAME_REF@[362; 364)
+                    IDENT@[362; 364) "i8"
+          R_PAREN@[364; 365)
+      WHITESPACE@[365; 366)
+      R_CURLY@[366; 367)
+  WHITESPACE@[367; 369)
+  FN_DEF@[369; 394)
+    FN_KW@[369; 371)
+    WHITESPACE@[371; 372)
+    NAME@[372; 375)
+      IDENT@[372; 375) "foo"
+    PARAM_LIST@[375; 391)
+      L_PAREN@[375; 376)
+      PARAM@[376; 390)
+        RANGE_PAT@[376; 386)
+          LITERAL_PAT@[376; 380)
+            MINUS@[376; 377)
+            LITERAL@[377; 380)
+              INT_NUMBER@[377; 380) "128"
+          DOTDOTEQ@[380; 383)
+          LITERAL_PAT@[383; 386)
+            LITERAL@[383; 386)
+              INT_NUMBER@[383; 386) "127"
+        COLON@[386; 387)
+        WHITESPACE@[387; 388)
+        PATH_TYPE@[388; 390)
+          PATH@[388; 390)
+            PATH_SEGMENT@[388; 390)
+              NAME_REF@[388; 390)
+                IDENT@[388; 390) "i8"
+      R_PAREN@[390; 391)
+    WHITESPACE@[391; 392)
+    BLOCK@[392; 394)
+      L_CURLY@[392; 393)
+      R_CURLY@[393; 394)
+  WHITESPACE@[394; 395)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs
new file mode 100644
index 000000000..871720a49
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.rs
@@ -0,0 +1,17 @@
+// https://github.com/rust-analyzer/rust-analyzer/pull/983
+fn compound_assignment() {
+    let mut a = 0;
+    a += 1;
+    a -= 2;
+    a *= 3;
+    a %= 4;
+    a /= 5;
+    a |= 6;
+    a &= 7;
+    a ^= 8;
+    a <= 9;
+    a >= 10;
+    a >>= 11;
+    a <<= 12;
+}
diff --git a/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt
new file mode 100644
index 000000000..c5ff06823
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0048_compound_assignment.txt
@@ -0,0 +1,200 @@
+SOURCE_FILE@[0; 257)
+  COMMENT@[0; 58)
+  WHITESPACE@[58; 60)
+  FN_DEF@[60; 256)
+    FN_KW@[60; 62)
+    WHITESPACE@[62; 63)
+    NAME@[63; 82)
+      IDENT@[63; 82) "compound_assignment"
+    PARAM_LIST@[82; 84)
+      L_PAREN@[82; 83)
+      R_PAREN@[83; 84)
+    WHITESPACE@[84; 85)
+    BLOCK@[85; 256)
+      L_CURLY@[85; 86)
+      WHITESPACE@[86; 91)
+      LET_STMT@[91; 105)
+        LET_KW@[91; 94)
+        WHITESPACE@[94; 95)
+        BIND_PAT@[95; 100)
+          MUT_KW@[95; 98)
+          WHITESPACE@[98; 99)
+          NAME@[99; 100)
+            IDENT@[99; 100) "a"
+        WHITESPACE@[100; 101)
+        EQ@[101; 102)
+        WHITESPACE@[102; 103)
+        LITERAL@[103; 104)
+          INT_NUMBER@[103; 104) "0"
+        SEMI@[104; 105)
+      WHITESPACE@[105; 110)
+      EXPR_STMT@[110; 117)
+        BIN_EXPR@[110; 116)
+          PATH_EXPR@[110; 111)
+            PATH@[110; 111)
+              PATH_SEGMENT@[110; 111)
+                NAME_REF@[110; 111)
+                  IDENT@[110; 111) "a"
+          WHITESPACE@[111; 112)
+          PLUSEQ@[112; 114)
+          WHITESPACE@[114; 115)
+          LITERAL@[115; 116)
+            INT_NUMBER@[115; 116) "1"
+        SEMI@[116; 117)
+      WHITESPACE@[117; 122)
+      EXPR_STMT@[122; 129)
+        BIN_EXPR@[122; 128)
+          PATH_EXPR@[122; 123)
+            PATH@[122; 123)
+              PATH_SEGMENT@[122; 123)
+                NAME_REF@[122; 123)
+                  IDENT@[122; 123) "a"
+          WHITESPACE@[123; 124)
+          MINUSEQ@[124; 126)
+          WHITESPACE@[126; 127)
+          LITERAL@[127; 128)
+            INT_NUMBER@[127; 128) "2"
+        SEMI@[128; 129)
+      WHITESPACE@[129; 134)
+      EXPR_STMT@[134; 141)
+        BIN_EXPR@[134; 140)
+          PATH_EXPR@[134; 135)
+            PATH@[134; 135)
+              PATH_SEGMENT@[134; 135)
+                NAME_REF@[134; 135)
+                  IDENT@[134; 135) "a"
+          WHITESPACE@[135; 136)
+          STAREQ@[136; 138)
+          WHITESPACE@[138; 139)
+          LITERAL@[139; 140)
+            INT_NUMBER@[139; 140) "3"
+        SEMI@[140; 141)
+      WHITESPACE@[141; 146)
+      EXPR_STMT@[146; 153)
+        BIN_EXPR@[146; 152)
+          PATH_EXPR@[146; 147)
+            PATH@[146; 147)
+              PATH_SEGMENT@[146; 147)
+                NAME_REF@[146; 147)
+                  IDENT@[146; 147) "a"
+          WHITESPACE@[147; 148)
+          PERCENTEQ@[148; 150)
+          WHITESPACE@[150; 151)
+          LITERAL@[151; 152)
+            INT_NUMBER@[151; 152) "4"
+        SEMI@[152; 153)
+      WHITESPACE@[153; 158)
+      EXPR_STMT@[158; 165)
+        BIN_EXPR@[158; 164)
+          PATH_EXPR@[158; 159)
+            PATH@[158; 159)
+              PATH_SEGMENT@[158; 159)
+                NAME_REF@[158; 159)
+                  IDENT@[158; 159) "a"
+          WHITESPACE@[159; 160)
+          SLASHEQ@[160; 162)
+          WHITESPACE@[162; 163)
+          LITERAL@[163; 164)
+            INT_NUMBER@[163; 164) "5"
+        SEMI@[164; 165)
+      WHITESPACE@[165; 170)
+      EXPR_STMT@[170; 177)
+        BIN_EXPR@[170; 176)
+          PATH_EXPR@[170; 171)
+            PATH@[170; 171)
+              PATH_SEGMENT@[170; 171)
+                NAME_REF@[170; 171)
+                  IDENT@[170; 171) "a"
+          WHITESPACE@[171; 172)
+          PIPEEQ@[172; 174)
+          WHITESPACE@[174; 175)
+          LITERAL@[175; 176)
+            INT_NUMBER@[175; 176) "6"
+        SEMI@[176; 177)
+      WHITESPACE@[177; 182)
+      EXPR_STMT@[182; 189)
+        BIN_EXPR@[182; 188)
+          PATH_EXPR@[182; 183)
+            PATH@[182; 183)
+              PATH_SEGMENT@[182; 183)
+                NAME_REF@[182; 183)
+                  IDENT@[182; 183) "a"
+          WHITESPACE@[183; 184)
+          AMPEQ@[184; 186)
+          WHITESPACE@[186; 187)
+          LITERAL@[187; 188)
+            INT_NUMBER@[187; 188) "7"
+        SEMI@[188; 189)
+      WHITESPACE@[189; 194)
+      EXPR_STMT@[194; 201)
+        BIN_EXPR@[194; 200)
+          PATH_EXPR@[194; 195)
+            PATH@[194; 195)
+              PATH_SEGMENT@[194; 195)
+                NAME_REF@[194; 195)
+                  IDENT@[194; 195) "a"
+          WHITESPACE@[195; 196)
+          CARETEQ@[196; 198)
+          WHITESPACE@[198; 199)
+          LITERAL@[199; 200)
+            INT_NUMBER@[199; 200) "8"
+        SEMI@[200; 201)
+      WHITESPACE@[201; 206)
+      EXPR_STMT@[206; 213)
+        BIN_EXPR@[206; 212)
+          PATH_EXPR@[206; 207)
+            PATH@[206; 207)
+              PATH_SEGMENT@[206; 207)
+                NAME_REF@[206; 207)
+                  IDENT@[206; 207) "a"
+          WHITESPACE@[207; 208)
+          LTEQ@[208; 210)
+          WHITESPACE@[210; 211)
+          LITERAL@[211; 212)
+            INT_NUMBER@[211; 212) "9"
+        SEMI@[212; 213)
+      WHITESPACE@[213; 218)
+      EXPR_STMT@[218; 226)
+        BIN_EXPR@[218; 225)
+          PATH_EXPR@[218; 219)
+            PATH@[218; 219)
+              PATH_SEGMENT@[218; 219)
+                NAME_REF@[218; 219)
+                  IDENT@[218; 219) "a"
+          WHITESPACE@[219; 220)
+          GTEQ@[220; 222)
+          WHITESPACE@[222; 223)
+          LITERAL@[223; 225)
+            INT_NUMBER@[223; 225) "10"
+        SEMI@[225; 226)
+      WHITESPACE@[226; 231)
+      EXPR_STMT@[231; 240)
+        BIN_EXPR@[231; 239)
+          PATH_EXPR@[231; 232)
+            PATH@[231; 232)
+              PATH_SEGMENT@[231; 232)
+                NAME_REF@[231; 232)
+                  IDENT@[231; 232) "a"
+          WHITESPACE@[232; 233)
+          SHREQ@[233; 236)
+          WHITESPACE@[236; 237)
+          LITERAL@[237; 239)
+            INT_NUMBER@[237; 239) "11"
+        SEMI@[239; 240)
+      WHITESPACE@[240; 245)
+      EXPR_STMT@[245; 254)
+        BIN_EXPR@[245; 253)
+          PATH_EXPR@[245; 246)
+            PATH@[245; 246)
+              PATH_SEGMENT@[245; 246)
+                NAME_REF@[245; 246)
+                  IDENT@[245; 246) "a"
+          WHITESPACE@[246; 247)
+          SHLEQ@[247; 250)
+          WHITESPACE@[250; 251)
+          LITERAL@[251; 253)
+            INT_NUMBER@[251; 253) "12"
+        SEMI@[253; 254)
+      WHITESPACE@[254; 255)
+      R_CURLY@[255; 256)
+  WHITESPACE@[256; 257)
diff --git a/crates/test_utils/src/marks.rs b/crates/test_utils/src/marks.rs
index 107432926..1c268b49c 100644
--- a/crates/test_utils/src/marks.rs
+++ b/crates/test_utils/src/marks.rs
@@ -30,13 +30,13 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 #[macro_export]
 macro_rules! tested_by {
-    ($ident:ident) => {
+    ($ident:ident) => {{
        #[cfg(test)]
        {
            // sic! use call-site crate
            crate::marks::$ident.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        }
-    };
+    }};
 }
 #[macro_export]
diff --git a/editors/README.md b/editors/README.md
index 6e1189cad..ddc6ee048 100644
--- a/editors/README.md
+++ b/editors/README.md
@@ -1,5 +1,5 @@
-Preqrequisites:
+Prerequisites:
 In order to build the VS Code plugin, you need to have node.js and npm with
 a minimum version of 10 installed. Please refer to
diff --git a/editors/code/package.json b/editors/code/package.json
index 0a1e84b4a..3834f2847 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -46,7 +46,8 @@
    "activationEvents": [
        "onLanguage:rust",
        "onCommand:rust-analyzer.analyzerStatus",
-        "onCommand:rust-analyzer.collectGarbage"
+        "onCommand:rust-analyzer.collectGarbage",
+        "workspaceContains:**/Cargo.toml"
    ],
    "main": "./out/extension",
    "contributes": {
diff --git a/editors/emacs/ra-emacs-lsp.el b/editors/emacs/ra-emacs-lsp.el
index 780182f8a..955703edb 100644
--- a/editors/emacs/ra-emacs-lsp.el
+++ b/editors/emacs/ra-emacs-lsp.el
@@ -58,17 +58,16 @@
 (defun rust-analyzer--apply-source-change (data)
  ;; TODO fileSystemEdits
-  (--each (-> data (ht-get "workspaceEdit") (ht-get "documentChanges"))
+  (seq-doseq (it (-> data (ht-get "workspaceEdit") (ht-get "documentChanges")))
    (rust-analyzer--apply-text-document-edit it))
  (-when-let (cursor-position (ht-get data "cursorPosition"))
    (let ((filename (rust-analyzer--uri-filename (ht-get cursor-position "textDocument")))
          (position (ht-get cursor-position "position")))
      (find-file filename)
-      (rust-analyzer--goto-lsp-loc position)
+      (rust-analyzer--goto-lsp-loc position))))
-      )))
 (defun rust-analyzer--apply-source-change-command (p)
-  (let ((data (-> p (ht-get "arguments") (car))))
+  (let ((data (-> p (ht-get "arguments") (seq-first))))
    (rust-analyzer--apply-source-change data)))
 (lsp-register-client
@@ -126,7 +125,7 @@
     "rust-analyzer/extendSelection"
     (rust-analyzer--extend-selection-params)))
   (ht-get "selections")
-   (car)))
+   (seq-first)))
 (defun rust-analyzer--add-er-expansion ()
  (make-variable-buffer-local 'er/try-expand-list)