72 files changed, 1584 insertions, 704 deletions

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 58c8f083a..29e388e7c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -7,14 +7,18 @@ on:
     - staging
     - trying
 
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CC: deny_c
+  RUN_SLOW_TESTS: 1
+  RUSTFLAGS: -D warnings
+  RUSTUP_MAX_RETRIES: 10
+
 jobs:
   rust-audit:
     name: Audit Rust vulnerabilities
     runs-on: ubuntu-latest
-    env:
-      RUSTUP_MAX_RETRIES: 10
-      CARGO_NET_RETRY: 10
-
     steps:
     - name: Install Rust toolchain
       uses: actions-rs/toolchain@v1
@@ -46,14 +50,6 @@ jobs:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
 
-    env:
-      RUSTFLAGS: -D warnings
-      CC: deny_c
-      CARGO_INCREMENTAL: 0
-      RUN_SLOW_TESTS: 1
-      RUSTUP_MAX_RETRIES: 10
-      CARGO_NET_RETRY: 10
-
     steps:
     - name: Checkout repository
       uses: actions/checkout@v2
@@ -111,9 +107,6 @@ jobs:
   typescript:
     name: TypeScript
     runs-on: ubuntu-latest
-    env:
-      CXX: g++-4.9
-      CC: gcc-4.9
     steps:
     - name: Checkout repository
       uses: actions/checkout@v2
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index c055d113d..fd184e8f1 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -8,6 +8,12 @@ on:
     - release
     - nightly
 
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTFLAGS: -D warnings
+  RUSTUP_MAX_RETRIES: 10
+
 jobs:
   dist:
     name: dist
@@ -16,12 +22,6 @@ jobs:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
 
-    env:
-      RUSTFLAGS: -D warnings
-      CARGO_INCREMENTAL: 0
-      RUSTUP_MAX_RETRIES: 10
-      CARGO_NET_RETRY: 10
-
     steps:
     - name: Checkout repository
       uses: actions/checkout@v2
diff --git a/.github/workflows/rustdoc.yaml b/.github/workflows/rustdoc.yaml
index c84ce5d48..cf4bca840 100644
--- a/.github/workflows/rustdoc.yaml
+++ b/.github/workflows/rustdoc.yaml
@@ -4,12 +4,15 @@ on:
    branches:
    - master
 
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTFLAGS: -D warnings
+  RUSTUP_MAX_RETRIES: 10
+
 jobs:
   rustdoc:
     runs-on: ubuntu-latest
-    env:
-      RUSTFLAGS: -D warnings
-      CARGO_INCREMENTAL: 0
 
     steps:
     - name: Checkout repository
diff --git a/Cargo.lock b/Cargo.lock
index eb5247b69..908319f87 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -170,7 +170,7 @@ dependencies = [
  "chalk-macros",
  "chalk-rust-ir",
  "ena",
- "itertools",
+ "itertools 0.8.2",
  "petgraph",
  "rustc-hash",
 ]
@@ -521,6 +521,15 @@ dependencies = [
 ]
 
 [[package]]
+name = "itertools"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
+dependencies = [
+ "either",
+]
+
+[[package]]
 name = "itoa"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -875,8 +884,9 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
+ "either",
  "format-buf",
- "itertools",
+ "itertools 0.9.0",
  "join_to_string",
  "ra_db",
  "ra_fmt",
@@ -928,7 +938,7 @@ dependencies = [
 name = "ra_fmt"
 version = "0.1.0"
 dependencies = [
- "itertools",
+ "itertools 0.9.0",
  "ra_syntax",
 ]
 
@@ -938,7 +948,7 @@ version = "0.1.0"
 dependencies = [
  "arrayvec",
  "either",
- "itertools",
+ "itertools 0.9.0",
  "log",
  "ra_db",
  "ra_hir_def",
@@ -1015,7 +1025,7 @@ dependencies = [
  "format-buf",
  "indexmap",
  "insta",
- "itertools",
+ "itertools 0.9.0",
  "join_to_string",
  "log",
  "ra_assists",
@@ -1036,6 +1046,7 @@ dependencies = [
 name = "ra_ide_db"
 version = "0.1.0"
 dependencies = [
+ "either",
  "fst",
  "log",
  "once_cell",
@@ -1101,7 +1112,7 @@ name = "ra_syntax"
 version = "0.1.0"
 dependencies = [
  "arrayvec",
- "itertools",
+ "itertools 0.9.0",
  "once_cell",
  "ra_parser",
  "ra_text_edit",
@@ -1278,7 +1289,7 @@ dependencies = [
  "crossbeam-channel",
  "env_logger",
  "globset",
- "itertools",
+ "itertools 0.9.0",
  "jod-thread",
  "log",
  "lsp-server",
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 85adddb5b..a87f4052a 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -11,7 +11,8 @@ doctest = false
 format-buf = "1.0.0"
 join_to_string = "0.1.3"
 rustc-hash = "1.1.0"
-itertools = "0.8.2"
+itertools = "0.9.0"
+either = "1.5.3"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 62182cf03..c3e653299 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -11,6 +11,7 @@ use ra_syntax::{
 use ra_text_edit::TextEditBuilder;
 
 use crate::{AssistAction, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
+use algo::SyntaxRewriter;
 
 #[derive(Clone, Debug)]
 pub(crate) struct Assist(pub(crate) Vec<AssistInfo>);
@@ -234,6 +235,11 @@ impl ActionBuilder {
     pub(crate) fn replace_ast<N: AstNode>(&mut self, old: N, new: N) {
         algo::diff(old.syntax(), new.syntax()).into_text_edit(&mut self.edit)
     }
+    pub(crate) fn rewrite(&mut self, rewriter: SyntaxRewriter) {
+        let node = rewriter.rewrite_root().unwrap();
+        let new = rewriter.rewrite(&node);
+        algo::diff(&node, &new).into_text_edit(&mut self.edit)
+    }
 
     fn build(self) -> AssistAction {
         AssistAction {
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 45558c448..52b4c82db 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -3,7 +3,10 @@ use rustc_hash::FxHashMap;
 
 use hir::{PathResolution, SemanticsScope};
 use ra_ide_db::RootDatabase;
-use ra_syntax::ast::{self, AstNode};
+use ra_syntax::{
+    algo::SyntaxRewriter,
+    ast::{self, AstNode},
+};
 
 pub trait AstTransform<'a> {
     fn get_substitution(&self, node: &ra_syntax::SyntaxNode) -> Option<ra_syntax::SyntaxNode>;
@@ -153,15 +156,14 @@ impl<'a> QualifyPaths<'a> {
 }
 
 pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
-    let syntax = node.syntax();
-    let result = ra_syntax::algo::replace_descendants(syntax, |element| match element {
+    SyntaxRewriter::from_fn(|element| match element {
         ra_syntax::SyntaxElement::Node(n) => {
             let replacement = transformer.get_substitution(&n)?;
             Some(replacement.into())
         }
         _ => None,
-    });
-    N::cast(result).unwrap()
+    })
+    .rewrite_ast(&node)
 }
 
 impl<'a> AstTransform<'a> for QualifyPaths<'a> {
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index aef6793e8..62dcb3808 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -275,8 +275,8 @@ enum Action { Move { distance: u32 }, Stop }
 
 fn handle(action: Action) {
     match action {
-        Action::Move { distance } => (),
-        Action::Stop => (),
+        Action::Move { distance } => {}
+        Action::Stop => {}
     }
 }
 "#####,
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index e5920b6f6..722f207e2 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -151,7 +151,7 @@ fn add_missing_impl_members_inner(
                 ast::ImplItem::FnDef(def) => ast::ImplItem::FnDef(add_body(def)),
                 _ => it,
             })
-            .map(|it| edit::strip_attrs_and_docs(&it));
+            .map(|it| edit::remove_attrs_and_docs(&it));
         let new_impl_item_list = impl_item_list.append_items(items);
         let cursor_position = {
             let first_new_item = new_impl_item_list.impl_items().nth(n_existing_items).unwrap();
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index bb280f633..99682e023 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -17,6 +17,7 @@ use crate::{
     utils::insert_use_statement,
     AssistId,
 };
+use either::Either;
 
 // Assist: auto_import
 //
@@ -58,6 +59,7 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
     group.finish()
 }
 
+#[derive(Debug)]
 struct AutoImportAssets {
     import_candidate: ImportCandidate,
     module_with_name_to_import: Module,
@@ -127,14 +129,14 @@ impl AutoImportAssets {
         ImportsLocator::new(db)
             .find_imports(&self.get_search_query())
             .into_iter()
-            .filter_map(|module_def| match &self.import_candidate {
+            .filter_map(|candidate| match &self.import_candidate {
                 ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
-                    let located_assoc_item = match module_def {
-                        ModuleDef::Function(located_function) => located_function
+                    let located_assoc_item = match candidate {
+                        Either::Left(ModuleDef::Function(located_function)) => located_function
                             .as_assoc_item(db)
                             .map(|assoc| assoc.container(db))
                             .and_then(Self::assoc_to_trait),
-                        ModuleDef::Const(located_const) => located_const
+                        Either::Left(ModuleDef::Const(located_const)) => located_const
                             .as_assoc_item(db)
                             .map(|assoc| assoc.container(db))
                             .and_then(Self::assoc_to_trait),
@@ -153,10 +155,11 @@ impl AutoImportAssets {
                             |_, assoc| Self::assoc_to_trait(assoc.container(db)),
                         )
                         .map(ModuleDef::from)
+                        .map(Either::Left)
                 }
                 ImportCandidate::TraitMethod(function_callee, _) => {
                     let located_assoc_item =
-                        if let ModuleDef::Function(located_function) = module_def {
+                        if let Either::Left(ModuleDef::Function(located_function)) = candidate {
                             located_function
                                 .as_assoc_item(db)
                                 .map(|assoc| assoc.container(db))
@@ -179,10 +182,18 @@ impl AutoImportAssets {
                             },
                         )
                         .map(ModuleDef::from)
+                        .map(Either::Left)
+                }
+                _ => Some(candidate),
+            })
+            .filter_map(|candidate| match candidate {
+                Either::Left(module_def) => {
+                    self.module_with_name_to_import.find_use_path(db, module_def)
+                }
+                Either::Right(macro_def) => {
+                    self.module_with_name_to_import.find_use_path(db, macro_def)
                 }
-                _ => Some(module_def),
             })
-            .filter_map(|module_def| self.module_with_name_to_import.find_use_path(db, module_def))
             .filter(|use_path| !use_path.segments.is_empty())
             .take(20)
             .collect::<BTreeSet<_>>()
@@ -440,6 +451,30 @@ mod tests {
     }
 
     #[test]
+    fn macro_import() {
+        check_assist(
+            auto_import,
+            r"
+                    //- /lib.rs crate:crate_with_macro
+                    #[macro_export]
+                    macro_rules! foo {
+                        () => ()
+                    }
+
+                    //- /main.rs crate:main deps:crate_with_macro
+                    fn main() {
+                        foo<|>
+                    }",
+            r"use crate_with_macro::foo;
+
+fn main() {
+    foo<|>
+}
+",
+        );
+    }
+
+    #[test]
     fn auto_import_target() {
         check_assist_target(
             auto_import,
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index 54e0a6c84..cd6d1ee6c 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -2,13 +2,14 @@ use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
     SyntaxKind::{
-        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, IDENT, MODULE, STRUCT_DEF, TRAIT_DEF,
-        VISIBILITY, WHITESPACE,
+        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
+        WHITESPACE,
     },
     SyntaxNode, TextUnit, T,
 };
 
 use crate::{Assist, AssistCtx, AssistId};
+use test_utils::tested_by;
 
 // Assist: change_visibility
 //
@@ -47,13 +48,16 @@ fn add_vis(ctx: AssistCtx) -> Option<Assist> {
         }
         (vis_offset(&parent), keyword.text_range())
     } else {
-        let ident = ctx.token_at_offset().find(|leaf| leaf.kind() == IDENT)?;
-        let field = ident.parent().ancestors().find_map(ast::RecordFieldDef::cast)?;
-        if field.name()?.syntax().text_range() != ident.text_range() && field.visibility().is_some()
-        {
+        let field_name: ast::Name = ctx.find_node_at_offset()?;
+        let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
+        if field.name()? != field_name {
+            tested_by!(change_visibility_field_false_positive);
             return None;
         }
-        (vis_offset(field.syntax()), ident.text_range())
+        if field.visibility().is_some() {
+            return None;
+        }
+        (vis_offset(field.syntax()), field_name.syntax().text_range())
     };
 
     ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub(crate)", |edit| {
@@ -98,8 +102,11 @@ fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
 
 #[cfg(test)]
 mod tests {
+    use test_utils::covers;
+
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+
     use super::*;
-    use crate::helpers::{check_assist, check_assist_target};
 
     #[test]
     fn change_visibility_adds_pub_crate_to_items() {
@@ -120,8 +127,17 @@ mod tests {
     fn change_visibility_works_with_struct_fields() {
         check_assist(
             change_visibility,
-            "struct S { <|>field: u32 }",
-            "struct S { <|>pub(crate) field: u32 }",
+            r"struct S { <|>field: u32 }",
+            r"struct S { <|>pub(crate) field: u32 }",
+        )
+    }
+
+    #[test]
+    fn change_visibility_field_false_positive() {
+        covers!(change_visibility_field_false_positive);
+        check_assist_not_applicable(
+            change_visibility,
+            r"struct S { field: [(); { let <|>x = ();}] }",
         )
     }
 
@@ -144,7 +160,7 @@ mod tests {
     fn change_visibility_handles_comment_attrs() {
         check_assist(
             change_visibility,
-            "
+            r"
             /// docs
 
             // comments
@@ -152,7 +168,7 @@ mod tests {
             #[derive(Debug)]
             <|>struct Foo;
             ",
-            "
+            r"
             /// docs
 
             // comments
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 7463b2af7..add82e5b1 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -2,7 +2,7 @@
 
 use std::iter;
 
-use hir::{Adt, HasSource, Semantics};
+use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 
@@ -30,8 +30,8 @@ use ast::{MatchArm, Pat};
 //
 // fn handle(action: Action) {
 //     match action {
-//         Action::Move { distance } => (),
-//         Action::Stop => (),
+//         Action::Move { distance } => {}
+//         Action::Stop => {}
 //     }
 // }
 // ```
@@ -57,7 +57,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
             .into_iter()
             .filter_map(|variant| build_pat(ctx.db, module, variant))
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
-            .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()))
+            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect()
     } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
         // Partial fill not currently supported for tuple of enums.
@@ -86,7 +86,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
                 ast::Pat::from(make::tuple_pat(patterns))
             })
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
-            .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()))
+            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect()
     } else {
         return None;
@@ -154,7 +154,7 @@ fn resolve_tuple_of_enum_def(
 }
 
 fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> Option<ast::Pat> {
-    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
+    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, ModuleDef::from(var))?);
 
     // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
     let pat: ast::Pat = match var.source(db).value.kind() {
@@ -192,8 +192,8 @@ mod tests {
             fn main() {
                 match A::As<|> {
                     A::As,
-                    A::Bs{x,y:Some(_)} => (),
-                    A::Cs(_, Some(_)) => (),
+                    A::Bs{x,y:Some(_)} => {}
+                    A::Cs(_, Some(_)) => {}
                 }
             }
             "#,
@@ -227,8 +227,8 @@ mod tests {
             }
             fn main() {
                 match A::As<|> {
-                    A::Bs{x,y:Some(_)} => (),
-                    A::Cs(_, Some(_)) => (),
+                    A::Bs{x,y:Some(_)} => {}
+                    A::Cs(_, Some(_)) => {}
                 }
             }
             "#,
@@ -240,9 +240,9 @@ mod tests {
             }
             fn main() {
                 match <|>A::As {
-                    A::Bs{x,y:Some(_)} => (),
-                    A::Cs(_, Some(_)) => (),
-                    A::As => (),
+                    A::Bs{x,y:Some(_)} => {}
+                    A::Cs(_, Some(_)) => {}
+                    A::As => {}
                 }
             }
             "#,
@@ -261,7 +261,7 @@ mod tests {
             }
             fn main() {
                 match A::As<|> {
-                    A::Cs(_) | A::Bs => (),
+                    A::Cs(_) | A::Bs => {}
                 }
             }
             "#,
@@ -273,8 +273,8 @@ mod tests {
             }
             fn main() {
                 match <|>A::As {
-                    A::Cs(_) | A::Bs => (),
-                    A::As => (),
+                    A::Cs(_) | A::Bs => {}
+                    A::As => {}
                 }
             }
             "#,
@@ -299,8 +299,8 @@ mod tests {
             }
             fn main() {
                 match A::As<|> {
-                    A::Bs if 0 < 1 => (),
-                    A::Ds(_value) => (),
+                    A::Bs if 0 < 1 => {}
+                    A::Ds(_value) => { let x = 1; }
                     A::Es(B::Xs) => (),
                 }
             }
@@ -319,11 +319,11 @@ mod tests {
             }
             fn main() {
                 match <|>A::As {
-                    A::Bs if 0 < 1 => (),
-                    A::Ds(_value) => (),
+                    A::Bs if 0 < 1 => {}
+                    A::Ds(_value) => { let x = 1; }
                     A::Es(B::Xs) => (),
-                    A::As => (),
-                    A::Cs => (),
+                    A::As => {}
+                    A::Cs => {}
                 }
             }
             "#,
@@ -360,11 +360,11 @@ mod tests {
             fn main() {
                 let a = A::As;
                 match <|>a {
-                    A::As => (),
-                    A::Bs => (),
-                    A::Cs(_) => (),
-                    A::Ds(_, _) => (),
-                    A::Es { x, y } => (),
+                    A::As => {}
+                    A::Bs => {}
+                    A::Cs(_) => {}
+                    A::Ds(_, _) => {}
+                    A::Es { x, y } => {}
                 }
             }
             "#,
@@ -405,10 +405,10 @@ mod tests {
                 let a = A::One;
                 let b = B::One;
                 match <|>(a, b) {
-                    (A::One, B::One) => (),
-                    (A::One, B::Two) => (),
-                    (A::Two, B::One) => (),
-                    (A::Two, B::Two) => (),
+                    (A::One, B::One) => {}
+                    (A::One, B::Two) => {}
+                    (A::Two, B::One) => {}
+                    (A::Two, B::Two) => {}
                 }
             }
             "#,
@@ -449,10 +449,10 @@ mod tests {
                 let a = A::One;
                 let b = B::One;
                 match <|>(&a, &b) {
-                    (A::One, B::One) => (),
-                    (A::One, B::Two) => (),
-                    (A::Two, B::One) => (),
-                    (A::Two, B::Two) => (),
+                    (A::One, B::One) => {}
+                    (A::One, B::Two) => {}
+                    (A::Two, B::One) => {}
+                    (A::Two, B::Two) => {}
                 }
             }
             "#,
@@ -477,7 +477,7 @@ mod tests {
                 let a = A::One;
                 let b = B::One;
                 match (a<|>, b) {
-                    (A::Two, B::One) => (),
+                    (A::Two, B::One) => {}
                 }
             }
             "#,
@@ -502,10 +502,10 @@ mod tests {
                 let a = A::One;
                 let b = B::One;
                 match (a<|>, b) {
-                    (A::Two, B::One) => (),
-                    (A::One, B::One) => (),
-                    (A::One, B::Two) => (),
-                    (A::Two, B::Two) => (),
+                    (A::Two, B::One) => {}
+                    (A::One, B::One) => {}
+                    (A::One, B::Two) => {}
+                    (A::Two, B::Two) => {}
                 }
             }
             "#,
@@ -555,7 +555,7 @@ mod tests {
 
             fn foo(a: &A) {
                 match <|>a {
-                    A::As => (),
+                    A::As => {}
                 }
             }
             "#,
@@ -580,7 +580,7 @@ mod tests {
 
             fn foo(a: &mut A) {
                 match <|>a {
-                    A::Es { x, y } => (),
+                    A::Es { x, y } => {}
                 }
             }
             "#,
@@ -611,7 +611,7 @@ mod tests {
 
             fn main() {
                 match E::X {
-                    <|>_ => {},
+                    <|>_ => {}
                 }
             }
             "#,
@@ -620,8 +620,8 @@ mod tests {
 
             fn main() {
                 match <|>E::X {
-                    E::X => (),
-                    E::Y => (),
+                    E::X => {}
+                    E::Y => {}
                 }
             }
             "#,
@@ -648,8 +648,8 @@ mod tests {
 
             fn main() {
                 match <|>X {
-                    X => (),
-                    foo::E::Y => (),
+                    X => {}
+                    foo::E::Y => {}
                 }
             }
             "#,
diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs
index 89bc975bd..9c57d1e30 100644
--- a/crates/ra_assists/src/handlers/merge_imports.rs
+++ b/crates/ra_assists/src/handlers/merge_imports.rs
@@ -1,9 +1,9 @@
 use std::iter::successors;
 
 use ra_syntax::{
-    algo::neighbor,
+    algo::{neighbor, SyntaxRewriter},
     ast::{self, edit::AstNodeEdit, make},
-    AstNode, AstToken, Direction, InsertPosition, SyntaxElement, TextRange, T,
+    AstNode, Direction, InsertPosition, SyntaxElement, T,
 };
 
 use crate::{Assist, AssistCtx, AssistId};
@@ -22,9 +22,10 @@ use crate::{Assist, AssistCtx, AssistId};
 // ```
 pub(crate) fn merge_imports(ctx: AssistCtx) -> Option<Assist> {
     let tree: ast::UseTree = ctx.find_node_at_offset()?;
-    let (new_tree, to_delete) = if let Some(use_item) =
-        tree.syntax().parent().and_then(ast::UseItem::cast)
-    {
+    let mut rewriter = SyntaxRewriter::default();
+    let mut offset = ctx.frange.range.start();
+
+    if let Some(use_item) = tree.syntax().parent().and_then(ast::UseItem::cast) {
         let (merged, to_delete) = next_prev()
             .filter_map(|dir| neighbor(&use_item, dir))
             .filter_map(|it| Some((it.clone(), it.use_tree()?)))
@@ -32,42 +33,28 @@ pub(crate) fn merge_imports(ctx: AssistCtx) -> Option<Assist> {
                 Some((try_merge_trees(&tree, &use_tree)?, use_item.clone()))
             })?;
 
-        let mut range = to_delete.syntax().text_range();
-        let next_ws = to_delete
-            .syntax()
-            .next_sibling_or_token()
-            .and_then(|it| it.into_token())
-            .and_then(ast::Whitespace::cast);
-        if let Some(ws) = next_ws {
-            range = range.extend_to(&ws.syntax().text_range())
+        rewriter.replace_ast(&tree, &merged);
+        rewriter += to_delete.remove();
+
+        if to_delete.syntax().text_range().end() < offset {
+            offset -= to_delete.syntax().text_range().len();
         }
-        (merged, range)
     } else {
         let (merged, to_delete) = next_prev()
             .filter_map(|dir| neighbor(&tree, dir))
             .find_map(|use_tree| Some((try_merge_trees(&tree, &use_tree)?, use_tree.clone())))?;
 
-        let mut range = to_delete.syntax().text_range();
-        if let Some((dir, nb)) = next_prev().find_map(|dir| Some((dir, neighbor(&to_delete, dir)?)))
-        {
-            let nb_range = nb.syntax().text_range();
-            if dir == Direction::Prev {
-                range = TextRange::from_to(nb_range.end(), range.end());
-            } else {
-                range = TextRange::from_to(range.start(), nb_range.start());
-            }
+        rewriter.replace_ast(&tree, &merged);
+        rewriter += to_delete.remove();
+
+        if to_delete.syntax().text_range().end() < offset {
+            offset -= to_delete.syntax().text_range().len();
         }
-        (merged, range)
     };
 
-    let mut offset = ctx.frange.range.start();
     ctx.add_assist(AssistId("merge_imports"), "Merge imports", |edit| {
-        edit.replace_ast(tree, new_tree);
-        edit.delete(to_delete);
-
-        if to_delete.end() <= offset {
-            offset -= to_delete.len();
-        }
+        edit.rewrite(rewriter);
+        // FIXME: we only need because our diff is imprecise
         edit.set_cursor(offset);
     })
 }
@@ -156,7 +143,7 @@ use std::fmt::Debug;
 use std::fmt<|>::Display;
 ",
             r"
-use std::fmt<|>::{Display, Debug};
+use std::fmt:<|>:{Display, Debug};
 ",
         );
     }
@@ -178,7 +165,57 @@ use std::{fmt<|>::{Debug, Display}};
 use std::{fmt::Debug, fmt<|>::Display};
 ",
             r"
-use std::{fmt<|>::{Display, Debug}};
+use std::{fmt::<|>{Display, Debug}};
+",
+        );
+    }
+
+    #[test]
+    fn removes_just_enough_whitespace() {
+        check_assist(
+            merge_imports,
+            r"
+use foo<|>::bar;
+use foo::baz;
+
+/// Doc comment
+",
+            r"
+use foo<|>::{bar, baz};
+
+/// Doc comment
+",
+        );
+    }
+
+    #[test]
+    fn works_with_trailing_comma() {
+        check_assist(
+            merge_imports,
+            r"
+use {
+    foo<|>::bar,
+    foo::baz,
+};
+",
+            r"
+use {
+    foo<|>::{bar, baz},
+};
+",
+        );
+        check_assist(
+            merge_imports,
+            r"
+use {
+    foo::baz,
+    foo<|>::bar,
+};
+",
+            r"
+use {
+    foo::{bar<|>, baz},
+};
 ",
         );
     }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index b8704ea7d..bcc9b3f10 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -165,7 +165,6 @@ mod helpers {
 
     use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
     use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-    use ra_syntax::TextRange;
     use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
 
     use crate::{AssistCtx, AssistHandler};
@@ -175,8 +174,7 @@ mod helpers {
         let (mut db, file_id) = RootDatabase::with_single_file(text);
         // FIXME: ideally, this should be done by the above `RootDatabase::with_single_file`,
         // but it looks like this might need specialization? :(
-        let local_roots = vec![db.file_source_root(file_id)];
-        db.set_local_roots(Arc::new(local_roots));
+        db.set_local_roots(Arc::new(vec![db.file_source_root(file_id)]));
         (db, file_id)
     }
 
@@ -206,11 +204,24 @@ mod helpers {
     }
 
     fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
-        let (range_or_offset, before) = extract_range_or_offset(before);
-        let range: TextRange = range_or_offset.into();
+        let (text_without_caret, file_with_caret_id, range_or_offset, db) =
+            if before.contains("//-") {
+                let (mut db, position) = RootDatabase::with_position(before);
+                db.set_local_roots(Arc::new(vec![db.file_source_root(position.file_id)]));
+                (
+                    db.file_text(position.file_id).as_ref().to_owned(),
+                    position.file_id,
+                    RangeOrOffset::Offset(position.offset),
+                    db,
+                )
+            } else {
+                let (range_or_offset, text_without_caret) = extract_range_or_offset(before);
+                let (db, file_id) = with_single_file(&text_without_caret);
+                (text_without_caret, file_id, range_or_offset, db)
+            };
+
+        let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
 
-        let (db, file_id) = with_single_file(&before);
-        let frange = FileRange { file_id, range };
         let sema = Semantics::new(&db);
         let assist_ctx = AssistCtx::new(&sema, frange, true);
 
@@ -218,7 +229,7 @@ mod helpers {
             (Some(assist), ExpectedResult::After(after)) => {
                 let action = assist.0[0].action.clone().unwrap();
 
-                let mut actual = action.edit.apply(&before);
+                let mut actual = action.edit.apply(&text_without_caret);
                 match action.cursor_position {
                     None => {
                         if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
@@ -237,7 +248,7 @@ mod helpers {
             (Some(assist), ExpectedResult::Target(target)) => {
                 let action = assist.0[0].action.clone().unwrap();
                 let range = action.target.expect("expected target on action");
-                assert_eq_text!(&before[range], target);
+                assert_eq_text!(&text_without_caret[range], target);
             }
             (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
             (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
diff --git a/crates/ra_assists/src/marks.rs b/crates/ra_assists/src/marks.rs
index 22404ee80..6c2a2b8b6 100644
--- a/crates/ra_assists/src/marks.rs
+++ b/crates/ra_assists/src/marks.rs
@@ -7,4 +7,5 @@ test_utils::marks![
     not_applicable_outside_of_bind_pat
     test_not_inline_mut_variable
     test_not_applicable_if_variable_unused
+    change_visibility_field_false_positive
 ];
diff --git a/crates/ra_fmt/Cargo.toml b/crates/ra_fmt/Cargo.toml
index ea9befeaf..e9d057afc 100644
--- a/crates/ra_fmt/Cargo.toml
+++ b/crates/ra_fmt/Cargo.toml
@@ -9,6 +9,6 @@ publish = false
 doctest = false
 
 [dependencies]
-itertools = "0.8.2"
+itertools = "0.9.0"
 
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 42193b492..ba7b39a19 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -13,7 +13,7 @@ rustc-hash = "1.1.0"
 either = "1.5.3"
 arrayvec = "0.5.1"
 
-itertools = "0.8.2"
+itertools = "0.9.0"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_db = { path = "../ra_db" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index e91abf6f5..cd2a8fc62 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -33,7 +33,11 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-use crate::{db::HirDatabase, has_source::HasSource, CallableDef, HirDisplay, InFile, Name};
+use crate::{
+    db::{DefDatabase, HirDatabase},
+    has_source::HasSource,
+    CallableDef, HirDisplay, InFile, Name,
+};
 
 /// hir::Crate describes a single crate. It's the main interface with which
 /// a crate's dependencies interact. Mostly, it should be just a proxy for the
@@ -230,6 +234,10 @@ impl Module {
             .collect()
     }
 
+    pub fn visibility_of(self, db: &dyn HirDatabase, def: &ModuleDef) -> Option<Visibility> {
+        db.crate_def_map(self.id.krate)[self.id.local_id].scope.visibility_of(def.clone().into())
+    }
+
     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
         let _p = profile("Module::diagnostics");
         let crate_def_map = db.crate_def_map(self.id.krate);
@@ -274,20 +282,10 @@ impl Module {
     /// this module, if possible.
     pub fn find_use_path(
         self,
-        db: &dyn HirDatabase,
-        item: ModuleDef,
+        db: &dyn DefDatabase,
+        item: impl Into<ItemInNs>,
     ) -> Option<hir_def::path::ModPath> {
-        // FIXME expose namespace choice
-        hir_def::find_path::find_path(db.upcast(), determine_item_namespace(item), self.into())
-    }
-}
-
-fn determine_item_namespace(module_def: ModuleDef) -> ItemInNs {
-    match module_def {
-        ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
-            ItemInNs::Values(module_def.into())
-        }
-        _ => ItemInNs::Types(module_def.into()),
+        hir_def::find_path::find_path(db, item.into(), self.into())
     }
 }
 
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index fcba95091..ec931b34f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -10,15 +10,16 @@ pub use hir_def::db::{
     TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
-    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternMacroQuery, MacroArgQuery, MacroDefQuery,
-    MacroExpandQuery, ParseMacroQuery,
+    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
+    MacroArgQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
 };
 pub use hir_ty::db::{
     AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
     GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
     HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsForTraitQuery,
     ImplsInCrateQuery, InferQueryQuery, InternAssocTyValueQuery, InternChalkImplQuery,
-    InternTypeCtorQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
+    InternTypeCtorQuery, InternTypeParamIdQuery, StructDatumQuery, TraitDatumQuery,
+    TraitSolveQuery, TyQuery, ValueTyQuery,
 };
 
 #[test]
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index c179b13c6..62fb52e72 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -9,8 +9,8 @@ use hir_def::{
 };
 
 use crate::{
-    Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local, ModuleDef, StructField,
-    VariantDef,
+    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local,
+    MacroDef, ModuleDef, StructField, VariantDef,
 };
 
 macro_rules! from_id {
@@ -228,3 +228,20 @@ impl From<(DefWithBodyId, PatId)> for Local {
         Local { parent, pat_id }
     }
 }
+
+impl From<MacroDef> for ItemInNs {
+    fn from(macro_def: MacroDef) -> Self {
+        ItemInNs::Macros(macro_def.into())
+    }
+}
+
+impl From<ModuleDef> for ItemInNs {
+    fn from(module_def: ModuleDef) -> Self {
+        match module_def {
+            ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
+                ItemInNs::Values(module_def.into())
+            }
+            _ => ItemInNs::Types(module_def.into()),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 713d45f48..5af7e5d6d 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,7 +54,7 @@ pub use crate::{
         Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Const, Crate, CrateDependency,
         DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, HasAttrs,
         HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct,
-        StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
+        StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
     },
     has_source::HasSource,
     semantics::{original_range, PathResolution, Semantics, SemanticsScope},
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index d982f6ffa..16a5fe968 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -173,11 +173,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
     }
 
     pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
-        self.analyze(call.syntax()).resolve_method_call(call)
+        self.analyze(call.syntax()).resolve_method_call(self.db, call)
     }
 
     pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<StructField> {
-        self.analyze(field.syntax()).resolve_field(field)
+        self.analyze(field.syntax()).resolve_field(self.db, field)
     }
 
     pub fn resolve_record_field(
@@ -188,7 +188,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
     }
 
     pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<VariantDef> {
-        self.analyze(record_lit.syntax()).resolve_record_literal(record_lit)
+        self.analyze(record_lit.syntax()).resolve_record_literal(self.db, record_lit)
     }
 
     pub fn resolve_record_pattern(&self, record_pat: &ast::RecordPat) -> Option<VariantDef> {
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 10c12c910..815ca158c 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -78,9 +78,15 @@ impl SourceAnalyzer {
         }
     }
 
-    fn expr_id(&self, expr: &ast::Expr) -> Option<ExprId> {
-        let src = InFile { file_id: self.file_id, value: expr };
-        self.body_source_map.as_ref()?.node_expr(src)
+    fn expr_id(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<ExprId> {
+        let src = match expr {
+            ast::Expr::MacroCall(call) => {
+                self.expand_expr(db, InFile::new(self.file_id, call.clone()))?
+            }
+            _ => InFile::new(self.file_id, expr.clone()),
+        };
+        let sm = self.body_source_map.as_ref()?;
+        sm.node_expr(src.as_ref())
     }
 
     fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
@@ -104,14 +110,7 @@ impl SourceAnalyzer {
     }
 
     pub(crate) fn type_of(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
-        let expr_id = match expr {
-            ast::Expr::MacroCall(call) => {
-                let expr = self.expand_expr(db, InFile::new(self.file_id, call.clone()))?;
-                self.body_source_map.as_ref()?.node_expr(expr.as_ref())
-            }
-            _ => self.expr_id(expr),
-        }?;
-
+        let expr_id = self.expr_id(db, expr)?;
         let ty = self.infer.as_ref()?[expr_id].clone();
         Type::new_with_resolver(db, &self.resolver, ty)
     }
@@ -122,13 +121,21 @@ impl SourceAnalyzer {
         Type::new_with_resolver(db, &self.resolver, ty)
     }
 
-    pub(crate) fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
-        let expr_id = self.expr_id(&call.clone().into())?;
+    pub(crate) fn resolve_method_call(
+        &self,
+        db: &dyn HirDatabase,
+        call: &ast::MethodCallExpr,
+    ) -> Option<Function> {
+        let expr_id = self.expr_id(db, &call.clone().into())?;
         self.infer.as_ref()?.method_resolution(expr_id).map(Function::from)
     }
 
-    pub(crate) fn resolve_field(&self, field: &ast::FieldExpr) -> Option<crate::StructField> {
-        let expr_id = self.expr_id(&field.clone().into())?;
+    pub(crate) fn resolve_field(
+        &self,
+        db: &dyn HirDatabase,
+        field: &ast::FieldExpr,
+    ) -> Option<crate::StructField> {
+        let expr_id = self.expr_id(db, &field.clone().into())?;
         self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
     }
 
@@ -138,7 +145,7 @@ impl SourceAnalyzer {
         field: &ast::RecordField,
     ) -> Option<(crate::StructField, Option<Local>)> {
         let (expr_id, local) = match field.expr() {
-            Some(it) => (self.expr_id(&it)?, None),
+            Some(it) => (self.expr_id(db, &it)?, None),
             None => {
                 let src = InFile { file_id: self.file_id, value: field };
                 let expr_id = self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?;
@@ -159,9 +166,10 @@ impl SourceAnalyzer {
 
     pub(crate) fn resolve_record_literal(
         &self,
+        db: &dyn HirDatabase,
         record_lit: &ast::RecordLit,
     ) -> Option<crate::VariantDef> {
-        let expr_id = self.expr_id(&record_lit.clone().into())?;
+        let expr_id = self.expr_id(db, &record_lit.clone().into())?;
         self.infer.as_ref()?.variant_resolution_for_expr(expr_id).map(|it| it.into())
     }
 
@@ -207,7 +215,7 @@ impl SourceAnalyzer {
         path: &ast::Path,
     ) -> Option<PathResolution> {
         if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
-            let expr_id = self.expr_id(&path_expr.into())?;
+            let expr_id = self.expr_id(db, &path_expr.into())?;
             if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
                 return Some(PathResolution::AssocItem(assoc.into()));
             }
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 7f8c1ea21..5dc7395f5 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -48,6 +48,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
 
     #[salsa::invoke(crate_def_map_wait)]
+    #[salsa::transparent]
     fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
 
     #[salsa::invoke(CrateDefMap::crate_def_map_query)]
@@ -109,12 +110,6 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
 }
 
-// impl<T: DefDatabase> Upcast<dyn AstDatabase> for T {
-//     fn upcast(&self) -> &dyn AstDatabase {
-//         &*self
-//     }
-// }
-
 fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
     let _p = profile("crate_def_map:wait");
     db.crate_def_map_query(krate)
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index 5e943b780..259b9ff03 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -68,6 +68,12 @@ impl ItemScope {
         self.impls.iter().copied()
     }
 
+    pub fn visibility_of(&self, def: ModuleDefId) -> Option<Visibility> {
+        self.name_of(ItemInNs::Types(def))
+            .or_else(|| self.name_of(ItemInNs::Values(def)))
+            .map(|(_, v)| v)
+    }
+
     /// Iterate over all module scoped macros
     pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
         self.visible.iter().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 516dd773e..bd32ac20a 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -475,6 +475,12 @@ impl AsMacroCall for AstIdWithPath<ast::ModuleItem> {
         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
     ) -> Option<MacroCallId> {
         let def = resolver(self.path.clone())?;
-        Some(def.as_lazy_macro(db.upcast(), MacroCallKind::Attr(self.ast_id)).into())
+        Some(
+            def.as_lazy_macro(
+                db.upcast(),
+                MacroCallKind::Attr(self.ast_id, self.path.segments.last()?.to_string()),
+            )
+            .into(),
+        )
     }
 }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 5b292c250..9c125f32f 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -7,6 +7,7 @@ use hir_expand::{
     builtin_derive::find_builtin_derive,
     builtin_macro::find_builtin_macro,
     name::{name, AsName, Name},
+    proc_macro::ProcMacroExpander,
     HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use ra_cfg::CfgOptions;
@@ -64,6 +65,9 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
         unexpanded_attribute_macros: Vec::new(),
         mod_dirs: FxHashMap::default(),
         cfg_options,
+
+        // FIXME: pass proc-macro from crate-graph
+        proc_macros: Default::default(),
     };
     collector.collect();
     collector.finish()
@@ -122,6 +126,7 @@ struct DefCollector<'a> {
     unexpanded_attribute_macros: Vec<DeriveDirective>,
     mod_dirs: FxHashMap<LocalModuleId, ModDir>,
     cfg_options: &'a CfgOptions,
+    proc_macros: Vec<(Name, ProcMacroExpander)>,
 }
 
 impl DefCollector<'_> {
@@ -177,6 +182,24 @@ impl DefCollector<'_> {
         for directive in unresolved_imports {
             self.record_resolved_import(&directive)
         }
+
+        // Record proc-macros
+        self.collect_proc_macro();
+    }
+
+    fn collect_proc_macro(&mut self) {
+        let proc_macros = std::mem::take(&mut self.proc_macros);
+        for (name, expander) in proc_macros {
+            let krate = self.def_map.krate;
+
+            let macro_id = MacroDefId {
+                ast_id: None,
+                krate: Some(krate),
+                kind: MacroDefKind::CustomDerive(expander),
+            };
+
+            self.define_proc_macro(name.clone(), macro_id);
+        }
     }
 
     /// Define a macro with `macro_rules`.
@@ -238,6 +261,18 @@ impl DefCollector<'_> {
         self.def_map.modules[module_id].scope.define_legacy_macro(name, mac);
     }
 
+    /// Define a proc macro
+    ///
+    /// A proc macro is similar to normal macro scope, but it would not visiable in legacy textual scoped.
+    /// And unconditionally exported.
+    fn define_proc_macro(&mut self, name: Name, macro_: MacroDefId) {
+        self.update(
+            self.def_map.root,
+            &[(name, PerNs::macros(macro_, Visibility::Public))],
+            Visibility::Public,
+        );
+    }
+
     /// Import macros from `#[macro_use] extern crate`.
     fn import_macros_from_extern_crate(
         &mut self,
@@ -537,8 +572,9 @@ impl DefCollector<'_> {
             true
         });
         attribute_macros.retain(|directive| {
-            if let Some(call_id) =
-                directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
+            if let Some(call_id) = directive
+                .ast_id
+                .as_call_id(self.db, |path| self.resolve_attribute_macro(&directive, &path))
             {
                 resolved.push((directive.module_id, call_id, 0));
                 res = ReachedFixedPoint::No;
@@ -562,9 +598,11 @@ impl DefCollector<'_> {
         res
     }
 
-    fn resolve_attribute_macro(&self, path: &ModPath) -> Option<MacroDefId> {
-        // FIXME this is currently super hacky, just enough to support the
-        // built-in derives
+    fn resolve_attribute_macro(
+        &self,
+        directive: &DeriveDirective,
+        path: &ModPath,
+    ) -> Option<MacroDefId> {
         if let Some(name) = path.as_ident() {
             // FIXME this should actually be handled with the normal name
             // resolution; the std lib defines built-in stubs for the derives,
@@ -573,7 +611,15 @@ impl DefCollector<'_> {
                 return Some(def_id);
             }
         }
-        None
+        let resolved_res = self.def_map.resolve_path_fp_with_macro(
+            self.db,
+            ResolveMode::Other,
+            directive.module_id,
+            &path,
+            BuiltinShadowMode::Module,
+        );
+
+        resolved_res.resolved_def.take_macros()
     }
 
     fn collect_macro_expansion(
@@ -776,7 +822,6 @@ impl ModCollector<'_, '_> {
         // FIXME: check attrs to see if this is an attribute macro invocation;
         // in which case we don't add the invocation, just a single attribute
         // macro invocation
-
         self.collect_derives(attrs, def);
 
         let name = def.name.clone();
@@ -955,6 +1000,7 @@ mod tests {
             unexpanded_attribute_macros: Vec::new(),
             mod_dirs: FxHashMap::default(),
             cfg_options: &CfgOptions::default(),
+            proc_macros: Default::default(),
         };
         collector.collect();
         collector.def_map
diff --git a/crates/ra_hir_expand/src/builtin_derive.rs b/crates/ra_hir_expand/src/builtin_derive.rs
index a5b50a832..79aea5806 100644
--- a/crates/ra_hir_expand/src/builtin_derive.rs
+++ b/crates/ra_hir_expand/src/builtin_derive.rs
@@ -229,9 +229,12 @@ fn partial_ord_expand(
 mod tests {
     use super::*;
     use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
+    use name::{known, Name};
     use ra_db::{fixture::WithFixture, SourceDatabase};
 
-    fn expand_builtin_derive(s: &str, expander: BuiltinDeriveExpander) -> String {
+    fn expand_builtin_derive(s: &str, name: Name) -> String {
+        let def = find_builtin_derive(&name).unwrap();
+
         let (db, file_id) = TestDB::with_single_file(&s);
         let parsed = db.parse(file_id);
         let items: Vec<_> =
@@ -239,14 +242,9 @@ mod tests {
 
         let ast_id_map = db.ast_id_map(file_id.into());
 
-        // the first one should be a macro_rules
-        let def =
-            MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(expander) };
+        let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
 
-        let loc = MacroCallLoc {
-            def,
-            kind: MacroCallKind::Attr(AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]))),
-        };
+        let loc = MacroCallLoc { def, kind: MacroCallKind::Attr(attr_id, name.to_string()) };
 
         let id: MacroCallId = db.intern_macro(loc).into();
         let parsed = db.parse_or_expand(id.as_file()).unwrap();
@@ -263,7 +261,7 @@ mod tests {
         #[derive(Copy)]
         struct Foo;
 "#,
-            BuiltinDeriveExpander::Copy,
+            known::Copy,
         );
 
         assert_eq!(expanded, "impl< >std::marker::CopyforFoo< >{}");
@@ -276,7 +274,7 @@ mod tests {
         #[derive(Copy)]
         struct Foo<A, B>;
 "#,
-            BuiltinDeriveExpander::Copy,
+            known::Copy,
         );
 
         assert_eq!(
@@ -292,7 +290,7 @@ mod tests {
         #[derive(Copy)]
         struct Foo<A, B, 'a, 'b>;
 "#,
-            BuiltinDeriveExpander::Copy,
+            known::Copy,
         );
 
         // We currently just ignore lifetimes
@@ -310,7 +308,7 @@ mod tests {
         #[derive(Clone)]
         struct Foo<A, B>;
 "#,
-            BuiltinDeriveExpander::Clone,
+            known::Clone,
         );
 
         assert_eq!(
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 5a696542f..047452306 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -11,7 +11,7 @@ use ra_syntax::{algo::diff, AstNode, Parse, SyntaxKind::*, SyntaxNode};
 use crate::{
     ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId,
     HirFileId, HirFileIdRepr, LazyMacroId, MacroCallId, MacroCallLoc, MacroDefId, MacroDefKind,
-    MacroFile,
+    MacroFile, ProcMacroExpander,
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -19,6 +19,7 @@ pub enum TokenExpander {
     MacroRules(mbe::MacroRules),
     Builtin(BuiltinFnLikeExpander),
     BuiltinDerive(BuiltinDeriveExpander),
+    ProcMacro(ProcMacroExpander),
 }
 
 impl TokenExpander {
@@ -33,6 +34,7 @@ impl TokenExpander {
             // FIXME switch these to ExpandResult as well
             TokenExpander::Builtin(it) => it.expand(db, id, tt).into(),
             TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
+            TokenExpander::ProcMacro(it) => it.expand(db, id, tt).into(),
         }
     }
 
@@ -41,6 +43,7 @@ impl TokenExpander {
             TokenExpander::MacroRules(it) => it.map_id_down(id),
             TokenExpander::Builtin(..) => id,
             TokenExpander::BuiltinDerive(..) => id,
+            TokenExpander::ProcMacro(..) => id,
         }
     }
 
@@ -49,6 +52,7 @@ impl TokenExpander {
             TokenExpander::MacroRules(it) => it.map_id_up(id),
             TokenExpander::Builtin(..) => (id, mbe::Origin::Call),
             TokenExpander::BuiltinDerive(..) => (id, mbe::Origin::Call),
+            TokenExpander::ProcMacro(..) => (id, mbe::Origin::Call),
         }
     }
 }
@@ -130,7 +134,10 @@ pub(crate) fn macro_def(
         MacroDefKind::BuiltInDerive(expander) => {
             Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
         }
-        MacroDefKind::BuiltInEager(_expander) => None,
+        MacroDefKind::BuiltInEager(_) => None,
+        MacroDefKind::CustomDerive(expander) => {
+            Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
+        }
     }
 }
 
diff --git a/crates/ra_hir_expand/src/eager.rs b/crates/ra_hir_expand/src/eager.rs
index 4cbce4df5..932f47c30 100644
--- a/crates/ra_hir_expand/src/eager.rs
+++ b/crates/ra_hir_expand/src/eager.rs
@@ -26,8 +26,8 @@ use crate::{
 };
 
 use ra_parser::FragmentKind;
-use ra_syntax::{algo::replace_descendants, SyntaxElement, SyntaxNode};
-use std::{collections::HashMap, sync::Arc};
+use ra_syntax::{algo::SyntaxRewriter, SyntaxNode};
+use std::sync::Arc;
 
 pub fn expand_eager_macro(
     db: &dyn AstDatabase,
@@ -95,10 +95,10 @@ fn eager_macro_recur(
     curr: InFile<SyntaxNode>,
     macro_resolver: &dyn Fn(ast::Path) -> Option<MacroDefId>,
 ) -> Option<SyntaxNode> {
-    let mut original = curr.value.clone();
+    let original = curr.value.clone();
 
     let children = curr.value.descendants().filter_map(ast::MacroCall::cast);
-    let mut replaces: HashMap<SyntaxElement, SyntaxElement> = HashMap::default();
+    let mut rewriter = SyntaxRewriter::default();
 
     // Collect replacement
     for child in children {
@@ -112,19 +112,17 @@ fn eager_macro_recur(
             }
             MacroDefKind::Declarative
             | MacroDefKind::BuiltIn(_)
-            | MacroDefKind::BuiltInDerive(_) => {
+            | MacroDefKind::BuiltInDerive(_)
+            | MacroDefKind::CustomDerive(_) => {
                 let expanded = lazy_expand(db, &def, curr.with_value(child.clone()))?;
                 // replace macro inside
                 eager_macro_recur(db, expanded, macro_resolver)?
             }
         };
 
-        replaces.insert(child.syntax().clone().into(), insert.into());
+        rewriter.replace(child.syntax(), &insert);
     }
 
-    if !replaces.is_empty() {
-        original = replace_descendants(&original, |n| replaces.get(n).cloned());
-    }
-
-    Some(original)
+    let res = rewriter.rewrite(&original);
+    Some(res)
 }
diff --git a/crates/ra_hir_expand/src/hygiene.rs b/crates/ra_hir_expand/src/hygiene.rs
index dfbac494f..0b41d0e95 100644
--- a/crates/ra_hir_expand/src/hygiene.rs
+++ b/crates/ra_hir_expand/src/hygiene.rs
@@ -30,6 +30,7 @@ impl Hygiene {
                         MacroDefKind::BuiltIn(_) => None,
                         MacroDefKind::BuiltInDerive(_) => None,
                         MacroDefKind::BuiltInEager(_) => None,
+                        MacroDefKind::CustomDerive(_) => None,
                     }
                 }
                 MacroCallId::EagerMacro(_id) => None,
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 6b59ea4c9..86299459f 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -11,6 +11,7 @@ pub mod hygiene;
 pub mod diagnostics;
 pub mod builtin_derive;
 pub mod builtin_macro;
+pub mod proc_macro;
 pub mod quote;
 pub mod eager;
 
@@ -27,6 +28,7 @@ use ra_syntax::{
 use crate::ast_id_map::FileAstId;
 use crate::builtin_derive::BuiltinDeriveExpander;
 use crate::builtin_macro::{BuiltinFnLikeExpander, EagerExpander};
+use crate::proc_macro::ProcMacroExpander;
 
 #[cfg(test)]
 mod test_db;
@@ -217,6 +219,7 @@ pub enum MacroDefKind {
     // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
     BuiltInDerive(BuiltinDeriveExpander),
     BuiltInEager(EagerExpander),
+    CustomDerive(ProcMacroExpander),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -228,21 +231,23 @@ pub struct MacroCallLoc {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroCallKind {
     FnLike(AstId<ast::MacroCall>),
-    Attr(AstId<ast::ModuleItem>),
+    Attr(AstId<ast::ModuleItem>, String),
 }
 
 impl MacroCallKind {
     pub fn file_id(&self) -> HirFileId {
         match self {
             MacroCallKind::FnLike(ast_id) => ast_id.file_id,
-            MacroCallKind::Attr(ast_id) => ast_id.file_id,
+            MacroCallKind::Attr(ast_id, _) => ast_id.file_id,
         }
     }
 
     pub fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
         match self {
             MacroCallKind::FnLike(ast_id) => ast_id.with_value(ast_id.to_node(db).syntax().clone()),
-            MacroCallKind::Attr(ast_id) => ast_id.with_value(ast_id.to_node(db).syntax().clone()),
+            MacroCallKind::Attr(ast_id, _) => {
+                ast_id.with_value(ast_id.to_node(db).syntax().clone())
+            }
         }
     }
 
@@ -251,7 +256,7 @@ impl MacroCallKind {
             MacroCallKind::FnLike(ast_id) => {
                 Some(ast_id.to_node(db).token_tree()?.syntax().clone())
             }
-            MacroCallKind::Attr(ast_id) => Some(ast_id.to_node(db).syntax().clone()),
+            MacroCallKind::Attr(ast_id, _) => Some(ast_id.to_node(db).syntax().clone()),
         }
     }
 }
diff --git a/crates/ra_hir_expand/src/proc_macro.rs b/crates/ra_hir_expand/src/proc_macro.rs
new file mode 100644
index 000000000..a8dee2052
--- /dev/null
+++ b/crates/ra_hir_expand/src/proc_macro.rs
@@ -0,0 +1,33 @@
+//! Proc Macro Expander stub
+
+use crate::{db::AstDatabase, LazyMacroId, MacroCallKind, MacroCallLoc};
+use ra_db::CrateId;
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+pub struct ProcMacroExpander {
+    krate: CrateId,
+}
+
+impl ProcMacroExpander {
+    pub fn new(krate: CrateId) -> ProcMacroExpander {
+        ProcMacroExpander { krate }
+    }
+
+    pub fn expand(
+        &self,
+        db: &dyn AstDatabase,
+        id: LazyMacroId,
+        _tt: &tt::Subtree,
+    ) -> Result<tt::Subtree, mbe::ExpandError> {
+        let loc: MacroCallLoc = db.lookup_intern_macro(id);
+        let name = match loc.kind {
+            MacroCallKind::FnLike(_) => return Err(mbe::ExpandError::ConversionError),
+            MacroCallKind::Attr(_, name) => name,
+        };
+
+        log::debug!("Proc-macro-expanding name = {}", name);
+
+        // Return nothing for now
+        return Ok(tt::Subtree::default());
+    }
+}
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index 11fc2ac3d..1462b053f 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -22,6 +22,7 @@ use hir_expand::name::Name;
 #[salsa::requires(salsa::Database)]
 pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     #[salsa::invoke(infer_wait)]
+    #[salsa::transparent]
     fn infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
 
     #[salsa::invoke(crate::infer::infer_query)]
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 2e309a379..eb97288f1 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -639,3 +639,22 @@ mod clone {
     );
     assert_eq!("(Wrapper<S>, {unknown})", type_at_pos(&db, pos));
 }
+
+#[test]
+fn infer_custom_derive_simple() {
+    // FIXME: this test current now do nothing
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs crate:main
+use foo::Foo;
+
+#[derive(Foo)]
+struct S{}
+
+fn test() {
+    S{}<|>;
+}
+"#,
+    );
+    assert_eq!("S", type_at_pos(&db, pos));
+}
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 7235c944c..36eec0e60 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -14,7 +14,7 @@ wasm = []
 either = "1.5.3"
 format-buf = "1.0.0"
 indexmap = "1.3.2"
-itertools = "0.8.2"
+itertools = "0.9.0"
 join_to_string = "0.1.3"
 log = "0.4.8"
 rustc-hash = "1.1.0"
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 0ba382165..0a00054b2 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -1,6 +1,9 @@
 //! FIXME: write short doc here
 
-use ra_syntax::{ast::AstNode, TextRange, TextUnit};
+use ra_syntax::{
+    ast::{self, AstNode},
+    TextRange, TextUnit,
+};
 use ra_text_edit::TextEdit;
 
 use crate::{
@@ -21,13 +24,8 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         None => return,
     };
 
-    let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
-        let text = dot_receiver.syntax().text();
-        let without_dot = ..text.len() - TextUnit::of_char('.');
-        text.slice(without_dot).to_string()
-    } else {
-        dot_receiver.syntax().text().to_string()
-    };
+    let receiver_text =
+        get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
 
     let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
         Some(it) => it,
@@ -35,10 +33,17 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     };
 
     if receiver_ty.is_bool() || receiver_ty.is_unknown() {
-        postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
-            .add_to(acc);
         postfix_snippet(
             ctx,
+            &dot_receiver,
+            "if",
+            "if expr {}",
+            &format!("if {} {{$0}}", receiver_text),
+        )
+        .add_to(acc);
+        postfix_snippet(
+            ctx,
+            &dot_receiver,
             "while",
             "while expr {}",
             &format!("while {} {{\n$0\n}}", receiver_text),
@@ -46,28 +51,70 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         .add_to(acc);
     }
 
-    postfix_snippet(ctx, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
+    // !&&&42 is a compiler error, ergo process it before considering the references
+    postfix_snippet(ctx, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
 
-    postfix_snippet(ctx, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
-    postfix_snippet(ctx, "refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, &dot_receiver, "refm", "&mut expr", &format!("&mut {}", receiver_text))
+        .add_to(acc);
+
+    // The rest of the postfix completions create an expression that moves an argument,
+    // so it's better to consider references now to avoid breaking the compilation
+    let dot_receiver = include_references(dot_receiver);
+    let receiver_text =
+        get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
 
     postfix_snippet(
         ctx,
+        &dot_receiver,
         "match",
         "match expr {}",
         &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
     )
     .add_to(acc);
 
-    postfix_snippet(ctx, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
+    postfix_snippet(
+        ctx,
+        &dot_receiver,
+        "box",
+        "Box::new(expr)",
+        &format!("Box::new({})", receiver_text),
+    )
+    .add_to(acc);
 
-    postfix_snippet(ctx, "box", "Box::new(expr)", &format!("Box::new({})", receiver_text))
+    postfix_snippet(ctx, &dot_receiver, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text))
         .add_to(acc);
 }
 
-fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
+fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
+    if receiver_is_ambiguous_float_literal {
+        let text = receiver.syntax().text();
+        let without_dot = ..text.len() - TextUnit::of_char('.');
+        text.slice(without_dot).to_string()
+    } else {
+        receiver.to_string()
+    }
+}
+
+fn include_references(initial_element: &ast::Expr) -> ast::Expr {
+    let mut resulting_element = initial_element.clone();
+    while let Some(parent_ref_element) =
+        resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
+    {
+        resulting_element = ast::Expr::from(parent_ref_element);
+    }
+    resulting_element
+}
+
+fn postfix_snippet(
+    ctx: &CompletionContext,
+    receiver: &ast::Expr,
+    label: &str,
+    detail: &str,
+    snippet: &str,
+) -> Builder {
     let edit = {
-        let receiver_syntax = ctx.dot_receiver.as_ref().expect("no receiver available").syntax();
+        let receiver_syntax = receiver.syntax();
         let receiver_range = ctx.sema.original_range(receiver_syntax).range;
         let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
         TextEdit::replace(delete_range, snippet.to_string())
@@ -340,4 +387,63 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn postfix_completion_for_references() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    &&&&42.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "Box::new(&&&&42)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "dbg!(&&&&42)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [56; 56),
+                delete: [49; 56),
+                insert: "match &&&&42 {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "!42",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "&42",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [56; 56),
+                delete: [53; 56),
+                insert: "&mut 42",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
index 83ed1d52c..e4e764f58 100644
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ b/crates/ra_ide/src/completion/complete_record_literal.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 
 use crate::completion::{CompletionContext, Completions};
+use ra_syntax::SmolStr;
 
 /// Complete fields in fields literals.
 pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
@@ -11,8 +12,24 @@ pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionCon
         _ => return,
     };
 
+    let already_present_names: Vec<SmolStr> = ctx
+        .record_lit_syntax
+        .as_ref()
+        .and_then(|record_literal| record_literal.record_field_list())
+        .map(|field_list| field_list.fields())
+        .map(|fields| {
+            fields
+                .into_iter()
+                .filter_map(|field| field.name_ref())
+                .map(|name_ref| name_ref.text().clone())
+                .collect()
+        })
+        .unwrap_or_default();
+
     for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
-        acc.add_field(ctx, field, &field_ty);
+        if !already_present_names.contains(&SmolStr::from(field.name(ctx.db).to_string())) {
+            acc.add_field(ctx, field, &field_ty);
+        }
     }
 }
 
@@ -178,4 +195,47 @@ mod tests {
         ]
         "###);
     }
+
+    #[test]
+    fn only_missing_fields_are_completed() {
+        let completions = complete(
+            r"
+            struct S {
+                foo1: u32,
+                foo2: u32,
+                bar: u32,
+                baz: u32,
+            }
+
+            fn main() {
+                let foo1 = 1;
+                let s = S {
+                    foo1,
+                    foo2: 5,
+                    <|>
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "bar",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "baz",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "baz",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 7fefa2c7a..ded1ff3bc 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -193,7 +193,7 @@ fn add_const_impl(
 }
 
 fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
-    let const_ = edit::strip_attrs_and_docs(const_);
+    let const_ = edit::remove_attrs_and_docs(const_);
 
     let const_start = const_.syntax().text_range().start();
     let const_end = const_.syntax().text_range().end();
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index e58526f31..f536ba3e7 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -3,10 +3,9 @@
 use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    algo::{find_node_at_offset, replace_descendants},
-    ast, AstNode, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, WalkEvent, T,
+    algo::{find_node_at_offset, SyntaxRewriter},
+    ast, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, WalkEvent, T,
 };
-use rustc_hash::FxHashMap;
 
 use crate::FilePosition;
 
@@ -37,7 +36,7 @@ fn expand_macro_recur(
     let mut expanded = sema.expand(macro_call)?;
 
     let children = expanded.descendants().filter_map(ast::MacroCall::cast);
-    let mut replaces: FxHashMap<SyntaxElement, SyntaxElement> = FxHashMap::default();
+    let mut rewriter = SyntaxRewriter::default();
 
     for child in children.into_iter() {
         if let Some(new_node) = expand_macro_recur(sema, &child) {
@@ -47,12 +46,13 @@ fn expand_macro_recur(
             if expanded == *child.syntax() {
                 expanded = new_node;
             } else {
-                replaces.insert(child.syntax().clone().into(), new_node.into());
+                rewriter.replace(child.syntax(), &new_node)
             }
         }
     }
 
-    Some(replace_descendants(&expanded, |n| replaces.get(n).cloned()))
+    let res = rewriter.rewrite(&expanded);
+    Some(res)
 }
 
 // FIXME: It would also be cool to share logic here and in the mbe tests,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 502fcb0cf..8aed94d16 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -104,6 +104,9 @@ mod tests {
         let (analysis, pos) = analysis_and_position(ra_fixture);
 
         let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
+        if navs.len() == 0 {
+            panic!("unresolved reference")
+        }
         assert_eq!(navs.len(), 1);
 
         let nav = navs.pop().unwrap();
@@ -359,7 +362,7 @@ mod tests {
     fn goto_def_for_fields() {
         covers!(ra_ide_db::goto_def_for_fields);
         check_goto(
-            "
+            r"
             //- /lib.rs
             struct Foo {
                 spam: u32,
@@ -378,7 +381,7 @@ mod tests {
     fn goto_def_for_record_fields() {
         covers!(ra_ide_db::goto_def_for_record_fields);
         check_goto(
-            "
+            r"
             //- /lib.rs
             struct Foo {
                 spam: u32,
@@ -396,6 +399,23 @@ mod tests {
     }
 
     #[test]
+    fn goto_def_for_record_fields_macros() {
+        check_goto(
+            r"
+            //- /lib.rs
+            macro_rules! m { () => { 92 };}
+            struct Foo { spam: u32 }
+
+            fn bar() -> Foo {
+                Foo { spam<|>: m!() }
+            }
+            ",
+            "spam RECORD_FIELD_DEF FileId(1) [45; 54) [45; 49)",
+            "spam: u32|spam",
+        );
+    }
+
+    #[test]
     fn goto_for_tuple_fields() {
         check_goto(
             "
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index ecd615cf4..f4f0751c0 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -5,7 +5,7 @@ use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, SmolStr, TextRange,
+    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange,
 };
 
 use crate::{FileId, FunctionSignature};
@@ -14,12 +14,13 @@ use crate::{FileId, FunctionSignature};
 pub struct InlayHintsOptions {
     pub type_hints: bool,
     pub parameter_hints: bool,
+    pub chaining_hints: bool,
     pub max_length: Option<usize>,
 }
 
 impl Default for InlayHintsOptions {
     fn default() -> Self {
-        Self { type_hints: true, parameter_hints: true, max_length: None }
+        Self { type_hints: true, parameter_hints: true, chaining_hints: true, max_length: None }
     }
 }
 
@@ -27,6 +28,7 @@ impl Default for InlayHintsOptions {
 pub enum InlayKind {
     TypeHint,
     ParameterHint,
+    ChainingHint,
 }
 
 #[derive(Debug)]
@@ -47,6 +49,10 @@ pub(crate) fn inlay_hints(
 
     let mut res = Vec::new();
     for node in file.syntax().descendants() {
+        if let Some(expr) = ast::Expr::cast(node.clone()) {
+            get_chaining_hints(&mut res, &sema, options, expr);
+        }
+
         match_ast! {
             match node {
                 ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
@@ -59,6 +65,46 @@ pub(crate) fn inlay_hints(
     res
 }
 
+fn get_chaining_hints(
+    acc: &mut Vec<InlayHint>,
+    sema: &Semantics<RootDatabase>,
+    options: &InlayHintsOptions,
+    expr: ast::Expr,
+) -> Option<()> {
+    if !options.chaining_hints {
+        return None;
+    }
+
+    let ty = sema.type_of_expr(&expr)?;
+    if ty.is_unknown() {
+        return None;
+    }
+
+    let mut tokens = expr
+        .syntax()
+        .siblings_with_tokens(Direction::Next)
+        .filter_map(NodeOrToken::into_token)
+        .filter(|t| match t.kind() {
+            SyntaxKind::WHITESPACE if !t.text().contains('\n') => false,
+            SyntaxKind::COMMENT => false,
+            _ => true,
+        });
+
+    // Chaining can be defined as an expression whose next sibling tokens are newline and dot
+    // Ignoring extra whitespace and comments
+    let next = tokens.next()?.kind();
+    let next_next = tokens.next()?.kind();
+    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
+        let label = ty.display_truncated(sema.db, options.max_length).to_string();
+        acc.push(InlayHint {
+            range: expr.syntax().text_range(),
+            kind: InlayKind::ChainingHint,
+            label: label.into(),
+        });
+    }
+    Some(())
+}
+
 fn get_param_name_hints(
     acc: &mut Vec<InlayHint>,
     sema: &Semantics<RootDatabase>,
@@ -238,7 +284,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
         [
             InlayHint {
                 range: [106; 107),
@@ -262,7 +308,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
     }
 
     #[test]
@@ -274,7 +320,7 @@ mod tests {
                 let _x = foo(4, 4);
             }"#,
         );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
         [
             InlayHint {
                 range: [97; 99),
@@ -1052,4 +1098,124 @@ fn main() {
         "###
         );
     }
+
+    #[test]
+    fn chaining_hints_ignore_comments() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A(B);
+            impl A { fn into_b(self) -> B { self.0 } }
+            struct B(C);
+            impl B { fn into_c(self) -> C { self.0 } }
+            struct C;
+
+            fn main() {
+                let c = A(B(C))
+                    .into_b() // This is a comment
+                    .into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [232; 269),
+                kind: ChainingHint,
+                label: "B",
+            },
+            InlayHint {
+                range: [232; 239),
+                kind: ChainingHint,
+                label: "A",
+            },
+        ]"###);
+    }
+
+    #[test]
+    fn chaining_hints_without_newlines() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A(B);
+            impl A { fn into_b(self) -> B { self.0 } }
+            struct B(C);
+            impl B { fn into_c(self) -> C { self.0 } }
+            struct C;
+
+            fn main() {
+                let c = A(B(C)).into_b().into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
+    }
+
+    #[test]
+    fn struct_access_chaining_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A { pub b: B }
+            struct B { pub c: C }
+            struct C(pub bool);
+
+            fn main() {
+                let x = A { b: B { c: C(true) } }
+                    .b
+                    .c
+                    .0;
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [150; 221),
+                kind: ChainingHint,
+                label: "C",
+            },
+            InlayHint {
+                range: [150; 198),
+                kind: ChainingHint,
+                label: "B",
+            },
+            InlayHint {
+                range: [150; 175),
+                kind: ChainingHint,
+                label: "A",
+            },
+        ]"###);
+    }
+
+    #[test]
+    fn generic_chaining_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+            struct A<T>(T);
+            struct B<T>(T);
+            struct C<T>(T);
+            struct X<T,R>(T, R);
+
+            impl<T> A<T> {
+                fn new(t: T) -> Self { A(t) }
+                fn into_b(self) -> B<T> { B(self.0) }
+            }
+            impl<T> B<T> {
+                fn into_c(self) -> C<T> { C(self.0) }
+            }
+            fn main() {
+                let c = A::new(X(42, true))
+                    .into_b()
+                    .into_c();
+            }"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        [
+            InlayHint {
+                range: [403; 452),
+                kind: ChainingHint,
+                label: "B<X<i32, bool>>",
+            },
+            InlayHint {
+                range: [403; 422),
+                kind: ChainingHint,
+                label: "A<X<i32, bool>>",
+            },
+        ]"###);
+    }
 }
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index de4f5bce0..c3921bd40 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -17,6 +17,7 @@ fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 superslice = "1.0.0"
 once_cell = "1.3.1"
+either = "1.5.3"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index 628cf6416..8446ef88e 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -311,6 +311,7 @@ impl RootDatabase {
             hir::db::MacroDefQuery
             hir::db::ParseMacroQuery
             hir::db::MacroExpandQuery
+            hir::db::InternEagerExpansionQuery
 
             // DefDatabase
             hir::db::RawItemsQuery
@@ -359,14 +360,21 @@ impl RootDatabase {
             hir::db::ImplsInCrateQuery
             hir::db::ImplsForTraitQuery
             hir::db::InternTypeCtorQuery
+            hir::db::InternTypeParamIdQuery
             hir::db::InternChalkImplQuery
             hir::db::InternAssocTyValueQuery
             hir::db::AssociatedTyDataQuery
-            hir::db::AssociatedTyValueQuery
-            hir::db::TraitSolveQuery
             hir::db::TraitDatumQuery
             hir::db::StructDatumQuery
             hir::db::ImplDatumQuery
+            hir::db::AssociatedTyValueQuery
+            hir::db::TraitSolveQuery
+
+            // SymbolsDatabase
+            crate::symbol_index::FileSymbolsQuery
+
+            // LineIndexDatabase
+            crate::LineIndexQuery
         ];
         acc.sort_by_key(|it| std::cmp::Reverse(it.1));
         acc
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 97961bb6d..e9934844e 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,12 +6,12 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    Adt, FieldSource, HasSource, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
-    Semantics, StructField, TypeParam,
+    HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution, Semantics,
+    StructField, TypeParam, Visibility,
 };
 use ra_prof::profile;
 use ra_syntax::{
-    ast::{self, AstNode, VisibilityOwner},
+    ast::{self, AstNode},
     match_ast,
 };
 use test_utils::tested_by;
@@ -41,28 +41,13 @@ impl Definition {
         }
     }
 
-    pub fn visibility(&self, db: &RootDatabase) -> Option<ast::Visibility> {
+    pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
+        let module = self.module(db);
+
         match self {
             Definition::Macro(_) => None,
-            Definition::StructField(sf) => match sf.source(db).value {
-                FieldSource::Named(it) => it.visibility(),
-                FieldSource::Pos(it) => it.visibility(),
-            },
-            Definition::ModuleDef(def) => match def {
-                ModuleDef::Module(it) => it.declaration_source(db)?.value.visibility(),
-                ModuleDef::Function(it) => it.source(db).value.visibility(),
-                ModuleDef::Adt(adt) => match adt {
-                    Adt::Struct(it) => it.source(db).value.visibility(),
-                    Adt::Union(it) => it.source(db).value.visibility(),
-                    Adt::Enum(it) => it.source(db).value.visibility(),
-                },
-                ModuleDef::Const(it) => it.source(db).value.visibility(),
-                ModuleDef::Static(it) => it.source(db).value.visibility(),
-                ModuleDef::Trait(it) => it.source(db).value.visibility(),
-                ModuleDef::TypeAlias(it) => it.source(db).value.visibility(),
-                ModuleDef::EnumVariant(_) => None,
-                ModuleDef::BuiltinType(_) => None,
-            },
+            Definition::StructField(sf) => Some(sf.visibility(db)),
+            Definition::ModuleDef(def) => module?.visibility_of(db, def),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
             Definition::TypeParam(_) => None,
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index c96351982..bf0d8db60 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the ra_assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
 
-use hir::{ModuleDef, Semantics};
+use hir::{MacroDef, ModuleDef, Semantics};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
 
@@ -10,6 +10,7 @@ use crate::{
     symbol_index::{self, FileSymbol, Query},
     RootDatabase,
 };
+use either::Either;
 
 pub struct ImportsLocator<'a> {
     sema: Semantics<'a, RootDatabase>,
@@ -20,7 +21,7 @@ impl<'a> ImportsLocator<'a> {
         Self { sema: Semantics::new(db) }
     }
 
-    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
+    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<Either<ModuleDef, MacroDef>> {
         let _p = profile("search_for_imports");
         let db = self.sema.db;
 
@@ -43,7 +44,8 @@ impl<'a> ImportsLocator<'a> {
             .chain(lib_results.into_iter())
             .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
             .filter_map(|name_definition_to_import| match name_definition_to_import {
-                Definition::ModuleDef(module_def) => Some(module_def),
+                Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
+                Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
                 _ => None,
             })
             .collect()
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index 117454695..05a0eed30 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -6,7 +6,7 @@
 
 use std::mem;
 
-use hir::{DefWithBody, HasSource, ModuleSource, Semantics};
+use hir::{DefWithBody, HasSource, Module, ModuleSource, Semantics, Visibility};
 use once_cell::unsync::Lazy;
 use ra_db::{FileId, FileRange, SourceDatabaseExt};
 use ra_prof::profile;
@@ -123,51 +123,47 @@ impl Definition {
             return SearchScope::new(res);
         }
 
-        let vis = self.visibility(db).as_ref().map(|v| v.syntax().to_string()).unwrap_or_default();
+        let vis = self.visibility(db);
 
-        if vis.as_str() == "pub(super)" {
-            if let Some(parent_module) = module.parent(db) {
-                let mut res = FxHashMap::default();
-                let parent_src = parent_module.definition_source(db);
-                let file_id = parent_src.file_id.original_file(db);
+        // FIXME:
+        // The following logic are wrong that it does not search
+        // for submodules within other files recursively.
 
-                match parent_src.value {
-                    ModuleSource::Module(m) => {
-                        let range = Some(m.syntax().text_range());
-                        res.insert(file_id, range);
-                    }
-                    ModuleSource::SourceFile(_) => {
-                        res.insert(file_id, None);
-                        res.extend(parent_module.children(db).map(|m| {
-                            let src = m.definition_source(db);
-                            (src.file_id.original_file(db), None)
-                        }));
-                    }
+        if let Some(Visibility::Module(module)) = vis.and_then(|it| it.into()) {
+            let module: Module = module.into();
+            let mut res = FxHashMap::default();
+            let src = module.definition_source(db);
+            let file_id = src.file_id.original_file(db);
+
+            match src.value {
+                ModuleSource::Module(m) => {
+                    let range = Some(m.syntax().text_range());
+                    res.insert(file_id, range);
+                }
+                ModuleSource::SourceFile(_) => {
+                    res.insert(file_id, None);
+                    res.extend(module.children(db).map(|m| {
+                        let src = m.definition_source(db);
+                        (src.file_id.original_file(db), None)
+                    }));
                 }
-                return SearchScope::new(res);
             }
+            return SearchScope::new(res);
         }
 
-        if vis.as_str() != "" {
+        if let Some(Visibility::Public) = vis {
             let source_root_id = db.file_source_root(file_id);
             let source_root = db.source_root(source_root_id);
             let mut res = source_root.walk().map(|id| (id, None)).collect::<FxHashMap<_, _>>();
 
-            // FIXME: add "pub(in path)"
-
-            if vis.as_str() == "pub(crate)" {
-                return SearchScope::new(res);
-            }
-            if vis.as_str() == "pub" {
-                let krate = module.krate();
-                for rev_dep in krate.reverse_dependencies(db) {
-                    let root_file = rev_dep.root_file(db);
-                    let source_root_id = db.file_source_root(root_file);
-                    let source_root = db.source_root(source_root_id);
-                    res.extend(source_root.walk().map(|id| (id, None)));
-                }
-                return SearchScope::new(res);
+            let krate = module.krate();
+            for rev_dep in krate.reverse_dependencies(db) {
+                let root_file = rev_dep.root_file(db);
+                let source_root_id = db.file_source_root(root_file);
+                let source_root = db.source_root(source_root_id);
+                res.extend(source_root.walk().map(|id| (id, None)));
             }
+            return SearchScope::new(res);
         }
 
         let mut res = FxHashMap::default();
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index fcb73fbc7..8e8ae2b29 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -3,12 +3,11 @@
 use ra_parser::{FragmentKind, ParseError, TreeSink};
 use ra_syntax::{
     ast::{self, make::tokens::doc_comment},
-    tokenize, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind,
+    tokenize, AstToken, Parse, SmolStr, SyntaxKind,
     SyntaxKind::*,
-    SyntaxNode, SyntaxTreeBuilder, TextRange, TextUnit, Token, T,
+    SyntaxNode, SyntaxToken, SyntaxTreeBuilder, TextRange, TextUnit, Token as RawToken, T,
 };
 use rustc_hash::FxHashMap;
-use std::iter::successors;
 use tt::buffer::{Cursor, TokenBuffer};
 
 use crate::subtree_source::SubtreeTokenSource;
@@ -34,7 +33,7 @@ impl TokenTextRange {
 }
 
 /// Maps `tt::TokenId` to the relative range of the original token.
-#[derive(Debug, PartialEq, Eq, Default)]
+#[derive(Debug, PartialEq, Eq, Clone, Default)]
 pub struct TokenMap {
     /// Maps `tt::TokenId` to the *relative* source range.
     entries: Vec<(tt::TokenId, TokenTextRange)>,
@@ -50,10 +49,8 @@ pub fn ast_to_token_tree(ast: &impl ast::AstNode) -> Option<(tt::Subtree, TokenM
 /// will consume).
 pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, TokenMap)> {
     let global_offset = node.text_range().start();
-    let mut c = Convertor {
-        id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
-    };
-    let subtree = c.go(node)?;
+    let mut c = Convertor::new(node, global_offset);
+    let subtree = c.go()?;
     Some((subtree, c.id_alloc.map))
 }
 
@@ -152,6 +149,10 @@ impl TokenMap {
             }
         }
     }
+
+    fn remove_delim(&mut self, token_id: tt::TokenId) {
+        self.entries.retain(|(tid, _)| *tid != token_id);
+    }
 }
 
 /// Returns the textual content of a doc comment block as a quoted string
@@ -237,25 +238,26 @@ impl TokenIdAlloc {
         token_id
     }
 
-    fn delim(&mut self, open_abs_range: TextRange, close_abs_range: TextRange) -> tt::TokenId {
-        let open_relative_range = open_abs_range - self.global_offset;
-        let close_relative_range = close_abs_range - self.global_offset;
-        let token_id = tt::TokenId(self.next_id);
-        self.next_id += 1;
-
-        self.map.insert_delim(token_id, open_relative_range, close_relative_range);
-        token_id
-    }
-
     fn open_delim(&mut self, open_abs_range: TextRange) -> tt::TokenId {
         let token_id = tt::TokenId(self.next_id);
         self.next_id += 1;
-        self.map.insert_delim(token_id, open_abs_range, open_abs_range);
+        self.map.insert_delim(
+            token_id,
+            open_abs_range - self.global_offset,
+            open_abs_range - self.global_offset,
+        );
         token_id
     }
 
-    fn close_delim(&mut self, id: tt::TokenId, close_abs_range: TextRange) {
-        self.map.update_close_delim(id, close_abs_range);
+    fn close_delim(&mut self, id: tt::TokenId, close_abs_range: Option<TextRange>) {
+        match close_abs_range {
+            None => {
+                self.map.remove_delim(id);
+            }
+            Some(close) => {
+                self.map.update_close_delim(id, close - self.global_offset);
+            }
+        }
     }
 }
 
@@ -264,10 +266,20 @@ struct RawConvertor<'a> {
     text: &'a str,
     offset: TextUnit,
     id_alloc: TokenIdAlloc,
-    inner: std::slice::Iter<'a, Token>,
+    inner: std::slice::Iter<'a, RawToken>,
 }
 
-impl RawConvertor<'_> {
+trait SrcToken {
+    fn kind(&self) -> SyntaxKind;
+
+    fn to_char(&self) -> Option<char>;
+
+    fn to_text(&self) -> SmolStr;
+}
+
+trait TokenConvertor {
+    type Token: SrcToken;
+
     fn go(&mut self) -> Option<tt::Subtree> {
         let mut subtree = tt::Subtree::default();
         subtree.delimiter = None;
@@ -285,33 +297,22 @@ impl RawConvertor<'_> {
         Some(subtree)
     }
 
-    fn bump(&mut self) -> Option<(Token, TextRange)> {
-        let token = self.inner.next()?;
-        let range = TextRange::offset_len(self.offset, token.len);
-        self.offset += token.len;
-        Some((*token, range))
-    }
-
-    fn peek(&self) -> Option<Token> {
-        self.inner.as_slice().get(0).cloned()
-    }
-
     fn collect_leaf(&mut self, result: &mut Vec<tt::TokenTree>) {
         let (token, range) = match self.bump() {
             None => return,
             Some(it) => it,
         };
 
-        let k: SyntaxKind = token.kind;
+        let k: SyntaxKind = token.kind();
         if k == COMMENT {
-            let node = doc_comment(&self.text[range]);
-            if let Some(tokens) = convert_doc_comment(&node) {
+            if let Some(tokens) = self.convert_doc_comment(&token) {
                 result.extend(tokens);
             }
             return;
         }
 
         result.push(if k.is_punct() {
+            assert_eq!(range.len().to_usize(), 1);
             let delim = match k {
                 T!['('] => Some((tt::DelimiterKind::Parenthesis, T![')'])),
                 T!['{'] => Some((tt::DelimiterKind::Brace, T!['}'])),
@@ -321,40 +322,51 @@ impl RawConvertor<'_> {
 
             if let Some((kind, closed)) = delim {
                 let mut subtree = tt::Subtree::default();
-                let id = self.id_alloc.open_delim(range);
+                let id = self.id_alloc().open_delim(range);
                 subtree.delimiter = Some(tt::Delimiter { kind, id });
 
-                while self.peek().map(|it| it.kind != closed).unwrap_or(false) {
+                while self.peek().map(|it| it.kind() != closed).unwrap_or(false) {
                     self.collect_leaf(&mut subtree.token_trees);
                 }
                 let last_range = match self.bump() {
-                    None => return,
+                    None => {
+                        // For error resilience, we insert an char punct for the opening delim here
+                        self.id_alloc().close_delim(id, None);
+                        let leaf: tt::Leaf = tt::Punct {
+                            id: self.id_alloc().alloc(range),
+                            char: token.to_char().unwrap(),
+                            spacing: tt::Spacing::Alone,
+                        }
+                        .into();
+                        result.push(leaf.into());
+                        result.extend(subtree.token_trees);
+                        return;
+                    }
                     Some(it) => it.1,
                 };
-                self.id_alloc.close_delim(id, last_range);
+                self.id_alloc().close_delim(id, Some(last_range));
                 subtree.into()
             } else {
                 let spacing = match self.peek() {
                     Some(next)
-                        if next.kind.is_trivia()
-                            || next.kind == T!['[']
-                            || next.kind == T!['{']
-                            || next.kind == T!['('] =>
+                        if next.kind().is_trivia()
+                            || next.kind() == T!['[']
+                            || next.kind() == T!['{']
+                            || next.kind() == T!['('] =>
                     {
                         tt::Spacing::Alone
                     }
-                    Some(next) if next.kind.is_punct() => tt::Spacing::Joint,
+                    Some(next) if next.kind().is_punct() => tt::Spacing::Joint,
                     _ => tt::Spacing::Alone,
                 };
-                let char =
-                    self.text[range].chars().next().expect("Token from lexer must be single char");
+                let char = token.to_char().expect("Token from lexer must be single char");
 
-                tt::Leaf::from(tt::Punct { char, spacing, id: self.id_alloc.alloc(range) }).into()
+                tt::Leaf::from(tt::Punct { char, spacing, id: self.id_alloc().alloc(range) }).into()
             }
         } else {
             macro_rules! make_leaf {
                 ($i:ident) => {
-                    tt::$i { id: self.id_alloc.alloc(range), text: self.text[range].into() }.into()
+                    tt::$i { id: self.id_alloc().alloc(range), text: token.to_text() }.into()
                 };
             }
             let leaf: tt::Leaf = match k {
@@ -368,133 +380,168 @@ impl RawConvertor<'_> {
             leaf.into()
         });
     }
+
+    fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>>;
+
+    fn bump(&mut self) -> Option<(Self::Token, TextRange)>;
+
+    fn peek(&self) -> Option<Self::Token>;
+
+    fn id_alloc(&mut self) -> &mut TokenIdAlloc;
+}
+
+impl<'a> SrcToken for (RawToken, &'a str) {
+    fn kind(&self) -> SyntaxKind {
+        self.0.kind
+    }
+
+    fn to_char(&self) -> Option<char> {
+        self.1.chars().next()
+    }
+
+    fn to_text(&self) -> SmolStr {
+        self.1.into()
+    }
+}
+
+impl RawConvertor<'_> {}
+
+impl<'a> TokenConvertor for RawConvertor<'a> {
+    type Token = (RawToken, &'a str);
+
+    fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>> {
+        convert_doc_comment(&doc_comment(token.1))
+    }
+
+    fn bump(&mut self) -> Option<(Self::Token, TextRange)> {
+        let token = self.inner.next()?;
+        let range = TextRange::offset_len(self.offset, token.len);
+        self.offset += token.len;
+
+        Some(((*token, &self.text[range]), range))
+    }
+
+    fn peek(&self) -> Option<Self::Token> {
+        let token = self.inner.as_slice().get(0).cloned();
+
+        token.map(|it| {
+            let range = TextRange::offset_len(self.offset, it.len);
+            (it, &self.text[range])
+        })
+    }
+
+    fn id_alloc(&mut self) -> &mut TokenIdAlloc {
+        &mut self.id_alloc
+    }