59 files changed, 1420 insertions, 582 deletions
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();
+    SyntaxRewriter::from_fn(|element| match element {
-    let result = ra_syntax::algo::replace_descendants(syntax, |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::Move { distance } => {}
-        Action::Stop => (),
+        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 {
+                    let located_assoc_item = match candidate {
-                        ModuleDef::Function(located_function) => located_function
+                        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,
+        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
-        VISIBILITY, WHITESPACE,
+        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_name: ast::Name = ctx.find_node_at_offset()?;
-        let field = ident.parent().ancestors().find_map(ast::RecordFieldDef::cast)?;
+        let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
-        if field.name()?.syntax().text_range() != ident.text_range() && field.visibility().is_some()
+        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 }",
+            r"struct S { <|>field: u32 }",
-            "struct S { <|>pub(crate) 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::Move { distance } => {}
-//         Action::Stop => (),
+//         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::Bs{x,y:Some(_)} => {}
-                    A::Cs(_, Some(_)) => (),
+                    A::Cs(_, Some(_)) => {}
                }
            }
            "#,
@@ -227,8 +227,8 @@ mod tests {
            }
            fn main() {
                match A::As<|> {
-                    A::Bs{x,y:Some(_)} => (),
+                    A::Bs{x,y:Some(_)} => {}
-                    A::Cs(_, Some(_)) => (),
+                    A::Cs(_, Some(_)) => {}
                }
            }
            "#,
@@ -240,9 +240,9 @@ mod tests {
            }
            fn main() {
                match <|>A::As {
-                    A::Bs{x,y:Some(_)} => (),
+                    A::Bs{x,y:Some(_)} => {}
-                    A::Cs(_, Some(_)) => (),
+                    A::Cs(_, Some(_)) => {}
-                    A::As => (),
+                    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::Cs(_) | A::Bs => {}
-                    A::As => (),
+                    A::As => {}
                }
            }
            "#,
@@ -299,8 +299,8 @@ mod tests {
            }
            fn main() {
                match A::As<|> {
-                    A::Bs if 0 < 1 => (),
+                    A::Bs if 0 < 1 => {}
-                    A::Ds(_value) => (),
+                    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::Bs if 0 < 1 => {}
-                    A::Ds(_value) => (),
+                    A::Ds(_value) => { let x = 1; }
                    A::Es(B::Xs) => (),
-                    A::As => (),
+                    A::As => {}
-                    A::Cs => (),
+                    A::Cs => {}
                }
            }
            "#,
@@ -360,11 +360,11 @@ mod tests {
            fn main() {
                let a = A::As;
                match <|>a {
-                    A::As => (),
+                    A::As => {}
-                    A::Bs => (),
+                    A::Bs => {}
-                    A::Cs(_) => (),
+                    A::Cs(_) => {}
-                    A::Ds(_, _) => (),
+                    A::Ds(_, _) => {}
-                    A::Es { x, y } => (),
+                    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::One) => {}
-                    (A::One, B::Two) => (),
+                    (A::One, B::Two) => {}
-                    (A::Two, B::One) => (),
+                    (A::Two, B::One) => {}
-                    (A::Two, B::Two) => (),
+                    (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::One) => {}
-                    (A::One, B::Two) => (),
+                    (A::One, B::Two) => {}
-                    (A::Two, B::One) => (),
+                    (A::Two, B::One) => {}
-                    (A::Two, B::Two) => (),
+                    (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::Two, B::One) => {}
-                    (A::One, B::One) => (),
+                    (A::One, B::One) => {}
-                    (A::One, B::Two) => (),
+                    (A::One, B::Two) => {}
-                    (A::Two, 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::X => {}
-                    E::Y => (),
+                    E::Y => {}
                }
            }
            "#,
@@ -648,8 +648,8 @@ mod tests {
            fn main() {
                match <|>X {
-                    X => (),
+                    X => {}
-                    foo::E::Y => (),
+                    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) =
+    let mut rewriter = SyntaxRewriter::default();
-        tree.syntax().parent().and_then(ast::UseItem::cast)
+    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();
+        rewriter.replace_ast(&tree, &merged);
-        let next_ws = to_delete
+        rewriter += to_delete.remove();
-            .syntax()
-            .next_sibling_or_token()
+        if to_delete.syntax().text_range().end() < offset {
-            .and_then(|it| it.into_token())
+            offset -= to_delete.syntax().text_range().len();
-            .and_then(ast::Whitespace::cast);
-        if let Some(ws) = next_ws {
-            range = range.extend_to(&ws.syntax().text_range())
        }
-        (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();
+        rewriter.replace_ast(&tree, &merged);
-        if let Some((dir, nb)) = next_prev().find_map(|dir| Some((dir, neighbor(&to_delete, dir)?)))
+        rewriter += to_delete.remove();
-        {
-            let nb_range = nb.syntax().text_range();
+        if to_delete.syntax().text_range().end() < offset {
-            if dir == Direction::Prev {
+            offset -= to_delete.syntax().text_range().len();
-                range = TextRange::from_to(nb_range.end(), range.end());
-            } else {
-                range = TextRange::from_to(range.start(), nb_range.start());
-            }
        }
-        (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.rewrite(rewriter);
-        edit.delete(to_delete);
+        // FIXME: we only need because our diff is imprecise
-        if to_delete.end() <= offset {
-            offset -= to_delete.len();
-        }
        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(vec![db.file_source_root(file_id)]));
-        db.set_local_roots(Arc::new(local_roots));
        (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 (text_without_caret, file_with_caret_id, range_or_offset, db) =
-        let range: TextRange = range_or_offset.into();
+            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,
+        db: &dyn DefDatabase,
-        item: ModuleDef,
+        item: impl Into<ItemInNs>,
    ) -> Option<hir_def::path::ModPath> {
-        // FIXME expose namespace choice
+        hir_def::find_path::find_path(db, item.into(), self.into())
-        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()),
    }
 }
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,
+    AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
-    MacroExpandQuery, ParseMacroQuery,
+    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,
+    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local,
-    VariantDef,
+    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> {
+    fn expr_id(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<ExprId> {
-        let src = InFile { file_id: self.file_id, value: expr };
+        let src = match expr {
-        self.body_source_map.as_ref()?.node_expr(src)
+            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 {
+        let expr_id = self.expr_id(db, 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 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> {
+    pub(crate) fn resolve_method_call(
-        let expr_id = self.expr_id(&call.clone().into())?;
+        &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> {
+    pub(crate) fn resolve_field(
-        let expr_id = self.expr_id(&field.clone().into())?;
+        &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) =
+            if let Some(call_id) = directive
-                directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
+                .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> {
+    fn resolve_attribute_macro(
-        // FIXME this is currently super hacky, just enough to support the
+        &self,
-        // built-in derives
+        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 attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
-        let def =
-            MacroDefId { krate: None, ast_id: None, kind: MacroDefKind::BuiltInDerive(expander) };
-        let loc = MacroCallLoc {
+        let loc = MacroCallLoc { def, kind: MacroCallKind::Attr(attr_id, name.to_string()) };
-            def,
-            kind: MacroCallKind::Attr(AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]))),
-        };
        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 ra_syntax::{algo::SyntaxRewriter, SyntaxNode};
-use std::{collections::HashMap, sync::Arc};
+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() {
+    let res = rewriter.rewrite(&original);
-        original = replace_descendants(&original, |n| replaces.get(n).cloned());
+    Some(res)
-    }
-    Some(original)
 }
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 receiver_text =
-        let text = dot_receiver.syntax().text();
+        get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
-        let without_dot = ..text.len() - TextUnit::of_char('.');
-        text.slice(without_dot).to_string()
-    } else {
-        dot_receiver.syntax().text().to_string()
-    };
    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, &dot_receiver, "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, "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},
+    algo::{find_node_at_offset, SyntaxRewriter},
-    ast, AstNode, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, WalkEvent, T,
+    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,
+    HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution, Semantics,
-    Semantics, StructField, TypeParam,
+    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 {
+            Definition::StructField(sf) => Some(sf.visibility(db)),
-                FieldSource::Named(it) => it.visibility(),
+            Definition::ModuleDef(def) => module?.visibility_of(db, def),
-                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::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)" {
+        // FIXME:
-            if let Some(parent_module) = module.parent(db) {
+        // The following logic are wrong that it does not search
-                let mut res = FxHashMap::default();
+        // for submodules within other files recursively.
-                let parent_src = parent_module.definition_source(db);
-                let file_id = parent_src.file_id.original_file(db);
-                match parent_src.value {
+        if let Some(Visibility::Module(module)) = vis.and_then(|it| it.into()) {
-                    ModuleSource::Module(m) => {
+            let module: Module = module.into();
-                        let range = Some(m.syntax().text_range());
+            let mut res = FxHashMap::default();
-                        res.insert(file_id, range);
+            let src = module.definition_source(db);
-                    }
+            let file_id = src.file_id.original_file(db);
-                    ModuleSource::SourceFile(_) => {
-                        res.insert(file_id, None);
+            match src.value {
-                        res.extend(parent_module.children(db).map(|m| {
+                ModuleSource::Module(m) => {
-                            let src = m.definition_source(db);
+                    let range = Some(m.syntax().text_range());
-                            (src.file_id.original_file(db), None)
+                    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)"
+            let krate = module.krate();
+            for rev_dep in krate.reverse_dependencies(db) {
-            if vis.as_str() == "pub(crate)" {
+                let root_file = rev_dep.root_file(db);
-                return SearchScope::new(res);
+                let source_root_id = db.file_source_root(root_file);
-            }
+                let source_root = db.source_root(source_root_id);
-            if vis.as_str() == "pub" {
+                res.extend(source_root.walk().map(|id| (id, None)));
-                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);
            }
+            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 {
+    let mut c = Convertor::new(node, global_offset);
-        id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
+    let subtree = c.go()?;
-    };
-    let subtree = c.go(node)?;
    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) {
+    fn close_delim(&mut self, id: tt::TokenId, close_abs_range: Option<TextRange>) {
-        self.map.update_close_delim(id, close_abs_range);
+        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) = self.convert_doc_comment(&token) {
-            if let Some(tokens) = convert_doc_comment(&node) {
                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()
+                        if next.kind().is_trivia()
-                            || next.kind == T!['[']
+                            || next.kind() == T!['[']
-                            || next.kind == T!['{']
+                            || 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 =
+                let char = token.to_char().expect("Token from lexer must be single char");
-                    self.text[range].chars().next().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
+    }
 }
-// FIXME: There are some duplicate logic between RawConvertor and Convertor
-// It would be nice to refactor to converting SyntaxNode to ra_parser::Token and thus
-// use RawConvertor directly. But performance-wise it may not be a good idea ?
 struct Convertor {
    id_alloc: TokenIdAlloc,
+    current: Option<SyntaxToken>,
+    range: TextRange,
+    punct_offset: Option<(SyntaxToken, TextUnit)>,
 }
 impl Convertor {
-    fn go(&mut self, tt: &SyntaxNode) -> Option<tt::Subtree> {
+    fn new(node: &SyntaxNode, global_offset: TextUnit) -> Convertor {
-        // This tree is empty
+        Convertor {
-        if tt.first_child_or_token().is_none() {
+            id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
-            return Some(tt::Subtree { token_trees: vec![], delimiter: None });
+            current: node.first_token(),
+            range: node.text_range(),
+            punct_offset: None,
        }
+    }
+}
-        let first_child = tt.first_child_or_token()?;
+enum SynToken {
-        let last_child = tt.last_child_or_token()?;
+    Ordiniary(SyntaxToken),
+    Punch(SyntaxToken, TextUnit),
+}
-        // ignore trivial first_child and last_child
+impl SynToken {
-        let first_child = successors(Some(first_child), |it| {
+    fn token(&self) -> &SyntaxToken {
-            if it.kind().is_trivia() {
+        match self {
-                it.next_sibling_or_token()
+            SynToken::Ordiniary(it) => it,
-            } else {
+            SynToken::Punch(it, _) => it,
-                None
-            }
-        })
-        .last()
-        .unwrap();
-        if first_child.kind().is_trivia() {
-            return Some(tt::Subtree { token_trees: vec![], delimiter: None });
        }
+    }
+}
-        let last_child = successors(Some(last_child), |it| {
+impl SrcToken for SynToken {
-            if it.kind().is_trivia() {
+    fn kind(&self) -> SyntaxKind {
-                it.prev_sibling_or_token()
+        self.token().kind()
-            } else {
+    }
-                None
+    fn to_char(&self) -> Option<char> {
+        match self {
+            SynToken::Ordiniary(_) => None,
+            SynToken::Punch(it, i) => it.text().chars().nth(i.to_usize()),
+        }
+    }
+    fn to_text(&self) -> SmolStr {
+        self.token().text().clone()
+    }
+}
+impl TokenConvertor for Convertor {
+    type Token = SynToken;
+    fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>> {
+        convert_doc_comment(token.token())
+    }
+    fn bump(&mut self) -> Option<(Self::Token, TextRange)> {
+        if let Some((punct, offset)) = self.punct_offset.clone() {
+            if offset.to_usize() + 1 < punct.text().len() {
+                let offset = offset + TextUnit::from_usize(1);
+                let range = punct.text_range();
+                self.punct_offset = Some((punct.clone(), offset));
+                let range = TextRange::offset_len(range.start() + offset, TextUnit::from_usize(1));
+                return Some((SynToken::Punch(punct, offset), range));
            }
-        })
+        }
-        .last()
-        .unwrap();
+        let curr = self.current.clone()?;
+        if !curr.text_range().is_subrange(&self.range) {
-        let (delimiter_kind, skip_first) = match (first_child.kind(), last_child.kind()) {
+            return None;
-            (T!['('], T![')']) => (Some(tt::DelimiterKind::Parenthesis), true),
+        }
-            (T!['{'], T!['}']) => (Some(tt::DelimiterKind::Brace), true),
+        self.current = curr.next_token();
-            (T!['['], T![']']) => (Some(tt::DelimiterKind::Bracket), true),
-            _ => (None, false),
+        let token = if curr.kind().is_punct() {
+            let range = curr.text_range();
+            let range = TextRange::offset_len(range.start(), TextUnit::from_usize(1));
+            self.punct_offset = Some((curr.clone(), TextUnit::from_usize(0)));
+            (SynToken::Punch(curr, TextUnit::from_usize(0)), range)
+        } else {
+            self.punct_offset = None;
+            let range = curr.text_range();
+            (SynToken::Ordiniary(curr), range)
        };
-        let delimiter = delimiter_kind.map(|kind| tt::Delimiter {
-            kind,
-            id: self.id_alloc.delim(first_child.text_range(), last_child.text_range()),
-        });
-        let mut token_trees = Vec::new();
+        Some(token)
-        let mut child_iter = tt.children_with_tokens().skip(skip_first as usize).peekable();
+    }
-        while let Some(child) = child_iter.next() {
+    fn peek(&self) -> Option<Self::Token> {
-            if skip_first && (child == first_child || child == last_child) {
+        if let Some((punct, mut offset)) = self.punct_offset.clone() {
-                continue;
+            offset = offset + TextUnit::from_usize(1);
+            if offset.to_usize() < punct.text().len() {
+                return Some(SynToken::Punch(punct, offset));
            }
+        }
-            match child {
+        let curr = self.current.clone()?;
-                NodeOrToken::Token(token) => {
+        if !curr.text_range().is_subrange(&self.range) {
-                    if let Some(doc_tokens) = convert_doc_comment(&token) {
+            return None;
-                        token_trees.extend(doc_tokens);
-                    } else if token.kind().is_trivia() {
-                        continue;
-                    } else if token.kind().is_punct() {
-                        // we need to pull apart joined punctuation tokens
-                        let last_spacing = match child_iter.peek() {
-                            Some(NodeOrToken::Token(token)) => {
-                                if token.kind().is_punct() {
-                                    tt::Spacing::Joint
-                                } else {
-                                    tt::Spacing::Alone
-                                }
-                            }
-                            _ => tt::Spacing::Alone,
-                        };
-                        let spacing_iter = std::iter::repeat(tt::Spacing::Joint)
-                            .take(token.text().len() - 1)
-                            .chain(std::iter::once(last_spacing));
-                        for (char, spacing) in token.text().chars().zip(spacing_iter) {
-                            token_trees.push(
-                                tt::Leaf::from(tt::Punct {
-                                    char,
-                                    spacing,
-                                    id: self.id_alloc.alloc(token.text_range()),
-                                })
-                                .into(),
-                            );
-                        }
-                    } else {
-                        macro_rules! make_leaf {
-                            ($i:ident) => {
-                                tt::$i {
-                                    id: self.id_alloc.alloc(token.text_range()),
-                                    text: token.text().clone(),
-                                }
-                                .into()
-                            };
-                        }
-                        let child: tt::Leaf = match token.kind() {
-                            T![true] | T![false] => make_leaf!(Literal),
-                            IDENT | LIFETIME => make_leaf!(Ident),
-                            k if k.is_keyword() => make_leaf!(Ident),
-                            k if k.is_literal() => make_leaf!(Literal),
-                            _ => return None,
-                        };
-                        token_trees.push(child.into());
-                    }
-                }
-                NodeOrToken::Node(node) => {
-                    let child_subtree = self.go(&node)?;
-                    if child_subtree.delimiter.is_none() && node.kind() != SyntaxKind::TOKEN_TREE {
-                        token_trees.extend(child_subtree.token_trees);
-                    } else {
-                        token_trees.push(child_subtree.into());
-                    }
-                }
-            };
        }
-        let res = tt::Subtree { delimiter, token_trees };
+        let token = if curr.kind().is_punct() {
-        Some(res)
+            SynToken::Punch(curr, TextUnit::from_usize(0))
+        } else {
+            SynToken::Ordiniary(curr)
+        };
+        Some(token)
+    }
+    fn id_alloc(&mut self) -> &mut TokenIdAlloc {
+        &mut self.id_alloc
    }
 }
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 44f381938..a7fcea0ac 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -427,22 +427,28 @@ MACRO_ITEMS@[0; 40)
    );
 }
-#[test]
+fn to_subtree(tt: &tt::TokenTree) -> &tt::Subtree {
-fn test_expand_literals_to_token_tree() {
+    if let tt::TokenTree::Subtree(subtree) = tt {
-    fn to_subtree(tt: &tt::TokenTree) -> &tt::Subtree {
+        return &subtree;
-        if let tt::TokenTree::Subtree(subtree) = tt {
-            return &subtree;
-        }
-        unreachable!("It is not a subtree");
    }
+    unreachable!("It is not a subtree");
+}
+fn to_literal(tt: &tt::TokenTree) -> &tt::Literal {
+    if let tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) = tt {
+        return lit;
+    }
+    unreachable!("It is not a literal");
+}
-    fn to_literal(tt: &tt::TokenTree) -> &tt::Literal {
+fn to_punct(tt: &tt::TokenTree) -> &tt::Punct {
-        if let tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) = tt {
+    if let tt::TokenTree::Leaf(tt::Leaf::Punct(lit)) = tt {
-            return lit;
+        return lit;
-        }
-        unreachable!("It is not a literal");
    }
+    unreachable!("It is not a Punct");
+}
+#[test]
+fn test_expand_literals_to_token_tree() {
    let expansion = parse_macro(
        r#"
            macro_rules! literals {
@@ -471,6 +477,22 @@ fn test_expand_literals_to_token_tree() {
 }
 #[test]
+fn test_attr_to_token_tree() {
+    let expansion = parse_to_token_tree_by_syntax(
+        r#"
+            #[derive(Copy)]
+            struct Foo;
+            "#,
+    );
+    assert_eq!(to_punct(&expansion.token_trees[0]).char, '#');
+    assert_eq!(
+        to_subtree(&expansion.token_trees[1]).delimiter_kind(),
+        Some(tt::DelimiterKind::Bracket)
+    );
+}
+#[test]
 fn test_two_idents() {
    parse_macro(
        r#"
@@ -1427,8 +1449,8 @@ impl MacroFixture {
        let macro_invocation =
            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-        let (invocation_tt, _) =
+        let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap())
-            ast_to_token_tree(&macro_invocation.token_tree().unwrap()).unwrap();
+            .ok_or_else(|| ExpandError::ConversionError)?;
        self.rules.expand(&invocation_tt).result()
    }
@@ -1517,6 +1539,16 @@ pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
    MacroFixture { rules }
 }
+pub(crate) fn parse_to_token_tree_by_syntax(ra_fixture: &str) -> tt::Subtree {
+    let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
+    let tt = syntax_node_to_token_tree(source_file.syntax()).unwrap().0;
+    let parsed = parse_to_token_tree(ra_fixture).unwrap().0;
+    assert_eq!(tt, parsed);
+    parsed
+}
 fn debug_dump_ignore_spaces(node: &ra_syntax::SyntaxNode) -> String {
    let mut level = 0;
    let mut buf = String::new();
@@ -1662,5 +1694,5 @@ fn test_expand_bad_literal() {
        macro_rules! foo { ($i:literal) => {}; }
    "#,
    )
-    .assert_expand_err(r#"foo!(&k");"#, &ExpandError::BindingError("".to_string()));
+    .assert_expand_err(r#"foo!(&k");"#, &ExpandError::BindingError("".into()));
 }
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 2335d99b3..0d277a586 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -230,14 +230,20 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
    p.eat(T![async]);
    p.eat(T![move]);
    params::param_list_closure(p);
-    if opt_fn_ret_type(p) && !p.at(T!['{']) {
+    if opt_fn_ret_type(p) {
-        p.error("expected `{`");
+        if p.at(T!['{']) {
-    }
+            // test lambda_ret_block
+            // fn main() { || -> i32 { 92 }(); }
-    if p.at_ts(EXPR_FIRST) {
+            block_expr(p, None);
-        expr(p);
+        } else {
+            p.error("expected `{`");
+        }
    } else {
-        p.error("expected expression");
+        if p.at_ts(EXPR_FIRST) {
+            expr(p);
+        } else {
+            p.error("expected expression");
+        }
    }
    m.complete(p, LAMBDA_EXPR)
 }
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 8efc6b368..6fccc2303 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -11,7 +11,7 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 doctest = false
 [dependencies]
-itertools = "0.8.2"
+itertools = "0.9.0"
 rowan = "0.9.1"
 rustc_lexer = "0.1.0"
 rustc-hash = "1.1.0"
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index ffdbdc767..191123c8e 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -1,6 +1,9 @@
 //! FIXME: write short doc here
-use std::ops::RangeInclusive;
+use std::{
+    fmt,
+    ops::{self, RangeInclusive},
+};
 use itertools::Itertools;
 use ra_text_edit::TextEditBuilder;
@@ -222,44 +225,110 @@ fn _replace_children(
    with_children(parent, new_children)
 }
-/// Replaces descendants in the node, according to the mapping.
+#[derive(Default)]
-///
+pub struct SyntaxRewriter<'a> {
-/// This is a type-unsafe low-level editing API, if you need to use it, prefer
+    f: Option<Box<dyn Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a>>,
-/// to create a type-safe abstraction on top of it instead.
+    //FIXME: add debug_assertions that all elements are in fact from the same file.
-pub fn replace_descendants(
+    replacements: FxHashMap<SyntaxElement, Replacement>,
-    parent: &SyntaxNode,
-    map: impl Fn(&SyntaxElement) -> Option<SyntaxElement>,
-) -> SyntaxNode {
-    _replace_descendants(parent, &map)
 }
-fn _replace_descendants(
+impl fmt::Debug for SyntaxRewriter<'_> {
-    parent: &SyntaxNode,
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    map: &dyn Fn(&SyntaxElement) -> Option<SyntaxElement>,
+        f.debug_struct("SyntaxRewriter").field("replacements", &self.replacements).finish()
-) -> SyntaxNode {
+    }
-    //  FIXME: this could be made much faster.
+}
-    let new_children = parent.children_with_tokens().map(|it| go(map, it)).collect::<Vec<_>>();
-    return with_children(parent, new_children);
-    fn go(
+impl<'a> SyntaxRewriter<'a> {
-        map: &dyn Fn(&SyntaxElement) -> Option<SyntaxElement>,
+    pub fn from_fn(f: impl Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a) -> SyntaxRewriter<'a> {
-        element: SyntaxElement,
+        SyntaxRewriter { f: Some(Box::new(f)), replacements: FxHashMap::default() }
-    ) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
+    }
-        if let Some(replacement) = map(&element) {
+    pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
+        let what = what.clone().into();
+        let replacement = Replacement::Delete;
+        self.replacements.insert(what, replacement);
+    }
+    pub fn replace<T: Clone + Into<SyntaxElement>>(&mut self, what: &T, with: &T) {
+        let what = what.clone().into();
+        let replacement = Replacement::Single(with.clone().into());
+        self.replacements.insert(what, replacement);
+    }
+    pub fn replace_ast<T: AstNode>(&mut self, what: &T, with: &T) {
+        self.replace(what.syntax(), with.syntax())
+    }
+    pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
+        if self.f.is_none() && self.replacements.is_empty() {
+            return node.clone();
+        }
+        self.rewrite_children(node)
+    }
+    pub fn rewrite_ast<N: AstNode>(self, node: &N) -> N {
+        N::cast(self.rewrite(node.syntax())).unwrap()
+    }
+    pub fn rewrite_root(&self) -> Option<SyntaxNode> {
+        assert!(self.f.is_none());
+        self.replacements
+            .keys()
+            .map(|element| match element {
+                SyntaxElement::Node(it) => it.clone(),
+                SyntaxElement::Token(it) => it.parent(),
+            })
+            .fold1(|a, b| least_common_ancestor(&a, &b).unwrap())
+    }
+    fn replacement(&self, element: &SyntaxElement) -> Option<Replacement> {
+        if let Some(f) = &self.f {
+            assert!(self.replacements.is_empty());
+            return f(element).map(Replacement::Single);
+        }
+        self.replacements.get(element).cloned()
+    }
+    fn rewrite_children(&self, node: &SyntaxNode) -> SyntaxNode {
+        //  FIXME: this could be made much faster.
+        let new_children =
+            node.children_with_tokens().flat_map(|it| self.rewrite_self(&it)).collect::<Vec<_>>();
+        with_children(node, new_children)
+    }
+    fn rewrite_self(
+        &self,
+        element: &SyntaxElement,
+    ) -> Option<NodeOrToken<rowan::GreenNode, rowan::GreenToken>> {
+        if let Some(replacement) = self.replacement(&element) {
            return match replacement {
-                NodeOrToken::Node(it) => NodeOrToken::Node(it.green().clone()),
+                Replacement::Single(NodeOrToken::Node(it)) => {
-                NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
+                    Some(NodeOrToken::Node(it.green().clone()))
+                }
+                Replacement::Single(NodeOrToken::Token(it)) => {
+                    Some(NodeOrToken::Token(it.green().clone()))
+                }
+                Replacement::Delete => None,
            };
        }
-        match element {
+        let res = match element {
            NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
-            NodeOrToken::Node(it) => {
+            NodeOrToken::Node(it) => NodeOrToken::Node(self.rewrite_children(it).green().clone()),
-                NodeOrToken::Node(_replace_descendants(&it, map).green().clone())
+        };
-            }
+        Some(res)
-        }
    }
 }
+impl<'a> ops::AddAssign for SyntaxRewriter<'_> {
+    fn add_assign(&mut self, rhs: SyntaxRewriter) {
+        assert!(rhs.f.is_none());
+        self.replacements.extend(rhs.replacements)
+    }
+}
+#[derive(Clone, Debug)]
+enum Replacement {
+    Delete,
+    Single(SyntaxElement),
+}
 fn with_children(
    parent: &SyntaxNode,
    new_children: Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 68dae008f..f74c9f9c6 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -4,7 +4,6 @@
 use std::{iter, ops::RangeInclusive};
 use arrayvec::ArrayVec;
-use rustc_hash::FxHashMap;
 use crate::{
    algo,
@@ -17,6 +16,7 @@ use crate::{
    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
    SyntaxNode, SyntaxToken, T,
 };
+use algo::{neighbor, SyntaxRewriter};
 impl ast::BinExpr {
    #[must_use]
@@ -255,6 +255,28 @@ impl ast::UseItem {
        }
        self.clone()
    }
+    pub fn remove(&self) -> SyntaxRewriter<'static> {
+        let mut res = SyntaxRewriter::default();
+        res.delete(self.syntax());
+        let next_ws = self
+            .syntax()
+            .next_sibling_or_token()
+            .and_then(|it| it.into_token())
+            .and_then(ast::Whitespace::cast);
+        if let Some(next_ws) = next_ws {
+            let ws_text = next_ws.syntax().text();
+            if ws_text.starts_with('\n') {
+                let rest = &ws_text[1..];
+                if rest.is_empty() {
+                    res.delete(next_ws.syntax())
+                } else {
+                    res.replace(next_ws.syntax(), &make::tokens::whitespace(rest));
+                }
+            }
+        }
+        res
+    }
 }
 impl ast::UseTree {
@@ -293,14 +315,30 @@ impl ast::UseTree {
            Some(res)
        }
    }
+    pub fn remove(&self) -> SyntaxRewriter<'static> {
+        let mut res = SyntaxRewriter::default();
+        res.delete(self.syntax());
+        for &dir in [Direction::Next, Direction::Prev].iter() {
+            if let Some(nb) = neighbor(self, dir) {
+                self.syntax()
+                    .siblings_with_tokens(dir)
+                    .skip(1)
+                    .take_while(|it| it.as_node() != Some(nb.syntax()))
+                    .for_each(|el| res.delete(&el));
+                return res;
+            }
+        }
+        res
+    }
 }
 #[must_use]
-pub fn strip_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
+pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
-    N::cast(strip_attrs_and_docs_inner(node.syntax().clone())).unwrap()
+    N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
 }
-fn strip_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
+fn remove_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
    while let Some(start) =
        node.children_with_tokens().find(|it| it.kind() == ATTR || it.kind() == COMMENT)
    {
@@ -343,28 +381,24 @@ impl IndentLevel {
    }
    fn _increase_indent(self, node: SyntaxNode) -> SyntaxNode {
-        let replacements: FxHashMap<SyntaxElement, SyntaxElement> = node
+        let mut rewriter = SyntaxRewriter::default();
-            .descendants_with_tokens()
+        node.descendants_with_tokens()
            .filter_map(|el| el.into_token())
            .filter_map(ast::Whitespace::cast)
            .filter(|ws| {
                let text = ws.syntax().text();
                text.contains('\n')
            })
-            .map(|ws| {
+            .for_each(|ws| {
-                (
+                let new_ws = make::tokens::whitespace(&format!(
-                    ws.syntax().clone().into(),
+                    "{}{:width$}",
-                    make::tokens::whitespace(&format!(
+                    ws.syntax().text(),
-                        "{}{:width$}",
+                    "",
-                        ws.syntax().text(),
+                    width = self.0 as usize * 4
-                        "",
+                ));
-                        width = self.0 as usize * 4
+                rewriter.replace(ws.syntax(), &new_ws)
-                    ))
+            });
-                    .into(),
+        rewriter.rewrite(&node)
-                )
-            })
-            .collect();
-        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
    }
    pub fn decrease_indent<N: AstNode>(self, node: N) -> N {
@@ -372,27 +406,21 @@ impl IndentLevel {
    }
    fn _decrease_indent(self, node: SyntaxNode) -> SyntaxNode {
-        let replacements: FxHashMap<SyntaxElement, SyntaxElement> = node
+        let mut rewriter = SyntaxRewriter::default();
-            .descendants_with_tokens()
+        node.descendants_with_tokens()
            .filter_map(|el| el.into_token())
            .filter_map(ast::Whitespace::cast)
            .filter(|ws| {
                let text = ws.syntax().text();
                text.contains('\n')
            })
-            .map(|ws| {
+            .for_each(|ws| {
-                (
+                let new_ws = make::tokens::whitespace(
-                    ws.syntax().clone().into(),
+                    &ws.syntax().text().replace(&format!("\n{:1$}", "", self.0 as usize * 4), "\n"),
-                    make::tokens::whitespace(
+                );
-                        &ws.syntax()
+                rewriter.replace(ws.syntax(), &new_ws)
-                            .text()
+            });
-                            .replace(&format!("\n{:1$}", "", self.0 as usize * 4), "\n"),
+        rewriter.rewrite(&node)
-                    )
-                    .into(),
-                )
-            })
-            .collect();
-        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
    }
 }
@@ -442,12 +470,11 @@ pub trait AstNodeEdit: AstNode + Sized {
        &self,
        replacement_map: impl IntoIterator<Item = (D, D)>,
    ) -> Self {
-        let map = replacement_map
+        let mut rewriter = SyntaxRewriter::default();
-            .into_iter()
+        for (from, to) in replacement_map {
-            .map(|(from, to)| (from.syntax().clone().into(), to.syntax().clone().into()))
+            rewriter.replace(from.syntax(), to.syntax())
-            .collect::<FxHashMap<SyntaxElement, _>>();
+        }
-        let new_syntax = algo::replace_descendants(self.syntax(), |n| map.get(n).cloned());
+        rewriter.rewrite_ast(self)
-        Self::cast(new_syntax).unwrap()
    }
 }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 9257ccd1a..1145b69e8 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -87,6 +87,9 @@ pub fn block_from_expr(e: ast::Expr) -> ast::Block {
 pub fn expr_unit() -> ast::Expr {
    expr_from_text("()")
 }
+pub fn expr_empty_block() -> ast::Expr {
+    expr_from_text("{}")
+}
 pub fn expr_unimplemented() -> ast::Expr {
    expr_from_text("unimplemented!()")
 }
diff --git a/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt b/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
index e0edf6a2d..0ffbd25aa 100644
--- a/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
+++ b/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
@@ -12,8 +12,8 @@ SOURCE_FILE@[0; 42)
      BLOCK@[10; 41)
        L_CURLY@[10; 11) "{"
        WHITESPACE@[11; 16) "\n    "
-        EXPR_STMT@[16; 39)
+        EXPR_STMT@[16; 24)
-          LAMBDA_EXPR@[16; 38)
+          LAMBDA_EXPR@[16; 24)
            PARAM_LIST@[16; 18)
              PIPE@[16; 17) "|"
              PIPE@[17; 18) "|"
@@ -24,20 +24,22 @@ SOURCE_FILE@[0; 42)
              TUPLE_TYPE@[22; 24)
                L_PAREN@[22; 23) "("
                R_PAREN@[23; 24) ")"
-            WHITESPACE@[24; 25) " "
+        WHITESPACE@[24; 25) " "
-            BLOCK_EXPR@[25; 38)
+        EXPR_STMT@[25; 39)
-              UNSAFE_KW@[25; 31) "unsafe"
+          BLOCK_EXPR@[25; 38)
-              WHITESPACE@[31; 32) " "
+            UNSAFE_KW@[25; 31) "unsafe"
-              BLOCK@[32; 38)
+            WHITESPACE@[31; 32) " "
-                L_CURLY@[32; 33) "{"
+            BLOCK@[32; 38)
-                WHITESPACE@[33; 34) " "
+              L_CURLY@[32; 33) "{"
-                TUPLE_EXPR@[34; 36)
+              WHITESPACE@[33; 34) " "
-                  L_PAREN@[34; 35) "("
+              TUPLE_EXPR@[34; 36)
-                  R_PAREN@[35; 36) ")"
+                L_PAREN@[34; 35) "("
-                WHITESPACE@[36; 37) " "
+                R_PAREN@[35; 36) ")"
-                R_CURLY@[37; 38) "}"
+              WHITESPACE@[36; 37) " "
+              R_CURLY@[37; 38) "}"
          SEMI@[38; 39) ";"
        WHITESPACE@[39; 40) "\n"
        R_CURLY@[40; 41) "}"
  WHITESPACE@[41; 42) "\n"
 error [24; 24): expected `{`
+error [24; 24): expected SEMI
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs
new file mode 100644
index 000000000..061118d3a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs
@@ -0,0 +1 @@
+fn main() { || -> i32 { 92 }(); }
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt
new file mode 100644
index 000000000..ba8779094
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt
@@ -0,0 +1,45 @@
+SOURCE_FILE@[0; 34)
+  FN_DEF@[0; 33)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 33)
+      BLOCK@[10; 33)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 12) " "
+        EXPR_STMT@[12; 31)
+          CALL_EXPR@[12; 30)
+            LAMBDA_EXPR@[12; 28)
+              PARAM_LIST@[12; 14)
+                PIPE@[12; 13) "|"
+                PIPE@[13; 14) "|"
+              WHITESPACE@[14; 15) " "
+              RET_TYPE@[15; 21)
+                THIN_ARROW@[15; 17) "->"
+                WHITESPACE@[17; 18) " "
+                PATH_TYPE@[18; 21)
+                  PATH@[18; 21)
+                    PATH_SEGMENT@[18; 21)
+                      NAME_REF@[18; 21)
+                        IDENT@[18; 21) "i32"
+              WHITESPACE@[21; 22) " "
+              BLOCK_EXPR@[22; 28)
+                BLOCK@[22; 28)
+                  L_CURLY@[22; 23) "{"
+                  WHITESPACE@[23; 24) " "
+                  LITERAL@[24; 26)
+                    INT_NUMBER@[24; 26) "92"
+                  WHITESPACE@[26; 27) " "
+                  R_CURLY@[27; 28) "}"
+            ARG_LIST@[28; 30)
+              L_PAREN@[28; 29) "("
+              R_PAREN@[29; 30) ")"
+          SEMI@[30; 31) ";"
+        WHITESPACE@[31; 32) " "
+        R_CURLY@[32; 33) "}"
+  WHITESPACE@[33; 34) "\n"
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index d44f0ef1d..e071e9b8d 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -17,7 +17,7 @@ anyhow = "1.0.26"
 crossbeam-channel = "0.4.0"
 env_logger = { version = "0.7.1", default-features = false }
 globset = "0.4.4"
-itertools = "0.8.2"
+itertools = "0.9.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.73.0", features = ["proposed"] }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 103b2b53c..628ed107e 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -34,6 +34,8 @@ pub struct ServerConfig {
    pub inlay_hints_type: bool,
    #[serde(deserialize_with = "nullable_bool_true")]
    pub inlay_hints_parameter: bool,
+    #[serde(deserialize_with = "nullable_bool_true")]
+    pub inlay_hints_chaining: bool,
    pub inlay_hints_max_length: Option<usize>,
    pub cargo_watch_enable: bool,
@@ -66,6 +68,7 @@ impl Default for ServerConfig {
            lru_capacity: None,
            inlay_hints_type: true,
            inlay_hints_parameter: true,
+            inlay_hints_chaining: true,
            inlay_hints_max_length: None,
            cargo_watch_enable: true,
            cargo_watch_args: Vec::new(),
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index fd4657d7e..6edc03fe0 100644
--- a/crates/rust-analyzer/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -332,6 +332,7 @@ impl ConvWith<&LineIndex> for InlayHint {
            kind: match self.kind {
                InlayKind::ParameterHint => req::InlayKind::ParameterHint,
                InlayKind::TypeHint => req::InlayKind::TypeHint,
+                InlayKind::ChainingHint => req::InlayKind::ChainingHint,
            },
        }
    }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index a8a5894d2..7825b0077 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -183,6 +183,7 @@ pub fn main_loop(
                inlay_hints: InlayHintsOptions {
                    type_hints: config.inlay_hints_type,
                    parameter_hints: config.inlay_hints_parameter,
+                    chaining_hints: config.inlay_hints_chaining,
                    max_length: config.inlay_hints_max_length,
                },
                cargo_watch: CheckOptions {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 1cc2f6571..1033d6de9 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -734,19 +734,29 @@ pub fn handle_code_action(
        res.push(fix.action.clone());
    }
-    let mut grouped_assists: FxHashMap<String, Vec<Assist>> = FxHashMap::default();
+    let mut grouped_assists: FxHashMap<String, (usize, Vec<Assist>)> = FxHashMap::default();
    for assist in world.analysis().assists(FileRange { file_id, range })?.into_iter() {
        match &assist.group_label {
-            Some(label) => grouped_assists.entry(label.to_owned()).or_default().push(assist),
+            Some(label) => grouped_assists
-            None => res.push(create_single_code_action(assist, &world)?.into()),
+                .entry(label.to_owned())
+                .or_insert_with(|| {
+                    let idx = res.len();
+                    let dummy = Command::new(String::new(), String::new(), None);
+                    res.push(dummy.into());
+                    (idx, Vec::new())
+                })
+                .1
+                .push(assist),
+            None => {
+                res.push(create_single_code_action(assist, &world)?.into());
+            }
        }
    }
-    for (group_label, assists) in grouped_assists {
+    for (group_label, (idx, assists)) in grouped_assists {
        if assists.len() == 1 {
-            res.push(
+            res[idx] =
-                create_single_code_action(assists.into_iter().next().unwrap(), &world)?.into(),
+                create_single_code_action(assists.into_iter().next().unwrap(), &world)?.into();
-            );
        } else {
            let title = group_label;
@@ -760,17 +770,15 @@ pub fn handle_code_action(
                command: "rust-analyzer.selectAndApplySourceChange".to_string(),
                arguments: Some(vec![serde_json::Value::Array(arguments)]),
            });
-            res.push(
+            res[idx] = CodeAction {
-                CodeAction {
+                title,
-                    title,
+                kind: None,
-                    kind: None,
+                diagnostics: None,
-                    diagnostics: None,
+                edit: None,
-                    edit: None,
+                command,
-                    command,
+                is_preferred: None,
-                    is_preferred: None,
+            }
-                }
+            .into();
-                .into(),
-            );
        }
    }
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index 9e27d3f1c..8557294f6 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -200,6 +200,7 @@ pub struct InlayHintsParams {
 pub enum InlayKind {
    TypeHint,
    ParameterHint,
+    ChainingHint,
 }
 #[derive(Debug, Deserialize, Serialize)]