Merge branch 'master' of github.com:rust-analyzer/rust-analyzer into modname_spacing

author: Galilée 'Bill' Enguehard <[email protected]> 2020-05-21 22:27:38 +0100
committer: Galilée 'Bill' Enguehard <[email protected]> 2020-05-21 22:27:38 +0100
commit: 7fece3bdd2450c0807f7dd742239cae95f0cc65e (patch)
tree: 866c4db826c959e79c63a6727bdb9f2c61e6fc4f /crates/ra_ide
parent: db926218b2082077750291f8426ddd28b284cd08 (diff)
parent: 59732df8d40dfadc6dcf5951265416576399712a (diff)
37 files changed, 1614 insertions, 546 deletions
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
deleted file mode 100644
index 2b5d11681..000000000
--- a/crates/ra_ide/src/assists.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//! FIXME: write short doc here
-use ra_assists::{resolved_assists, AssistAction, AssistLabel};
-use ra_db::{FilePosition, FileRange};
-use ra_ide_db::RootDatabase;
-use crate::{FileId, SourceChange, SourceFileEdit};
-pub use ra_assists::AssistId;
-#[derive(Debug)]
-pub struct Assist {
-    pub id: AssistId,
-    pub label: String,
-    pub group_label: Option<String>,
-    pub source_change: SourceChange,
-}
-pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
-    resolved_assists(db, frange)
-        .into_iter()
-        .map(|assist| {
-            let file_id = frange.file_id;
-            let assist_label = &assist.label;
-            Assist {
-                id: assist_label.id,
-                label: assist_label.label.clone(),
-                group_label: assist.group_label.map(|it| it.0),
-                source_change: action_to_edit(assist.action, file_id, assist_label),
-            }
-        })
-        .collect()
-}
-fn action_to_edit(
-    action: AssistAction,
-    file_id: FileId,
-    assist_label: &AssistLabel,
-) -> SourceChange {
-    let file_id = match action.file {
-        ra_assists::AssistFile::TargetFile(it) => it,
-        _ => file_id,
-    };
-    let file_edit = SourceFileEdit { file_id, edit: action.edit };
-    SourceChange::source_file_edit(assist_label.label.clone(), file_edit)
-        .with_cursor_opt(action.cursor_position.map(|offset| FilePosition { offset, file_id }))
-}
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 780a03c13..aa039e6fc 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
    ast::{self, ArgListOwner},
    match_ast, AstNode, SyntaxNode, SyntaxToken,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::{CallInfo, FilePosition, FunctionSignature};
@@ -84,7 +84,7 @@ fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Op
                let arg_list_range = arg_list.syntax().text_range();
                if !arg_list_range.contains_inclusive(token.text_range().start()) {
-                    tested_by!(call_info_bad_offset);
+                    mark::hit!(call_info_bad_offset);
                    return None;
                }
@@ -213,7 +213,7 @@ impl CallInfo {
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
    use crate::mock_analysis::single_file_with_position;
@@ -529,7 +529,7 @@ By default this method stops actor's `Context`."#
    #[test]
    fn call_info_bad_offset() {
-        covers!(call_info_bad_offset);
+        mark::check!(call_info_bad_offset);
        let (analysis, position) = single_file_with_position(
            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
               fn bar() { foo <|> (3, ); }"#,
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index 4ca0fdf4f..191300704 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -59,13 +59,13 @@ pub use crate::completion::{
 /// with ordering of completions (currently this is done by the client).
 pub(crate) fn completions(
    db: &RootDatabase,
-    position: FilePosition,
    config: &CompletionConfig,
+    position: FilePosition,
 ) -> Option<Completions> {
    let ctx = CompletionContext::new(db, position, config)?;
    let mut acc = Completions::default();
+    complete_attribute::complete_attribute(&mut acc, &ctx);
    complete_fn_param::complete_fn_param(&mut acc, &ctx);
    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
    complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
@@ -79,7 +79,6 @@ pub(crate) fn completions(
    complete_postfix::complete_postfix(&mut acc, &ctx);
    complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
-    complete_attribute::complete_attribute(&mut acc, &ctx);
    Some(acc)
 }
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index 8bf952798..f17266221 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -3,25 +3,29 @@
 //! This module uses a bit of static metadata to provide completions
 //! for built-in attributes.
-use super::completion_context::CompletionContext;
+use ra_syntax::{ast, AstNode, SyntaxKind};
-use super::completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions};
+use rustc_hash::FxHashSet;
-use ra_syntax::{
-    ast::{Attr, AttrKind},
+use crate::completion::{
-    AstNode,
+    completion_context::CompletionContext,
+    completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
 };
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) {
+pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    if !ctx.is_attribute {
+    let attribute = ctx.attribute_under_caret.as_ref()?;
-        return;
-    }
-    let is_inner = ctx
+    match (attribute.path(), attribute.input()) {
-        .original_token
+        (Some(path), Some(ast::AttrInput::TokenTree(token_tree)))
-        .ancestors()
+            if path.to_string() == "derive" =>
-        .find_map(Attr::cast)
+        {
-        .map(|attr| attr.kind() == AttrKind::Inner)
+            complete_derive(acc, ctx, token_tree)
-        .unwrap_or(false);
+        }
+        _ => complete_attribute_start(acc, ctx, attribute),
+    }
+    Some(())
+}
+fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
    for attr_completion in ATTRIBUTES {
        let mut item = CompletionItem::new(
            CompletionKind::Attribute,
@@ -37,7 +41,7 @@ pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
            _ => {}
        }
-        if is_inner || !attr_completion.should_be_inner {
+        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.should_be_inner {
            acc.add(item);
        }
    }
@@ -126,6 +130,106 @@ const ATTRIBUTES: &[AttrCompletion] = &[
    },
 ];
+fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
+    if let Ok(existing_derives) = parse_derive_input(derive_input) {
+        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+            .into_iter()
+            .filter(|completion| !existing_derives.contains(completion.label))
+        {
+            let mut label = derive_completion.label.to_owned();
+            for dependency in derive_completion
+                .dependencies
+                .into_iter()
+                .filter(|&&dependency| !existing_derives.contains(dependency))
+            {
+                label.push_str(", ");
+                label.push_str(dependency);
+            }
+            acc.add(
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
+                    .kind(CompletionItemKind::Attribute),
+            );
+        }
+        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
+            acc.add(
+                CompletionItem::new(
+                    CompletionKind::Attribute,
+                    ctx.source_range(),
+                    custom_derive_name,
+                )
+                .kind(CompletionItemKind::Attribute),
+            );
+        }
+    }
+}
+fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
+    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
+        (Some(left_paren), Some(right_paren))
+            if left_paren.kind() == SyntaxKind::L_PAREN
+                && right_paren.kind() == SyntaxKind::R_PAREN =>
+        {
+            let mut input_derives = FxHashSet::default();
+            let mut current_derive = String::new();
+            for token in derive_input
+                .syntax()
+                .children_with_tokens()
+                .filter_map(|token| token.into_token())
+                .skip_while(|token| token != &left_paren)
+                .skip(1)
+                .take_while(|token| token != &right_paren)
+            {
+                if SyntaxKind::COMMA == token.kind() {
+                    if !current_derive.is_empty() {
+                        input_derives.insert(current_derive);
+                        current_derive = String::new();
+                    }
+                } else {
+                    current_derive.push_str(token.to_string().trim());
+                }
+            }
+            if !current_derive.is_empty() {
+                input_derives.insert(current_derive);
+            }
+            Ok(input_derives)
+        }
+        _ => Err(()),
+    }
+}
+fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    let mut result = FxHashSet::default();
+    ctx.scope().process_all_names(&mut |name, scope_def| {
+        if let hir::ScopeDef::MacroDef(mac) = scope_def {
+            if mac.is_derive_macro() {
+                result.insert(name.to_string());
+            }
+        }
+    });
+    result
+}
+struct DeriveCompletion {
+    label: &'static str,
+    dependencies: &'static [&'static str],
+}
+/// Standard Rust derives and the information about their dependencies
+/// (the dependencies are needed so that the main derive don't break the compilation when added)
+const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
+    DeriveCompletion { label: "Clone", dependencies: &[] },
+    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
+    DeriveCompletion { label: "Debug", dependencies: &[] },
+    DeriveCompletion { label: "Default", dependencies: &[] },
+    DeriveCompletion { label: "Hash", dependencies: &[] },
+    DeriveCompletion { label: "PartialEq", dependencies: &[] },
+    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
+];
 #[cfg(test)]
 mod tests {
    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
@@ -136,6 +240,170 @@ mod tests {
    }
    #[test]
+    fn empty_derive_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "Ord, PartialOrd, Eq, PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialEq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd, PartialEq",
+                source_range: 30..30,
+                delete: 30..30,
+                insert: "PartialOrd, PartialEq",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+    #[test]
+    fn no_completion_for_incorrect_derive() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                r"
+                    #[derive{<|>)]
+                    struct Test {}
+                    ",
+            ),
+            @"[]"
+        );
+    }
+    #[test]
+    fn derive_with_input_completion() {
+        assert_debug_snapshot!(
+            do_attr_completion(
+                    r"
+                    #[derive(serde::Serialize, PartialEq, <|>)]
+                    struct Test {}
+                    ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Copy, Clone",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Copy, Clone",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Debug",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Debug",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Default",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Default",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Hash",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Hash",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "Ord, PartialOrd, Eq",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "Ord, PartialOrd, Eq",
+                kind: Attribute,
+            },
+            CompletionItem {
+                label: "PartialOrd",
+                source_range: 59..59,
+                delete: 59..59,
+                insert: "PartialOrd",
+                kind: Attribute,
+            },
+        ]
+            "###
+        );
+    }
+    #[test]
    fn test_attribute_completion() {
        assert_debug_snapshot!(
        do_attr_completion(
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 6a0f0c72e..f2a52a407 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -14,6 +14,7 @@ use crate::{
    },
    CompletionItem,
 };
+use ra_assists::utils::TryEnum;
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
    if !ctx.config.enable_postfix_completions {
@@ -37,8 +38,53 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
        Some(it) => it,
        None => return,
    };
+    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
+    if let Some(try_enum) = &try_enum {
+        match try_enum {
+            TryEnum::Result => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Ok {}",
+                    &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
-    if receiver_ty.is_bool() || receiver_ty.is_unknown() {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Ok {}",
+                    &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+            TryEnum::Option => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Some {}",
+                    &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Some {}",
+                    &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+        }
+    } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
        postfix_snippet(
            ctx,
            cap,
@@ -58,7 +104,6 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
        )
        .add_to(acc);
    }
    // !&&&42 is a compiler error, ergo process it before considering the references
    postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
        .add_to(acc);
@@ -80,16 +125,45 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
    let dot_receiver = include_references(dot_receiver);
    let receiver_text =
        get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
+    match try_enum {
-    postfix_snippet(
+        Some(try_enum) => {
-        ctx,
+            match try_enum {
-        cap,
+                TryEnum::Result => {
-        &dot_receiver,
+                    postfix_snippet(
-        "match",
+                    ctx,
-        "match expr {}",
+                    cap,
-        &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+                    &dot_receiver,
-    )
+                    "match",
-    .add_to(acc);
+                    "match expr {}",
+                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2\\}},\n    Err(${{3:_}}) => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+                TryEnum::Option => {
+                    postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "match",
+                    "match expr {}",
+                    &format!("match {} {{\n    Some(${{1:_}}) => {{$2\\}},\n    None => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+            }
+        }
+        None => {
+            postfix_snippet(
+                ctx,
+                cap,
+                &dot_receiver,
+                "match",
+                "match expr {}",
+                &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+            )
+            .add_to(acc);
+        }
+    }
    postfix_snippet(
        ctx,
@@ -236,6 +310,164 @@ mod tests {
    }
    #[test]
+    fn postfix_completion_works_for_option() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Option<T> {
+                    Some(T),
+                    None,
+                }
+                fn main() {
+                    let bar = Option::Some(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "if let Some($1) = bar {\n    $0\n}",
+                detail: "if let Some {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "match bar {\n    Some(${1:_}) => {$2\\},\n    None => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "while let Some($1) = bar {\n    $0\n}",
+                detail: "while let Some {}",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn postfix_completion_works_for_result() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Result<T, E> {
+                    Ok(T),
+                    Err(E),
+                }
+                fn main() {
+                    let bar = Result::Ok(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "if let Ok($1) = bar {\n    $0\n}",
+                detail: "if let Ok {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "match bar {\n    Ok(${1:_}) => {$2\\},\n    Err(${3:_}) => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "while let Ok($1) = bar {\n    $0\n}",
+                detail: "while let Ok {}",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn some_postfix_completions_ignored() {
        assert_debug_snapshot!(
            do_postfix_completion(
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index aa56a5cd8..02ac0166b 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -2,20 +2,25 @@
 use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use ra_syntax::AstNode;
-use test_utils::tested_by;
+use rustc_hash::FxHashSet;
+use test_utils::mark;
 use crate::completion::{CompletionContext, Completions};
-use rustc_hash::FxHashSet;
 pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
    let path = match &ctx.path_prefix {
        Some(path) => path.clone(),
-        _ => return,
+        None => return,
    };
+    if ctx.attribute_under_caret.is_some() {
+        return;
+    }
    let scope = ctx.scope();
    let context_module = scope.module();
-    let res = match scope.resolve_hir_path(&path) {
+    let res = match scope.resolve_hir_path_qualifier(&path) {
        Some(res) => res,
        None => return,
    };
@@ -35,7 +40,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                        if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
                            if name_ref.syntax().text() == name.to_string().as_str() {
                                // for `use self::foo<|>`, don't suggest `foo` as a completion
-                                tested_by!(dont_complete_current_use);
+                                mark::hit!(dont_complete_current_use);
                                continue;
                            }
                        }
@@ -79,7 +84,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                });
                // Iterate assoc types separately
-                ty.iterate_impl_items(ctx.db, krate, |item| {
+                ty.iterate_assoc_items(ctx.db, krate, |item| {
                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                        return None;
                    }
@@ -142,7 +147,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
@@ -153,7 +158,7 @@ mod tests {
    #[test]
    fn dont_complete_current_use() {
-        covers!(dont_complete_current_use);
+        mark::check!(dont_complete_current_use);
        let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference);
        assert!(completions.is_empty());
    }
@@ -221,6 +226,34 @@ mod tests {
    }
    #[test]
+    fn completes_mod_with_same_name_as_function() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::my::<|>;
+                mod my {
+                    pub struct Bar;
+                }
+                fn my() {}
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: 31..31,
+                delete: 31..31,
+                insert: "Bar",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn path_visibility() {
        assert_debug_snapshot!(
            do_reference_completion(
@@ -1325,4 +1358,18 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn dont_complete_attr() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                mod foo { pub struct Foo; }
+                #[foo::<|>]
+                fn f() {}
+                "
+            ),
+            @r###"[]"###
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index a3f5d1b6a..0568d9ccf 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -36,6 +36,24 @@ pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionConte
    snippet(
        ctx,
        cap,
+        "Test module",
+        "\
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn ${1:test_name}() {
+        $0
+    }
+}",
+    )
+    .lookup_by("tmod")
+    .add_to(acc);
+    snippet(
+        ctx,
+        cap,
        "Test function",
        "\
 #[test]
@@ -118,6 +136,14 @@ mod tests {
                lookup: "tfn",
            },
            CompletionItem {
+                label: "Test module",
+                source_range: 78..78,
+                delete: 78..78,
+                insert: "#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn ${1:test_name}() {\n        $0\n    }\n}",
+                kind: Snippet,
+                lookup: "tmod",
+            },
+            CompletionItem {
                label: "macro_rules",
                source_range: 78..78,
                delete: 78..78,
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index ee32d1ff6..039df03e0 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -32,7 +32,7 @@
 //! ```
 use hir::{self, Docs, HasSource};
-use ra_assists::utils::get_missing_impl_items;
+use ra_assists::utils::get_missing_assoc_items;
 use ra_syntax::{
    ast::{self, edit, ImplDef},
    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
@@ -50,7 +50,7 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
    if let Some((trigger, impl_def)) = completion_match(ctx) {
        match trigger.kind() {
            SyntaxKind::NAME_REF => {
-                get_missing_impl_items(&ctx.sema, &impl_def).iter().for_each(|item| match item {
+                get_missing_assoc_items(&ctx.sema, &impl_def).iter().for_each(|item| match item {
                    hir::AssocItem::Function(fn_item) => {
                        add_function_impl(&trigger, acc, ctx, &fn_item)
                    }
@@ -64,34 +64,40 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
            }
            SyntaxKind::FN_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
+                for missing_fn in
-                    |item| match item {
+                    get_missing_assoc_items(&ctx.sema, &impl_def).iter().filter_map(|item| {
-                        hir::AssocItem::Function(fn_item) => Some(fn_item),
+                        match item {
-                        _ => None,
+                            hir::AssocItem::Function(fn_item) => Some(fn_item),
-                    },
+                            _ => None,
-                ) {
+                        }
+                    })
+                {
                    add_function_impl(&trigger, acc, ctx, &missing_fn);
                }
            }
            SyntaxKind::TYPE_ALIAS_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
+                for missing_fn in
-                    |item| match item {
+                    get_missing_assoc_items(&ctx.sema, &impl_def).iter().filter_map(|item| {
-                        hir::AssocItem::TypeAlias(type_item) => Some(type_item),
+                        match item {
-                        _ => None,
+                            hir::AssocItem::TypeAlias(type_item) => Some(type_item),
-                    },
+                            _ => None,
-                ) {
+                        }
+                    })
+                {
                    add_type_alias_impl(&trigger, acc, ctx, &missing_fn);
                }
            }
            SyntaxKind::CONST_DEF => {
-                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
+                for missing_fn in
-                    |item| match item {
+                    get_missing_assoc_items(&ctx.sema, &impl_def).iter().filter_map(|item| {
-                        hir::AssocItem::Const(const_item) => Some(const_item),
+                        match item {
-                        _ => None,
+                            hir::AssocItem::Const(const_item) => Some(const_item),
-                    },
+                            _ => None,
-                ) {
+                        }
+                    })
+                {
                    add_const_impl(&trigger, acc, ctx, &missing_fn);
                }
            }
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index a6a5568de..db791660a 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,16 +1,19 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 use hir::ScopeDef;
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::completion::{CompletionContext, Completions};
 use hir::{Adt, ModuleDef, Type};
 use ra_syntax::AstNode;
 pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if (!ctx.is_trivial_path && !ctx.is_pat_binding_or_const)
+    if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
-        || ctx.record_lit_syntax.is_some()
+        return;
+    }
+    if ctx.record_lit_syntax.is_some()
        || ctx.record_pat_syntax.is_some()
+        || ctx.attribute_under_caret.is_some()
    {
        return;
    }
@@ -27,7 +30,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
        if ctx.use_item_syntax.is_some() {
            if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                if name_ref.syntax().text() == name.to_string().as_str() {
-                    tested_by!(self_fulfilling_completion);
+                    mark::hit!(self_fulfilling_completion);
                    return;
                }
            }
@@ -63,7 +66,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 #[cfg(test)]
 mod tests {
    use insta::assert_debug_snapshot;
-    use test_utils::covers;
+    use test_utils::mark;
    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
@@ -73,7 +76,7 @@ mod tests {
    #[test]
    fn self_fulfilling_completion() {
-        covers!(self_fulfilling_completion);
+        mark::check!(self_fulfilling_completion);
        assert_debug_snapshot!(
            do_reference_completion(
                r#"
@@ -1369,4 +1372,18 @@ mod tests {
        "###
        )
    }
+    #[test]
+    fn dont_complete_attr() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                #[<|>]
+                fn f() {}
+                "
+            ),
+            @r###"[]"###
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 118fceb2e..da336973c 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
-use ra_text_edit::AtomTextEdit;
+use ra_text_edit::Indel;
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
@@ -34,7 +34,7 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) record_pat_syntax: Option<ast::RecordPat>,
    pub(super) record_field_syntax: Option<ast::RecordField>,
    pub(super) impl_def: Option<ast::ImplDef>,
-    /// FIXME: `ActiveParameter` is string-based, which is very wrong
+    /// FIXME: `ActiveParameter` is string-based, which is very very wrong
    pub(super) active_parameter: Option<ActiveParameter>,
    pub(super) is_param: bool,
    /// If a name-binding or reference to a const in a pattern.
@@ -58,7 +58,7 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) is_macro_call: bool,
    pub(super) is_path_type: bool,
    pub(super) has_type_args: bool,
-    pub(super) is_attribute: bool,
+    pub(super) attribute_under_caret: Option<ast::Attr>,
 }
 impl<'a> CompletionContext<'a> {
@@ -76,7 +76,7 @@ impl<'a> CompletionContext<'a> {
        // actual completion.
        let file_with_fake_ident = {
            let parse = db.parse(position.file_id);
-            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
+            let edit = Indel::insert(position.offset, "intellijRulezz".to_string());
            parse.reparse(&edit).tree()
        };
        let fake_ident_token =
@@ -116,7 +116,7 @@ impl<'a> CompletionContext<'a> {
            is_path_type: false,
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
-            is_attribute: false,
+            attribute_under_caret: None,
        };
        let mut original_file = original_file.syntax().clone();
@@ -200,6 +200,7 @@ impl<'a> CompletionContext<'a> {
                Some(ty)
            })
            .flatten();
+        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
        // First, let's try to complete a reference to some declaration.
        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
@@ -318,7 +319,6 @@ impl<'a> CompletionContext<'a> {
                .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                .is_some();
            self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some();
-            self.is_attribute = path.syntax().parent().and_then(ast::Attr::cast).is_some();
            self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
            self.has_type_args = segment.type_arg_list().is_some();
@@ -344,7 +344,7 @@ impl<'a> CompletionContext<'a> {
                                stmt.syntax().text_range() == name_ref.syntax().text_range(),
                            );
                        }
-                        if let Some(block) = ast::Block::cast(node) {
+                        if let Some(block) = ast::BlockExpr::cast(node) {
                            return Some(
                                block.expr().map(|e| e.syntax().text_range())
                                    == Some(name_ref.syntax().text_range()),
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 5936fb8f7..cfb7c1e38 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -2,11 +2,12 @@
 use std::fmt;
-use super::completion_config::SnippetCap;
 use hir::Documentation;
 use ra_syntax::TextRange;
 use ra_text_edit::TextEdit;
+use crate::completion::completion_config::SnippetCap;
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
 /// It is basically a POD with various properties. To construct a
 /// `CompletionItem`, use `new` method and the `Builder` struct.
@@ -62,8 +63,8 @@ impl fmt::Debug for CompletionItem {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut s = f.debug_struct("CompletionItem");
        s.field("label", &self.label()).field("source_range", &self.source_range());
-        if self.text_edit().as_atoms().len() == 1 {
+        if self.text_edit().len() == 1 {
-            let atom = &self.text_edit().as_atoms()[0];
+            let atom = &self.text_edit().iter().next().unwrap();
            s.field("delete", &atom.delete);
            s.field("insert", &atom.insert);
        } else {
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 2edb130cf..440ffa31d 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -3,7 +3,7 @@
 use hir::{Docs, HasAttrs, HasSource, HirDisplay, ModPath, ScopeDef, StructKind, Type};
 use ra_syntax::ast::NameOwner;
 use stdx::SepBy;
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::{
    completion::{
@@ -17,12 +17,11 @@ use crate::{
 impl Completions {
    pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
        let is_deprecated = is_deprecated(field, ctx.db);
-        let ty = ty.display(ctx.db).to_string();
        let name = field.name(ctx.db);
        let mut completion_item =
            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
                .kind(CompletionItemKind::Field)
-                .detail(ty.clone())
+                .detail(ty.display(ctx.db).to_string())
                .set_documentation(field.docs(ctx.db))
                .set_deprecated(is_deprecated);
@@ -107,6 +106,12 @@ impl Completions {
            }
        };
+        if let ScopeDef::Local(local) = resolution {
+            if let Some(score) = compute_score(ctx, &local.ty(ctx.db), &local_name) {
+                completion_item = completion_item.set_score(score);
+            }
+        }
        // Add `<>` for generic types
        if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
            if let Some(cap) = ctx.config.snippet_cap {
@@ -116,7 +121,7 @@ impl Completions {
                    _ => false,
                };
                if has_non_default_type_params {
-                    tested_by!(inserts_angle_brackets_for_generics);
+                    mark::hit!(inserts_angle_brackets_for_generics);
                    completion_item = completion_item
                        .lookup_by(local_name.clone())
                        .label(format!("{}<…>", local_name))
@@ -171,7 +176,7 @@ impl Completions {
            }
            None if needs_bang => builder.insert_text(format!("{}!", name)),
            _ => {
-                tested_by!(dont_insert_macro_call_parens_unncessary);
+                mark::hit!(dont_insert_macro_call_parens_unncessary);
                builder.insert_text(name)
            }
        };
@@ -319,19 +324,20 @@ impl Completions {
 pub(crate) fn compute_score(
    ctx: &CompletionContext,
-    // FIXME: this definitely should be a `Type`
+    ty: &Type,
-    ty: &str,
    name: &str,
 ) -> Option<CompletionScore> {
+    // FIXME: this should not fall back to string equality.
+    let ty = &ty.display(ctx.db).to_string();
    let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
-        tested_by!(test_struct_field_completion_in_record_lit);
+        mark::hit!(test_struct_field_completion_in_record_lit);
        let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?;
        (
            struct_field.name(ctx.db).to_string(),
            struct_field.signature_ty(ctx.db).display(ctx.db).to_string(),
        )
    } else if let Some(active_parameter) = &ctx.active_parameter {
-        tested_by!(test_struct_field_completion_in_func_call);
+        mark::hit!(test_struct_field_completion_in_func_call);
        (active_parameter.name.clone(), active_parameter.ty.clone())
    } else {
        return None;
@@ -392,7 +398,7 @@ impl Builder {
            None => return self,
        };
        // If not an import, add parenthesis automatically.
-        tested_by!(inserts_parens_for_function_calls);
+        mark::hit!(inserts_parens_for_function_calls);
        let (snippet, label) = if params.is_empty() {
            (format!("{}()$0", name), format!("{}()", name))
@@ -451,7 +457,7 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s
 #[cfg(test)]
 mod tests {
    use insta::assert_debug_snapshot;
-    use test_utils::covers;
+    use test_utils::mark;
    use crate::completion::{
        test_utils::{do_completion, do_completion_with_options},
@@ -601,7 +607,7 @@ mod tests {
    #[test]
    fn inserts_parens_for_function_calls() {
-        covers!(inserts_parens_for_function_calls);
+        mark::check!(inserts_parens_for_function_calls);
        assert_debug_snapshot!(
            do_reference_completion(
                r"
@@ -986,7 +992,7 @@ mod tests {
    #[test]
    fn inserts_angle_brackets_for_generics() {
-        covers!(inserts_angle_brackets_for_generics);
+        mark::check!(inserts_angle_brackets_for_generics);
        assert_debug_snapshot!(
            do_reference_completion(
                r"
@@ -1109,7 +1115,7 @@ mod tests {
    #[test]
    fn dont_insert_macro_call_parens_unncessary() {
-        covers!(dont_insert_macro_call_parens_unncessary);
+        mark::check!(dont_insert_macro_call_parens_unncessary);
        assert_debug_snapshot!(
            do_reference_completion(
                r"
@@ -1175,7 +1181,7 @@ mod tests {
    #[test]
    fn test_struct_field_completion_in_func_call() {
-        covers!(test_struct_field_completion_in_func_call);
+        mark::check!(test_struct_field_completion_in_func_call);
        assert_debug_snapshot!(
        do_reference_completion(
                r"
@@ -1265,7 +1271,7 @@ mod tests {
    #[test]
    fn test_struct_field_completion_in_record_lit() {
-        covers!(test_struct_field_completion_in_record_lit);
+        mark::check!(test_struct_field_completion_in_record_lit);
        assert_debug_snapshot!(
        do_reference_completion(
                r"
@@ -1405,4 +1411,48 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn prioritize_exact_ref_match() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                    struct WorldSnapshot { _f: () };
+                    fn go(world: &WorldSnapshot) {
+                        go(w<|>)
+                    }
+                    ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "WorldSnapshot",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "WorldSnapshot",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "go(…)",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "go(${1:world})$0",
+                kind: Function,
+                lookup: "go",
+                detail: "fn go(world: &WorldSnapshot)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "world",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "world",
+                kind: Binding,
+                detail: "&WorldSnapshot",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index eb90b5279..bf22452a2 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -20,7 +20,7 @@ pub(crate) fn do_completion_with_options(
    } else {
        single_file_with_position(code)
    };
-    let completions = analysis.completions(position, options).unwrap().unwrap();
+    let completions = analysis.completions(options, position).unwrap().unwrap();
    let completion_items: Vec<CompletionItem> = completions.into();
    let mut kind_completions: Vec<CompletionItem> =
        completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index a6b4c2c28..c2819bbf7 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -64,7 +64,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            .unwrap_or_else(|| RelativePath::new(""))
            .join(&d.candidate);
        let create_file = FileSystemEdit::CreateFile { source_root, path };
-        let fix = SourceChange::file_system_edit("create module", create_file);
+        let fix = SourceChange::file_system_edit("Create module", create_file);
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -92,7 +92,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            algo::diff(&d.ast(db).syntax(), &field_list.syntax()).into_text_edit(&mut builder);
            Some(SourceChange::source_file_edit_from(
-                "fill struct fields",
+                "Fill struct fields",
                file_id,
                builder.finish(),
            ))
@@ -117,7 +117,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
        let node = d.ast(db);
        let replacement = format!("Ok({})", node.syntax());
        let edit = TextEdit::replace(node.syntax().text_range(), replacement);
-        let fix = SourceChange::source_file_edit_from("wrap with ok", file_id, edit);
+        let fix = SourceChange::source_file_edit_from("Wrap with ok", file_id, edit);
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -199,7 +199,7 @@ fn check_struct_shorthand_initialization(
                    message: "Shorthand struct initialization".to_string(),
                    severity: Severity::WeakWarning,
                    fix: Some(SourceChange::source_file_edit(
-                        "use struct shorthand initialization",
+                        "Use struct shorthand initialization",
                        SourceFileEdit { file_id, edit },
                    )),
                });
@@ -241,7 +241,11 @@ mod tests {
            diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
        let mut fix = diagnostic.fix.unwrap();
        let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
        assert_eq_text!(after, &actual);
    }
@@ -256,7 +260,11 @@ mod tests {
        let mut fix = diagnostic.fix.unwrap();
        let edit = fix.source_file_edits.pop().unwrap().edit;
        let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
-        let actual = edit.apply(&target_file_contents);
+        let actual = {
+            let mut actual = target_file_contents.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
        // Strip indent and empty lines from `after`, to match the behaviour of
        // `parse_fixture` called from `analysis_and_position`.
@@ -288,7 +296,11 @@ mod tests {
        let diagnostic = analysis.diagnostics(file_id).unwrap().pop().unwrap();
        let mut fix = diagnostic.fix.unwrap();
        let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
        assert_eq_text!(after, &actual);
    }
@@ -606,7 +618,7 @@ mod tests {
                range: 0..8,
                fix: Some(
                    SourceChange {
-                        label: "create module",
+                        label: "Create module",
                        source_file_edits: [],
                        file_system_edits: [
                            CreateFile {
@@ -616,7 +628,7 @@ mod tests {
                                path: "foo.rs",
                            },
                        ],
-                        cursor_position: None,
+                        is_snippet: false,
                    },
                ),
                severity: Error,
@@ -655,24 +667,24 @@ mod tests {
                range: 224..233,
                fix: Some(
                    SourceChange {
-                        label: "fill struct fields",
+                        label: "Fill struct fields",
                        source_file_edits: [
                            SourceFileEdit {
                                file_id: FileId(
                                    1,
                                ),
                                edit: TextEdit {
-                                    atoms: [
+                                    indels: [
-                                        AtomTextEdit {
+                                        Indel {
-                                            delete: 3..9,
                                            insert: "{a:42, b: ()}",
+                                            delete: 3..9,
                                        },
                                    ],
                                },
                            },
                        ],
                        file_system_edits: [],
-                        cursor_position: None,
+                        is_snippet: false,
                    },
                ),
                severity: Error,
diff --git a/crates/ra_ide/src/display/function_signature.rs b/crates/ra_ide/src/display/function_signature.rs
index db3907fe6..9572debd8 100644
--- a/crates/ra_ide/src/display/function_signature.rs
+++ b/crates/ra_ide/src/display/function_signature.rs
@@ -1,5 +1,7 @@
 //! FIXME: write short doc here
+// FIXME: this modules relies on strings and AST way too much, and it should be
+// rewritten (matklad 2020-05-07)
 use std::{
    convert::From,
    fmt::{self, Display},
@@ -82,8 +84,8 @@ impl FunctionSignature {
            let ty = field.signature_ty(db);
            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1) {
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type[1..].to_string());
+                parameter_types.push(param_type.to_string());
            } else {
                // useful when you have tuple struct
                parameter_types.push(raw_param.clone());
@@ -127,8 +129,8 @@ impl FunctionSignature {
        for field in variant.fields(db).into_iter() {
            let ty = field.signature_ty(db);
            let raw_param = format!("{}", ty.display(db));
-            if let Some(param_type) = raw_param.split(':').nth(1) {
+            if let Some(param_type) = raw_param.split(':').nth(1).and_then(|it| it.get(1..)) {
-                parameter_types.push(param_type[1..].to_string());
+                parameter_types.push(param_type.to_string());
            } else {
                // The unwrap_or_else is useful when you have tuple
                parameter_types.push(raw_param);
@@ -195,14 +197,23 @@ impl From<&'_ ast::FnDef> for FunctionSignature {
                    let raw_param = self_param.syntax().text().to_string();
                    res_types.push(
-                        raw_param.split(':').nth(1).unwrap_or_else(|| " Self")[1..].to_string(),
+                        raw_param
+                            .split(':')
+                            .nth(1)
+                            .and_then(|it| it.get(1..))
+                            .unwrap_or_else(|| "Self")
+                            .to_string(),
                    );
                    res.push(raw_param);
                }
                res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
                res_types.extend(param_list.params().map(|param| {
-                    param.syntax().text().to_string().split(':').nth(1).unwrap()[1..].to_string()
+                    let param_text = param.syntax().text().to_string();
+                    match param_text.split(':').nth(1).and_then(|it| it.get(1..)) {
+                        Some(it) => it.to_string(),
+                        None => param_text,
+                    }
                }));
            }
            (has_self_param, res, res_types)
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 914a8b471..5da28edd2 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::FileSymbol;
+use crate::{FileRange, FileSymbol};
 use super::short_label::ShortLabel;
@@ -22,10 +22,11 @@ use super::short_label::ShortLabel;
 /// code, like a function or a struct, but this is not strictly required.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
+    // FIXME: use FileRange?
    file_id: FileId,
+    full_range: TextRange,
    name: SmolStr,
    kind: SyntaxKind,
-    full_range: TextRange,
    focus_range: Option<TextRange>,
    container_name: Option<SmolStr>,
    description: Option<String>,
@@ -63,6 +64,10 @@ impl NavigationTarget {
        self.file_id
    }
+    pub fn file_range(&self) -> FileRange {
+        FileRange { file_id: self.file_id, range: self.full_range }
+    }
    pub fn full_range(&self) -> TextRange {
        self.full_range
    }
@@ -376,16 +381,20 @@ impl ToNav for hir::Local {
 impl ToNav for hir::TypeParam {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
-        let range = match src.value {
+        let full_range = match &src.value {
            Either::Left(it) => it.syntax().text_range(),
            Either::Right(it) => it.syntax().text_range(),
        };
+        let focus_range = match &src.value {
+            Either::Left(_) => None,
+            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
+        };
        NavigationTarget {
            file_id: src.file_id.original_file(db),
            name: self.name(db).to_string().into(),
            kind: TYPE_PARAM,
-            full_range: range,
+            full_range,
-            focus_range: None,
+            focus_range,
            container_name: None,
            description: None,
            docs: None,
diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs
index 4379005aa..8657377de 100644
--- a/crates/ra_ide/src/folding_ranges.rs
+++ b/crates/ra_ide/src/folding_ranges.rs
@@ -88,7 +88,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
        | ITEM_LIST
        | EXTERN_ITEM_LIST
        | USE_TREE_LIST
-        | BLOCK
+        | BLOCK_EXPR
        | MATCH_ARM_LIST
        | ENUM_VARIANT_LIST
        | TOKEN_TREE => Some(FoldKind::Block),
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 1dfca819d..90e85d419 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -93,7 +93,7 @@ pub(crate) fn reference_definition(
 #[cfg(test)]
 mod tests {
-    use test_utils::{assert_eq_text, covers};
+    use test_utils::assert_eq_text;
    use crate::mock_analysis::analysis_and_position;
@@ -208,7 +208,6 @@ mod tests {
    #[test]
    fn goto_def_for_macros() {
-        covers!(ra_ide_db::goto_def_for_macros);
        check_goto(
            "
            //- /lib.rs
@@ -225,7 +224,6 @@ mod tests {
    #[test]
    fn goto_def_for_macros_from_other_crates() {
-        covers!(ra_ide_db::goto_def_for_macros);
        check_goto(
            "
            //- /lib.rs
@@ -244,6 +242,38 @@ mod tests {
    }
    #[test]
+    fn goto_def_for_use_alias() {
+        check_goto(
+            "
+            //- /lib.rs
+            use foo as bar<|>;
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }",
+            "SOURCE_FILE FileId(2) 0..50",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
+        );
+    }
+    #[test]
+    fn goto_def_for_use_alias_foo_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            use foo::foo as bar<|>;
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }
+            ",
+            "foo MACRO_CALL FileId(2) 0..49 29..32",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+        );
+    }
+    #[test]
    fn goto_def_for_macros_in_use_tree() {
        check_goto(
            "
@@ -337,7 +367,6 @@ mod tests {
    #[test]
    fn goto_def_for_methods() {
-        covers!(ra_ide_db::goto_def_for_methods);
        check_goto(
            "
            //- /lib.rs
@@ -357,7 +386,6 @@ mod tests {
    #[test]
    fn goto_def_for_fields() {
-        covers!(ra_ide_db::goto_def_for_fields);
        check_goto(
            r"
            //- /lib.rs
@@ -376,7 +404,6 @@ mod tests {
    #[test]
    fn goto_def_for_record_fields() {
-        covers!(ra_ide_db::goto_def_for_record_fields);
        check_goto(
            r"
            //- /lib.rs
@@ -397,7 +424,6 @@ mod tests {
    #[test]
    fn goto_def_for_record_pat_fields() {
-        covers!(ra_ide_db::goto_def_for_record_field_pats);
        check_goto(
            r"
            //- /lib.rs
@@ -754,14 +780,14 @@ mod tests {
    #[test]
    fn goto_for_type_param() {
        check_goto(
-            "
+            r#"
            //- /lib.rs
-            struct Foo<T> {
+            struct Foo<T: Clone> {
                t: <|>T,
            }
-            ",
+            "#,
-            "T TYPE_PARAM FileId(1) 11..12",
+            "T TYPE_PARAM FileId(1) 11..19 11..12",
-            "T",
+            "T: Clone|T",
        );
    }
@@ -840,7 +866,6 @@ mod tests {
    #[test]
    fn goto_def_for_field_init_shorthand() {
-        covers!(ra_ide_db::goto_def_for_field_init_shorthand);
        check_goto(
            "
            //- /lib.rs
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 54d318858..befa977c7 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -143,7 +143,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
            ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
            ModuleDef::BuiltinType(it) => Some(it.to_string()),
        },
-        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display_truncated(db, None))),
+        Definition::Local(it) => Some(rust_code_markup(&it.ty(db).display(db))),
        Definition::TypeParam(_) | Definition::SelfType(_) => {
            // FIXME: Hover for generic param
            None
@@ -208,7 +208,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
        }
    }?;
-    res.extend(Some(rust_code_markup(&ty.display_truncated(db, None))));
+    res.extend(Some(rust_code_markup(&ty.display(db))));
    let range = sema.original_range(&node).range;
    Some(RangeInfo::new(range, res))
 }
@@ -280,6 +280,47 @@ mod tests {
    }
    #[test]
+    fn hover_shows_long_type_of_an_expression() {
+        check_hover_result(
+            r#"
+            //- /main.rs
+            struct Scan<A, B, C> {
+                a: A,
+                b: B,
+                c: C,
+            }
+            struct FakeIter<I> {
+                inner: I,
+            }
+            struct OtherStruct<T> {
+                i: T,
+            }
+            enum FakeOption<T> {
+                Some(T),
+                None,
+            }
+            fn scan<A, B, C>(a: A, b: B, c: C) -> FakeIter<Scan<OtherStruct<A>, B, C>> {
+                FakeIter { inner: Scan { a, b, c } }
+            }
+            fn main() {
+                let num: i32 = 55;
+                let closure = |memo: &mut u32, value: &u32, _another: &mut u32| -> FakeOption<u32> {
+                    FakeOption::Some(*memo + value)
+                };
+                let number = 5u32;
+                let mut iter<|> = scan(OtherStruct { i: num }, closure, number);
+            }
+            "#,
+            &["FakeIter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> FakeOption<u32>, u32>>"],
+        );
+    }
+    #[test]
    fn hover_shows_fn_signature() {
        // Single file with result
        check_hover_result(
@@ -405,7 +446,7 @@ mod tests {
    }
    #[test]
-    fn hover_omits_default_generic_types() {
+    fn hover_default_generic_types() {
        check_hover_result(
            r#"
 //- /main.rs
@@ -417,7 +458,7 @@ struct Test<K, T = u8> {
 fn main() {
    let zz<|> = Test { t: 23, k: 33 };
 }"#,
-            &["Test<i32>"],
+            &["Test<i32, u8>"],
        );
    }
@@ -880,4 +921,21 @@ fn func(foo: i32) { if true { <|>foo; }; }
            &["unsafe trait foo"],
        );
    }
+    #[test]
+    fn test_hover_mod_with_same_name_as_function() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            use self::m<|>y::Bar;
+            mod my {
+                pub struct Bar;
+            }
+            fn my() {}
+            ",
+            &["mod my"],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 98483df32..b391f903a 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -9,6 +9,7 @@ use ra_syntax::{
 };
 use crate::{FileId, FunctionSignature};
+use stdx::to_lower_snake_case;
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
@@ -144,7 +145,7 @@ fn get_param_name_hints(
        .iter()
        .skip(n_params_to_skip)
        .zip(args)
-        .filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg))
+        .filter(|(param, arg)| should_show_param_name_hint(sema, &fn_signature, param, &arg))
        .map(|(param_name, arg)| InlayHint {
            range: arg.syntax().text_range(),
            kind: InlayKind::ParameterHint,
@@ -181,7 +182,7 @@ fn get_bind_pat_hints(
 fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
    if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
-        let pat_text = bind_pat.syntax().to_string();
+        let pat_text = bind_pat.to_string();
        enum_data
            .variants(db)
            .into_iter()
@@ -198,7 +199,7 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
    }
    if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
-        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.to_string() {
            return true;
        }
    }
@@ -230,15 +231,16 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
    false
 }
-fn should_show_param_hint(
+fn should_show_param_name_hint(
+    sema: &Semantics<RootDatabase>,
    fn_signature: &FunctionSignature,
    param_name: &str,
    argument: &ast::Expr,
 ) -> bool {
+    let param_name = param_name.trim_start_matches('_');
    if param_name.is_empty()
-        || is_argument_similar_to_param(argument, param_name)
+        || Some(param_name) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
-        || Some(param_name.trim_start_matches('_'))
+        || is_argument_similar_to_param_name(sema, argument, param_name)
-            == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
    {
        return false;
    }
@@ -254,20 +256,42 @@ fn should_show_param_hint(
    parameters_len != 1 || !is_obvious_param(param_name)
 }
-fn is_argument_similar_to_param(argument: &ast::Expr, param_name: &str) -> bool {
+fn is_argument_similar_to_param_name(
-    let argument_string = remove_ref(argument.clone()).syntax().to_string();
+    sema: &Semantics<RootDatabase>,
-    let param_name = param_name.trim_start_matches('_');
+    argument: &ast::Expr,
-    let argument_string = argument_string.trim_start_matches('_');
+    param_name: &str,
-    argument_string.starts_with(&param_name) || argument_string.ends_with(&param_name)
+) -> bool {
+    if is_enum_name_similar_to_param_name(sema, argument, param_name) {
+        return true;
+    }
+    match get_string_representation(argument) {
+        None => false,
+        Some(repr) => {
+            let argument_string = repr.trim_start_matches('_');
+            argument_string.starts_with(param_name) || argument_string.ends_with(param_name)
+        }
+    }
+}
+fn is_enum_name_similar_to_param_name(
+    sema: &Semantics<RootDatabase>,
+    argument: &ast::Expr,
+    param_name: &str,
+) -> bool {
+    match sema.type_of_expr(argument).and_then(|t| t.as_adt()) {
+        Some(Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name,
+        _ => false,
+    }
 }
-fn remove_ref(expr: ast::Expr) -> ast::Expr {
+fn get_string_representation(expr: &ast::Expr) -> Option<String> {
-    if let ast::Expr::RefExpr(ref_expr) = &expr {
+    match expr {
-        if let Some(inner) = ref_expr.expr() {
+        ast::Expr::MethodCallExpr(method_call_expr) => {
-            return inner;
+            Some(method_call_expr.name_ref()?.to_string())
        }
+        ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
+        _ => Some(expr.to_string()),
    }
-    expr
 }
 fn is_obvious_param(param_name: &str) -> bool {
@@ -1073,6 +1097,12 @@ struct TestVarContainer {
    test_var: i32,
 }
+impl TestVarContainer {
+    fn test_var(&self) -> i32 {
+        self.test_var
+    }
+}
 struct Test {}
 impl Test {
@@ -1098,10 +1128,15 @@ struct Param {}
 fn different_order(param: &Param) {}
 fn different_order_mut(param: &mut Param) {}
 fn has_underscore(_param: bool) {}
+fn enum_matches_param_name(completion_kind: CompletionKind) {}
 fn twiddle(twiddle: bool) {}
 fn doo(_doo: bool) {}
+enum CompletionKind {
+    Keyword,
+}
 fn main() {
    let container: TestVarContainer = TestVarContainer { test_var: 42 };
    let test: Test = Test {};
@@ -1114,18 +1149,21 @@ fn main() {
    let test_var: i32 = 55;
    test_processed.no_hints_expected(22, test_var);
    test_processed.no_hints_expected(33, container.test_var);
+    test_processed.no_hints_expected(44, container.test_var());
    test_processed.frob(false);
    twiddle(true);
    doo(true);
-    let param_begin: Param = Param {};
+    let mut param_begin: Param = Param {};
    different_order(&param_begin);
    different_order(&mut param_begin);
    let param: bool = true;
    has_underscore(param);
+    enum_matches_param_name(CompletionKind::Keyword);
    let a: f64 = 7.0;
    let b: f64 = 4.0;
    let _: f64 = a.div_euclid(b);
diff --git a/crates/ra_ide/src/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index d0def7eaa..af1ade8a1 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -129,8 +129,7 @@ fn has_comma_after(node: &SyntaxNode) -> bool {
 }
 fn join_single_expr_block(edit: &mut TextEditBuilder, token: &SyntaxToken) -> Option<()> {
-    let block = ast::Block::cast(token.parent())?;
+    let block_expr = ast::BlockExpr::cast(token.parent())?;
-    let block_expr = ast::BlockExpr::cast(block.syntax().parent()?)?;
    if !block_expr.is_standalone() {
        return None;
    }
@@ -167,16 +166,28 @@ fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
 #[cfg(test)]
 mod tests {
-    use crate::test_utils::{assert_eq_text, check_action, extract_range};
+    use ra_syntax::SourceFile;
+    use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
    use super::*;
    fn check_join_lines(before: &str, after: &str) {
-        check_action(before, after, |file, offset| {
+        let (before_cursor_pos, before) = extract_offset(before);
-            let range = TextRange::empty(offset);
+        let file = SourceFile::parse(&before).ok().unwrap();
-            let res = join_lines(file, range);
-            Some(res)
+        let range = TextRange::empty(before_cursor_pos);
-        })
+        let result = join_lines(&file, range);
+        let actual = {
+            let mut actual = before.to_string();
+            result.apply(&mut actual);
+            actual
+        };
+        let actual_cursor_pos = result
+            .apply_to_offset(before_cursor_pos)
+            .expect("cursor position is affected by the edit");
+        let actual = add_cursor(&actual, actual_cursor_pos);
+        assert_eq_text!(after, &actual);
    }
    #[test]
@@ -570,7 +581,11 @@ fn foo() {
        let (sel, before) = extract_range(before);
        let parse = SourceFile::parse(&before);
        let result = join_lines(&parse.tree(), sel);
-        let actual = result.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            result.apply(&mut actual);
+            actual
+        };
        assert_eq_text!(after, &actual);
    }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 09f602fe1..97ff67ee8 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -16,7 +16,6 @@ macro_rules! eprintln {
 }
 pub mod mock_analysis;
-mod source_change;
 mod prime_caches;
 mod status;
@@ -32,7 +31,6 @@ mod syntax_highlighting;
 mod parent_module;
 mod references;
 mod impls;
-mod assists;
 mod diagnostics;
 mod syntax_tree;
 mod folding_ranges;
@@ -44,11 +42,6 @@ mod inlay_hints;
 mod expand_macro;
 mod ssr;
-#[cfg(test)]
-mod marks;
-#[cfg(test)]
-mod test_utils;
 use std::sync::Arc;
 use ra_cfg::CfgOptions;
@@ -65,7 +58,6 @@ use ra_syntax::{SourceFile, TextRange, TextSize};
 use crate::display::ToNav;
 pub use crate::{
-    assists::{Assist, AssistId},
    call_hierarchy::CallItem,
    completion::{
        CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat,
@@ -78,7 +70,6 @@ pub use crate::{
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
-    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    ssr::SsrError,
    syntax_highlighting::{
        Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
@@ -86,17 +77,19 @@ pub use crate::{
 };
 pub use hir::Documentation;
+pub use ra_assists::{AssistConfig, AssistId};
 pub use ra_db::{
    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
 pub use ra_ide_db::{
    change::{AnalysisChange, LibraryData},
    line_index::{LineCol, LineIndex},
-    line_index_utils::translate_offset_with_edit,
    search::SearchScope,
+    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    symbol_index::Query,
    RootDatabase,
 };
+pub use ra_text_edit::{Indel, TextEdit};
 pub type Cancelable<T> = Result<T, Canceled>;
@@ -135,10 +128,12 @@ pub struct AnalysisHost {
    db: RootDatabase,
 }
-impl Default for AnalysisHost {
+#[derive(Debug)]
-    fn default() -> AnalysisHost {
+pub struct Assist {
-        AnalysisHost::new(None)
+    pub id: AssistId,
-    }
+    pub label: String,
+    pub group_label: Option<String>,
+    pub source_change: SourceChange,
 }
 impl AnalysisHost {
@@ -176,18 +171,20 @@ impl AnalysisHost {
    pub fn request_cancellation(&mut self) {
        self.db.request_cancellation();
    }
-    pub fn raw_database(
+    pub fn raw_database(&self) -> &RootDatabase {
-        &self,
-    ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
        &self.db
    }
-    pub fn raw_database_mut(
+    pub fn raw_database_mut(&mut self) -> &mut RootDatabase {
-        &mut self,
-    ) -> &mut (impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
        &mut self.db
    }
 }
+impl Default for AnalysisHost {
+    fn default() -> AnalysisHost {
+        AnalysisHost::new(None)
+    }
+}
 /// Analysis is a snapshot of a world state at a moment in time. It is the main
 /// entry point for asking semantic information about the world. When the world
 /// state is advanced using `AnalysisHost::apply_change` method, all existing
@@ -289,14 +286,10 @@ impl Analysis {
    /// Returns an edit to remove all newlines in the range, cleaning up minor
    /// stuff like trailing commas.
-    pub fn join_lines(&self, frange: FileRange) -> Cancelable<SourceChange> {
+    pub fn join_lines(&self, frange: FileRange) -> Cancelable<TextEdit> {
        self.with_db(|db| {
            let parse = db.parse(frange.file_id);
-            let file_edit = SourceFileEdit {
+            join_lines::join_lines(&parse.tree(), frange.range)
-                file_id: frange.file_id,
-                edit: join_lines::join_lines(&parse.tree(), frange.range),
-            };
-            SourceChange::source_file_edit("join lines", file_edit)
        })
    }
@@ -456,16 +449,26 @@ impl Analysis {
    /// Computes completions at the given position.
    pub fn completions(
        &self,
-        position: FilePosition,
        config: &CompletionConfig,
+        position: FilePosition,
    ) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.with_db(|db| completion::completions(db, position, config).map(Into::into))
+        self.with_db(|db| completion::completions(db, config, position).map(Into::into))
    }
    /// Computes assists (aka code actions aka intentions) for the given
    /// position.
-    pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<Assist>> {
+    pub fn assists(&self, config: &AssistConfig, frange: FileRange) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| assists::assists(db, frange))
+        self.with_db(|db| {
+            ra_assists::Assist::resolved(db, config, frange)
+                .into_iter()
+                .map(|assist| Assist {
+                    id: assist.assist.id,
+                    label: assist.assist.label,
+                    group_label: assist.assist.group.map(|it| it.0),
+                    source_change: assist.source_change,
+                })
+                .collect()
+        })
    }
    /// Computes the set of diagnostics for the given file.
@@ -490,7 +493,7 @@ impl Analysis {
    ) -> Cancelable<Result<SourceChange, SsrError>> {
        self.with_db(|db| {
            let edits = ssr::parse_search_replace(query, parse_only, db)?;
-            Ok(SourceChange::source_file_edits("ssr", edits))
+            Ok(SourceChange::source_file_edits("Structural Search Replace", edits))
        })
    }
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
deleted file mode 100644
index bea30fe2a..000000000
--- a/crates/ra_ide/src/marks.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! See test_utils/src/marks.rs
-test_utils::marks!(
-    inserts_angle_brackets_for_generics
-    inserts_parens_for_function_calls
-    call_info_bad_offset
-    dont_complete_current_use
-    test_resolve_parent_module_on_module_decl
-    search_filters_by_range
-    dont_insert_macro_call_parens_unncessary
-    self_fulfilling_completion
-    test_struct_field_completion_in_func_call
-    test_struct_field_completion_in_record_lit
-);
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index aaf4460df..a083fb1eb 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -7,7 +7,7 @@ use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, AstNode},
 };
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::NavigationTarget;
@@ -25,7 +25,7 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
            .item_list()
            .map_or(false, |it| it.syntax().text_range().contains_inclusive(position.offset))
        {
-            tested_by!(test_resolve_parent_module_on_module_decl);
+            mark::hit!(test_resolve_parent_module_on_module_decl);
            module = m.syntax().ancestors().skip(1).find_map(ast::Module::cast);
        }
    }
@@ -57,7 +57,7 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
 mod tests {
    use ra_cfg::CfgOptions;
    use ra_db::Env;
-    use test_utils::covers;
+    use test_utils::mark;
    use crate::{
        mock_analysis::{analysis_and_position, MockAnalysis},
@@ -81,7 +81,7 @@ mod tests {
    #[test]
    fn test_resolve_parent_module_on_module_decl() {
-        covers!(test_resolve_parent_module_on_module_decl);
+        mark::check!(test_resolve_parent_module_on_module_decl);
        let (analysis, pos) = analysis_and_position(
            "
            //- /lib.rs
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 555ccf295..96444bf6a 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -190,8 +190,6 @@ fn get_struct_def_name_for_struct_literal_search(
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
    use crate::{
        mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
        Declaration, Reference, ReferenceSearchResult, SearchScope,
@@ -301,7 +299,6 @@ mod tests {
    #[test]
    fn search_filters_by_range() {
-        covers!(ra_ide_db::search_filters_by_range);
        let code = r#"
            fn foo() {
                let spam<|> = 92;
@@ -593,6 +590,31 @@ mod tests {
        check_result(refs, "i BIND_PAT FileId(1) 36..37 Other", &["FileId(1) 51..52 Other Write"]);
    }
+    #[test]
+    fn test_find_struct_function_refs_outside_module() {
+        let code = r#"
+        mod foo {
+            pub struct Foo;
+            impl Foo {
+                pub fn new<|>() -> Foo {
+                    Foo
+                }
+            }
+        }
+        fn main() {
+            let _f = foo::Foo::new();
+        }"#;
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "new FN_DEF FileId(1) 87..150 94..97 Other",
+            &["FileId(1) 227..230 StructLiteral"],
+        );
+    }
    fn get_all_refs(text: &str) -> ReferenceSearchResult {
        let (analysis, position) = single_file_with_position(text);
        analysis.find_all_refs(position, None).unwrap().unwrap()
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index fd17bc9f2..fd2163dad 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -4,17 +4,18 @@ use hir::{ModuleSource, Semantics};
 use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
+    algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
+    AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 use ra_text_edit::TextEdit;
+use std::convert::TryInto;
+use test_utils::mark;
 use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind, SourceChange,
+    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
-    SourceFileEdit, TextRange,
+    SourceChange, SourceFileEdit, TextRange, TextSize,
 };
-use super::find_all_refs;
 pub(crate) fn rename(
    db: &RootDatabase,
    position: FilePosition,
@@ -22,17 +23,21 @@ pub(crate) fn rename(
 ) -> Option<RangeInfo<SourceChange>> {
    match lex_single_valid_syntax_kind(new_name)? {
        SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
+        SyntaxKind::SELF_KW => return rename_to_self(db, position),
        _ => return None,
    }
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
-    if let Some((ast_name, ast_module)) =
+    let syntax = source_file.syntax();
-        find_name_and_module_at_offset(source_file.syntax(), position)
+    if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
-    {
        let range = ast_name.syntax().text_range();
        rename_mod(&sema, &ast_name, &ast_module, position, new_name)
            .map(|info| RangeInfo::new(range, info))
+    } else if let Some(self_token) =
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+    {
+        rename_self_to_param(db, position, self_token, new_name)
    } else {
        rename_reference(sema.db, position, new_name)
    }
@@ -52,11 +57,13 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
    let file_id = reference.file_range.file_id;
    let range = match reference.kind {
        ReferenceKind::FieldShorthandForField => {
+            mark::hit!(test_rename_struct_field_for_shorthand);
            replacement_text.push_str(new_name);
            replacement_text.push_str(": ");
            TextRange::new(reference.file_range.range.start(), reference.file_range.range.start())
        }
        ReferenceKind::FieldShorthandForLocal => {
+            mark::hit!(test_rename_local_for_field_shorthand);
            replacement_text.push_str(": ");
            replacement_text.push_str(new_name);
            TextRange::new(reference.file_range.range.end(), reference.file_range.range.end())
@@ -121,7 +128,113 @@ fn rename_mod(
        source_file_edits.extend(ref_edits);
    }
-    Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
+    Some(SourceChange::from_edits("Rename", source_file_edits, file_system_edits))
+}
+fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+    let syn = source_file.syntax();
+    let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
+    let params = fn_def.param_list()?;
+    if params.self_param().is_some() {
+        return None; // method already has self param
+    }
+    let first_param = params.params().next()?;
+    let mutable = match first_param.ascribed_type() {
+        Some(ast::TypeRef::ReferenceType(rt)) => rt.mut_token().is_some(),
+        _ => return None, // not renaming other types
+    };
+    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let param_range = first_param.syntax().text_range();
+    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
+        .into_iter()
+        .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
+    if param_ref.is_empty() {
+        return None;
+    }
+    let mut edits = usages
+        .into_iter()
+        .map(|reference| source_edit_from_reference(reference, "self"))
+        .collect::<Vec<_>>();
+    edits.push(SourceFileEdit {
+        file_id: position.file_id,
+        edit: TextEdit::replace(
+            param_range,
+            String::from(if mutable { "&mut self" } else { "&self" }),
+        ),
+    });
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edits)))
+}
+fn text_edit_from_self_param(
+    syn: &SyntaxNode,
+    self_param: &ast::SelfParam,
+    new_name: &str,
+) -> Option<TextEdit> {
+    fn target_type_name(impl_def: &ast::ImplDef) -> Option<String> {
+        if let Some(ast::TypeRef::PathType(p)) = impl_def.target_type() {
+            return Some(p.path()?.segment()?.name_ref()?.text().to_string());
+        }
+        None
+    }
+    let impl_def =
+        find_node_at_offset::<ast::ImplDef>(syn, self_param.syntax().text_range().start())?;
+    let type_name = target_type_name(&impl_def)?;
+    let mut replacement_text = String::from(new_name);
+    replacement_text.push_str(": ");
+    replacement_text.push_str(self_param.mut_token().map_or("&", |_| "&mut "));
+    replacement_text.push_str(type_name.as_str());
+    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
+}
+fn rename_self_to_param(
+    db: &RootDatabase,
+    position: FilePosition,
+    self_token: SyntaxToken,
+    new_name: &str,
+) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+    let syn = source_file.syntax();
+    let text = db.file_text(position.file_id);
+    let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
+    let search_range = fn_def.syntax().text_range();
+    let mut edits: Vec<SourceFileEdit> = vec![];
+    for (idx, _) in text.match_indices("self") {
+        let offset: TextSize = idx.try_into().unwrap();
+        if !search_range.contains_inclusive(offset) {
+            continue;
+        }
+        if let Some(ref usage) =
+            syn.token_at_offset(offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        {
+            let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
+                text_edit_from_self_param(syn, self_param, new_name)?
+            } else {
+                TextEdit::replace(usage.text_range(), String::from(new_name))
+            };
+            edits.push(SourceFileEdit { file_id: position.file_id, edit });
+        }
+    }
+    let range = ast::SelfParam::cast(self_token.parent())
+        .map_or(self_token.text_range(), |p| p.syntax().text_range());
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edits)))
 }
 fn rename_reference(
@@ -140,14 +253,14 @@ fn rename_reference(
        return None;
    }
-    Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edit)))
 }
 #[cfg(test)]
 mod tests {
    use insta::assert_debug_snapshot;
    use ra_text_edit::TextEditBuilder;
-    use test_utils::assert_eq_text;
+    use test_utils::{assert_eq_text, mark};
    use crate::{
        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
@@ -379,6 +492,7 @@ mod tests {
    #[test]
    fn test_rename_struct_field_for_shorthand() {
+        mark::check!(test_rename_struct_field_for_shorthand);
        test_rename(
            r#"
    struct Foo {
@@ -408,6 +522,7 @@ mod tests {
    #[test]
    fn test_rename_local_for_field_shorthand() {
+        mark::check!(test_rename_local_for_field_shorthand);
        test_rename(
            r#"
    struct Foo {
@@ -527,17 +642,17 @@ mod tests {
            RangeInfo {
                range: 4..7,
                info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
                                2,
                            ),
                            edit: TextEdit {
-                                atoms: [
+                                indels: [
-                                    AtomTextEdit {
+                                    Indel {
-                                        delete: 4..7,
                                        insert: "foo2",
+                                        delete: 4..7,
                                    },
                                ],
                            },
@@ -554,7 +669,7 @@ mod tests {
                            dst_path: "bar/foo2.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
@@ -579,17 +694,17 @@ mod tests {
            RangeInfo {
                range: 4..7,
                info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
                                1,
                            ),
                            edit: TextEdit {
-                                atoms: [
+                                indels: [
-                                    AtomTextEdit {
+                                    Indel {
-                                        delete: 4..7,
                                        insert: "foo2",
+                                        delete: 4..7,
                                    },
                                ],
                            },
@@ -606,7 +721,7 @@ mod tests {
                            dst_path: "foo2/mod.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
@@ -662,17 +777,17 @@ mod tests {
            RangeInfo {
                range: 8..11,
                info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
                                2,
                            ),
                            edit: TextEdit {
-                                atoms: [
+                                indels: [
-                                    AtomTextEdit {
+                                    Indel {
-                                        delete: 8..11,
                                        insert: "foo2",
+                                        delete: 8..11,
                                    },
                                ],
                            },
@@ -682,10 +797,10 @@ mod tests {
                                1,
                            ),
                            edit: TextEdit {
-                                atoms: [
+                                indels: [
-                                    AtomTextEdit {
+                                    Indel {
-                                        delete: 27..30,
                                        insert: "foo2",
+                                        delete: 27..30,
                                    },
                                ],
                            },
@@ -702,13 +817,164 @@ mod tests {
                            dst_path: "bar/foo2.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
        "###);
    }
+    #[test]
+    fn test_enum_variant_from_module_1() {
+        test_rename(
+            r#"
+    mod foo {
+        pub enum Foo {
+            Bar<|>,
+        }
+    }
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Bar => {}
+        }
+    }
+    "#,
+            "Baz",
+            r#"
+    mod foo {
+        pub enum Foo {
+            Baz,
+        }
+    }
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Baz => {}
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_enum_variant_from_module_2() {
+        test_rename(
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub bar<|>: uint,
+        }
+    }
+    fn foo(f: foo::Foo) {
+        let _ = f.bar;
+    }
+    "#,
+            "baz",
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub baz: uint,
+        }
+    }
+    fn foo(f: foo::Foo) {
+        let _ = f.baz;
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_parameter_to_self() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(foo<|>: &mut Foo) -> i32 {
+            foo.i
+        }
+    }
+    "#,
+            "self",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(&mut self) -> i32 {
+            self.i
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_self_to_parameter() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(&mut <|>self) -> i32 {
+            self.i
+        }
+    }
+    "#,
+            "foo",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(foo: &mut Foo) -> i32 {
+            foo.i
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_self_in_path_to_parameter() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(&self) -> i32 {
+            let self_var = 1;
+            self<|>.i
+        }
+    }
+    "#,
+            "foo",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn f(foo: &Foo) -> i32 {
+            let self_var = 1;
+            foo.i
+        }
+    }
+    "#,
+        );
+    }
    fn test_rename(text: &str, new_name: &str, expected: &str) {
        let (analysis, position) = single_file_with_position(text);
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -717,13 +983,13 @@ mod tests {
        if let Some(change) = source_change {
            for edit in change.info.source_file_edits {
                file_id = Some(edit.file_id);
-                for atom in edit.edit.as_atoms() {
+                for indel in edit.edit.into_iter() {
-                    text_edit_builder.replace(atom.delete, atom.insert.clone());
+                    text_edit_builder.replace(indel.delete, indel.insert);
                }
            }
        }
-        let result =
+        let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
-            text_edit_builder.finish().apply(&*analysis.file_text(file_id.unwrap()).unwrap());
+        text_edit_builder.finish().apply(&mut result);
        assert_eq_text!(expected, &*result);
    }
 }
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index 38637c19c..131b8f307 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use hir::Semantics;
+use hir::{AsAssocItem, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
@@ -9,6 +9,7 @@ use ra_syntax::{
 };
 use crate::FileId;
+use ast::DocCommentsOwner;
 use std::fmt::Display;
 #[derive(Debug)]
@@ -37,6 +38,7 @@ pub enum RunnableKind {
    Test { test_id: TestId, attr: TestAttr },
    TestMod { path: String },
    Bench { test_id: TestId },
+    DocTest { test_id: TestId },
    Bin,
 }
@@ -63,14 +65,36 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, fn_def: ast::FnDef) -> Option<Run
        RunnableKind::Bin
    } else {
        let test_id = if let Some(module) = sema.to_def(&fn_def).map(|def| def.module(sema.db)) {
-            let path = module
+            let def = sema.to_def(&fn_def)?;
+            let impl_trait_name =
+                def.as_assoc_item(sema.db).and_then(|assoc_item| {
+                    match assoc_item.container(sema.db) {
+                        hir::AssocItemContainer::Trait(trait_item) => {
+                            Some(trait_item.name(sema.db).to_string())
+                        }
+                        hir::AssocItemContainer::ImplDef(impl_def) => impl_def
+                            .target_ty(sema.db)
+                            .as_adt()
+                            .map(|adt| adt.name(sema.db).to_string()),
+                    }
+                });
+            let path_iter = module
                .path_to_root(sema.db)
                .into_iter()
                .rev()
                .filter_map(|it| it.name(sema.db))
-                .map(|name| name.to_string())
+                .map(|name| name.to_string());
-                .chain(std::iter::once(name_string))
-                .join("::");
+            let path = if let Some(impl_trait_name) = impl_trait_name {
+                path_iter
+                    .chain(std::iter::once(impl_trait_name))
+                    .chain(std::iter::once(name_string))
+                    .join("::")
+            } else {
+                path_iter.chain(std::iter::once(name_string)).join("::")
+            };
            TestId::Path(path)
        } else {
            TestId::Name(name_string)
@@ -81,6 +105,8 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, fn_def: ast::FnDef) -> Option<Run
            RunnableKind::Test { test_id, attr }
        } else if fn_def.has_atom_attr("bench") {
            RunnableKind::Bench { test_id }
+        } else if has_doc_test(&fn_def) {
+            RunnableKind::DocTest { test_id }
        } else {
            return None;
        }
@@ -117,6 +143,10 @@ fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
        .any(|attribute_text| attribute_text.contains("test"))
 }
+fn has_doc_test(fn_def: &ast::FnDef) -> bool {
+    fn_def.doc_comment_text().map_or(false, |comment| comment.contains("```"))
+}
 fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
    let has_test_function = module
        .item_list()?
@@ -195,6 +225,79 @@ mod tests {
    }
    #[test]
+    fn test_runnables_doc_test() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+        /// ```
+        /// let x = 5;
+        /// ```
+        fn foo() {}
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot!(&runnables,
+        @r###"
+        [
+            Runnable {
+                range: 1..21,
+                kind: Bin,
+            },
+            Runnable {
+                range: 22..64,
+                kind: DocTest {
+                    test_id: Path(
+                        "foo",
+                    ),
+                },
+            },
+        ]
+        "###
+                );
+    }
+    #[test]
+    fn test_runnables_doc_test_in_impl() {
+        let (analysis, pos) = analysis_and_position(
+            r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+        struct Data;
+        impl Data {
+            /// ```
+            /// let x = 5;
+            /// ```
+            fn foo() {}
+        }
+        "#,
+        );
+        let runnables = analysis.runnables(pos.file_id).unwrap();
+        assert_debug_snapshot!(&runnables,
+        @r###"
+        [
+            Runnable {
+                range: 1..21,
+                kind: Bin,
+            },
+            Runnable {
+                range: 51..105,
+                kind: DocTest {
+                    test_id: Path(
+                        "Data::foo",
+                    ),
+                },
+            },
+        ]
+        "###
+                );
+    }
+    #[test]
    fn test_runnables_module() {
        let (analysis, pos) = analysis_and_position(
            r#"
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index de06daf72..752b487e8 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -27,13 +27,13 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
 </style>
-<pre><code><span class="macro">macro_rules!</span> println {
+<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> {
    ($($arg:tt)*) =&gt; ({
        $<span class="keyword">crate</span>::io::_print($<span class="keyword">crate</span>::format_args_nl!($($arg)*));
    })
 }
 #[rustc_builtin_macro]
-<span class="macro">macro_rules!</span> format_args_nl {
+<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> {
    ($fmt:expr) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
    ($fmt:expr, $($args:tt)*) =&gt; {{ <span class="comment">/* compiler built-in */</span> }};
 }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 4b12fe823..635fe5cf9 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -33,11 +33,23 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
 }
+<span class="keyword">trait</span> <span class="trait declaration">Bar</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span>;
+}
+<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span> {
+        <span class="keyword">self</span>.<span class="field">x</span>
+    }
+}
+<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span>: <span class="builtin_type">i32</span> = <span class="numeric_literal">0</span>;
 <span class="keyword">fn</span> <span class="function declaration">foo</span>&lt;<span class="lifetime declaration">'a</span>, <span class="type_param declaration">T</span>&gt;() -&gt; <span class="type_param">T</span> {
    <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;()
 }
-<span class="macro">macro_rules!</span> def_fn {
+<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> {
    ($($tt:tt)*) =&gt; {$($tt)*}
 }
@@ -56,7 +68,14 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
        <span class="keyword">let</span> <span class="variable declaration">x</span> = <span class="numeric_literal">92</span>;
        <span class="variable mutable">vec</span>.<span class="unresolved_reference">push</span>(<span class="struct">Foo</span> { <span class="field">x</span>, <span class="field">y</span>: <span class="numeric_literal">1</span> });
    }
-    <span class="keyword unsafe">unsafe</span> { <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>); }
+    <span class="keyword unsafe">unsafe</span> {
+        <span class="variable mutable">vec</span>.<span class="unresolved_reference">set_len</span>(<span class="numeric_literal">0</span>);
+        <span class="static mutable">STATIC_MUT</span> = <span class="numeric_literal">1</span>;
+    }
+    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> {
+        <span class="comment">// Do nothing</span>
+    }
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
diff --git a/crates/ra_ide/src/source_change.rs b/crates/ra_ide/src/source_change.rs
deleted file mode 100644
index 71b0e8f75..000000000
--- a/crates/ra_ide/src/source_change.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-//! This modules defines type to represent changes to the source code, that flow
-//! from the server to the client.
-//!
-//! It can be viewed as a dual for `AnalysisChange`.
-use ra_db::RelativePathBuf;
-use ra_text_edit::TextEdit;
-use crate::{FileId, FilePosition, SourceRootId, TextSize};
-#[derive(Debug)]
-pub struct SourceChange {
-    pub label: String,
-    pub source_file_edits: Vec<SourceFileEdit>,
-    pub file_system_edits: Vec<FileSystemEdit>,
-    pub cursor_position: Option<FilePosition>,
-}
-impl SourceChange {
-    /// Creates a new SourceChange with the given label
-    /// from the edits.
-    pub(crate) fn from_edits<L: Into<String>>(
-        label: L,
-        source_file_edits: Vec<SourceFileEdit>,
-        file_system_edits: Vec<FileSystemEdit>,
-    ) -> Self {
-        SourceChange {
-            label: label.into(),
-            source_file_edits,
-            file_system_edits,
-            cursor_position: None,
-        }
-    }
-    /// Creates a new SourceChange with the given label,
-    /// containing only the given `SourceFileEdits`.
-    pub(crate) fn source_file_edits<L: Into<String>>(label: L, edits: Vec<SourceFileEdit>) -> Self {
-        SourceChange {
-            label: label.into(),
-            source_file_edits: edits,
-            file_system_edits: vec![],
-            cursor_position: None,
-        }
-    }
-    /// Creates a new SourceChange with the given label,
-    /// containing only the given `FileSystemEdits`.
-    pub(crate) fn file_system_edits<L: Into<String>>(label: L, edits: Vec<FileSystemEdit>) -> Self {
-        SourceChange {
-            label: label.into(),
-            source_file_edits: vec![],
-            file_system_edits: edits,
-            cursor_position: None,
-        }
-    }
-    /// Creates a new SourceChange with the given label,
-    /// containing only a single `SourceFileEdit`.
-    pub(crate) fn source_file_edit<L: Into<String>>(label: L, edit: SourceFileEdit) -> Self {
-        SourceChange::source_file_edits(label, vec![edit])
-    }
-    /// Creates a new SourceChange with the given label
-    /// from the given `FileId` and `TextEdit`
-    pub(crate) fn source_file_edit_from<L: Into<String>>(
-        label: L,
-        file_id: FileId,
-        edit: TextEdit,
-    ) -> Self {
-        SourceChange::source_file_edit(label, SourceFileEdit { file_id, edit })
-    }
-    /// Creates a new SourceChange with the given label
-    /// from the given `FileId` and `TextEdit`
-    pub(crate) fn file_system_edit<L: Into<String>>(label: L, edit: FileSystemEdit) -> Self {
-        SourceChange::file_system_edits(label, vec![edit])
-    }
-    /// Sets the cursor position to the given `FilePosition`
-    pub(crate) fn with_cursor(mut self, cursor_position: FilePosition) -> Self {
-        self.cursor_position = Some(cursor_position);
-        self
-    }
-    /// Sets the cursor position to the given `FilePosition`
-    pub(crate) fn with_cursor_opt(mut self, cursor_position: Option<FilePosition>) -> Self {
-        self.cursor_position = cursor_position;
-        self
-    }
-}
-#[derive(Debug)]
-pub struct SourceFileEdit {
-    pub file_id: FileId,
-    pub edit: TextEdit,
-}
-#[derive(Debug)]
-pub enum FileSystemEdit {
-    CreateFile { source_root: SourceRootId, path: RelativePathBuf },
-    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
-}
-pub(crate) struct SingleFileChange {
-    pub label: String,
-    pub edit: TextEdit,
-    pub cursor_position: Option<TextSize>,
-}
-impl SingleFileChange {
-    pub(crate) fn into_source_change(self, file_id: FileId) -> SourceChange {
-        SourceChange {
-            label: self.label,
-            source_file_edits: vec![SourceFileEdit { file_id, edit: self.edit }],
-            file_system_edits: Vec::new(),
-            cursor_position: self.cursor_position.map(|offset| FilePosition { file_id, offset }),
-        }
-    }
-}
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 7b93ff2d2..1873d1d0d 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -1,18 +1,18 @@
 //!  structural search replace
-use crate::source_change::SourceFileEdit;
+use std::{collections::HashMap, iter::once, str::FromStr};
 use ra_db::{SourceDatabase, SourceDatabaseExt};
-use ra_ide_db::symbol_index::SymbolsDatabase;
+use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-use ra_ide_db::RootDatabase;
-use ra_syntax::ast::make::try_expr_from_text;
 use ra_syntax::ast::{
-    ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr, RecordField, RecordLit,
+    make::try_expr_from_text, ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr,
+    RecordField, RecordLit,
 };
 use ra_syntax::{AstNode, SyntaxElement, SyntaxKind, SyntaxNode};
 use ra_text_edit::{TextEdit, TextEditBuilder};
 use rustc_hash::FxHashMap;
-use std::collections::HashMap;
-use std::{iter::once, str::FromStr};
+use crate::SourceFileEdit;
 #[derive(Debug, PartialEq)]
 pub struct SsrError(String);
@@ -401,16 +401,22 @@ fn render_replace(
    ignored_comments: &Vec<Comment>,
    template: &SsrTemplate,
 ) -> String {
-    let mut builder = TextEditBuilder::default();
+    let edit = {
-    for element in template.template.descendants() {
+        let mut builder = TextEditBuilder::default();
-        if let Some(var) = template.placeholders.get(&element) {
+        for element in template.template.descendants() {
-            builder.replace(element.text_range(), binding[var].to_string())
+            if let Some(var) = template.placeholders.get(&element) {
+                builder.replace(element.text_range(), binding[var].to_string())
+            }
        }
-    }
+        for comment in ignored_comments {
-    for comment in ignored_comments {
+            builder.insert(template.template.text_range().end(), comment.syntax().to_string())
-        builder.insert(template.template.text_range().end(), comment.syntax().to_string())
+        }
-    }
+        builder.finish()
-    builder.finish().apply(&template.template.text().to_string())
+    };
+    let mut text = template.template.text().to_string();
+    edit.apply(&mut text);
+    text
 }
 #[cfg(test)]
@@ -505,7 +511,9 @@ mod tests {
        );
        let edit = replace(&matches, &query.template);
-        assert_eq!(edit.apply(input), "fn main() { bar(1+2); }");
+        let mut after = input.to_string();
+        edit.apply(&mut after);
+        assert_eq!(after, "fn main() { bar(1+2); }");
    }
    fn assert_ssr_transform(query: &str, input: &str, result: &str) {
@@ -513,7 +521,9 @@ mod tests {
        let code = SourceFile::parse(input).tree();
        let matches = find(&query.pattern, code.syntax());
        let edit = replace(&matches, &query.template);
-        assert_eq!(edit.apply(input), result);
+        let mut after = input.to_string();
+        edit.apply(&mut after);
+        assert_eq!(after, result);
    }
    #[test]
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 6658c7bb2..be57eeb0a 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -167,6 +167,19 @@ pub(crate) fn highlight(
                        binding_hash: None,
                    });
                }
+                if let Some(name) = mc.is_macro_rules() {
+                    if let Some((highlight, binding_hash)) = highlight_element(
+                        &sema,
+                        &mut bindings_shadow_count,
+                        name.syntax().clone().into(),
+                    ) {
+                        stack.add(HighlightedRange {
+                            range: name.syntax().text_range(),
+                            highlight,
+                            binding_hash,
+                        });
+                    }
+                }
                continue;
            }
            WalkEvent::Leave(Some(mc)) => {
@@ -390,12 +403,13 @@ fn highlight_element(
                T![break]
                | T![continue]
                | T![else]
-                | T![for]
                | T![if]
                | T![loop]
                | T![match]
                | T![return]
-                | T![while] => h | HighlightModifier::ControlFlow,
+                | T![while]
+                | T![in] => h | HighlightModifier::ControlFlow,
+                T![for] if !is_child_of_impl(element) => h | HighlightModifier::ControlFlow,
                T![unsafe] => h | HighlightModifier::Unsafe,
                _ => h,
            }
@@ -419,6 +433,13 @@ fn highlight_element(
    }
 }
+fn is_child_of_impl(element: SyntaxElement) -> bool {
+    match element.parent() {
+        Some(e) => e.kind() == IMPL_DEF,
+        _ => false,
+    }
+}
 fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
    match def {
        Definition::Macro(_) => HighlightTag::Macro,
@@ -431,10 +452,16 @@ fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
            hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
            hir::ModuleDef::Const(_) => HighlightTag::Constant,
-            hir::ModuleDef::Static(_) => HighlightTag::Static,
            hir::ModuleDef::Trait(_) => HighlightTag::Trait,
            hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
            hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
+            hir::ModuleDef::Static(s) => {
+                let mut h = Highlight::new(HighlightTag::Static);
+                if s.is_mut(db) {
+                    h |= HighlightModifier::Mutable;
+                }
+                return h;
+            }
        },
        Definition::SelfType(_) => HighlightTag::SelfType,
        Definition::TypeParam(_) => HighlightTag::TypeParam,
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index d2926ba78..eb43a23da 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -17,6 +17,18 @@ struct Foo {
    pub y: i32,
 }
+trait Bar {
+    fn bar(&self) -> i32;
+}
+impl Bar for Foo {
+    fn bar(&self) -> i32 {
+        self.x
+    }
+}
+static mut STATIC_MUT: i32 = 0;
 fn foo<'a, T>() -> T {
    foo::<'a, i32>()
 }
@@ -40,7 +52,14 @@ fn main() {
        let x = 92;
        vec.push(Foo { x, y: 1 });
    }
-    unsafe { vec.set_len(0); }
+    unsafe {
+        vec.set_len(0);
+        STATIC_MUT = 1;
+    }
+    for e in vec {
+        // Do nothing
+    }
    let mut x = 42;
    let y = &mut x;
diff --git a/crates/ra_ide/src/syntax_tree.rs b/crates/ra_ide/src/syntax_tree.rs
index bf97f8c56..86c70ff83 100644
--- a/crates/ra_ide/src/syntax_tree.rs
+++ b/crates/ra_ide/src/syntax_tree.rs
@@ -120,9 +120,8 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "}"
-        [email protected] "}"
 "#
            .trim()
        );
@@ -153,26 +152,25 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "\n    "
-        [email protected] "\n    "
+      [email protected]
-        [email protected]
+        [email protected]
-          [email protected]
+          [email protected]
-            [email protected]
+            [email protected]
-              [email protected]
+              [email protected]
-                [email protected]
+                [email protected] "assert"
-                  [email protected] "assert"
+          [email protected] "!"
-            [email protected] "!"
+          [email protected]
-            [email protected]
+            [email protected] "("
-              [email protected] "("
+            [email protected] "\"\n    fn foo() {\n     ..."
-              [email protected] "\"\n    fn foo() {\n     ..."
+            [email protected] ","
-              [email protected] ","
+            [email protected] " "
-              [email protected] " "
+            [email protected] "\"\""
-              [email protected] "\"\""
+            [email protected] ")"
-              [email protected] ")"
+        [email protected] ";"
-          [email protected] ";"
+      [email protected] "\n"
-        [email protected] "\n"
+      [email protected] "}"
-        [email protected] "}"
 "#
            .trim()
        );
@@ -196,9 +194,8 @@ [email protected]
    [email protected] ")"
  [email protected] " "
  [email protected]
-    [email protected]
+    [email protected] "{"
-      [email protected] "{"
+    [email protected] "}"
-      [email protected] "}"
 "#
            .trim()
        );
@@ -265,10 +262,9 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "\n"
-        [email protected] "\n"
+      [email protected] "}"
-        [email protected] "}"
 "#
            .trim()
        );
@@ -300,10 +296,9 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "\n"
-        [email protected] "\n"
+      [email protected] "}"
-        [email protected] "}"
 "#
            .trim()
        );
@@ -334,10 +329,9 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "\n"
-        [email protected] "\n"
+      [email protected] "}"
-        [email protected] "}"
  [email protected] "\n"
  [email protected]
    [email protected] "fn"
@@ -349,10 +343,9 @@ [email protected]
      [email protected] ")"
    [email protected] " "
    [email protected]
-      [email protected]
+      [email protected] "{"
-        [email protected] "{"
+      [email protected] "\n"
-        [email protected] "\n"
+      [email protected] "}"
-        [email protected] "}"
 "#
            .trim()
        );
diff --git a/crates/ra_ide/src/test_utils.rs b/crates/ra_ide/src/test_utils.rs
deleted file mode 100644
index f14533e14..000000000
--- a/crates/ra_ide/src/test_utils.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! FIXME: write short doc here
-use ra_syntax::{SourceFile, TextSize};
-use ra_text_edit::TextEdit;
-pub use test_utils::*;
-pub fn check_action<F: Fn(&SourceFile, TextSize) -> Option<TextEdit>>(
-    before: &str,
-    after: &str,
-    f: F,
-) {
-    let (before_cursor_pos, before) = extract_offset(before);
-    let file = SourceFile::parse(&before).ok().unwrap();
-    let result = f(&file, before_cursor_pos).expect("code action is not applicable");
-    let actual = result.apply(&before);
-    let actual_cursor_pos =
-        result.apply_to_offset(before_cursor_pos).expect("cursor position is affected by the edit");
-    let actual = add_cursor(&actual, actual_cursor_pos);
-    assert_eq_text!(after, &actual);
-}
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 2a8b4327f..cd48cad93 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -17,15 +17,16 @@ mod on_enter;
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{source_change::SingleFileChange, RootDatabase};
 use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, AstToken},
    AstNode, SourceFile, TextRange, TextSize,
 };
 use ra_text_edit::TextEdit;
-use crate::{source_change::SingleFileChange, SourceChange};
+use crate::SourceChange;
 pub(crate) use on_enter::on_enter;
@@ -81,7 +82,6 @@ fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange>
    Some(SingleFileChange {
        label: "add semicolon".to_string(),
        edit: TextEdit::insert(offset, ";".to_string()),
-        cursor_position: None,
    })
 }
@@ -110,7 +110,6 @@ fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange>
    Some(SingleFileChange {
        label: "reindent dot".to_string(),
        edit: TextEdit::replace(TextRange::new(offset - current_indent_len, offset), target_indent),
-        cursor_position: Some(offset + target_indent_len - current_indent_len + TextSize::of('.')),
    })
 }
@@ -129,7 +128,6 @@ fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChang
    Some(SingleFileChange {
        label: "add space after return type".to_string(),
        edit: TextEdit::insert(after_arrow, " ".to_string()),
-        cursor_position: Some(after_arrow),
    })
 }
@@ -139,26 +137,23 @@ mod tests {
    use super::*;
-    fn do_type_char(char_typed: char, before: &str) -> Option<(String, SingleFileChange)> {
+    fn do_type_char(char_typed: char, before: &str) -> Option<String> {
        let (offset, before) = extract_offset(before);
        let edit = TextEdit::insert(offset, char_typed.to_string());
-        let before = edit.apply(&before);
+        let mut before = before.to_string();
+        edit.apply(&mut before);
        let parse = SourceFile::parse(&before);
-        on_char_typed_inner(&parse.tree(), offset, char_typed)
+        on_char_typed_inner(&parse.tree(), offset, char_typed).map(|it| {
-            .map(|it| (it.edit.apply(&before), it))
+            it.edit.apply(&mut before);
+            before.to_string()
+        })
    }
    fn type_char(char_typed: char, before: &str, after: &str) {
-        let (actual, file_change) = do_type_char(char_typed, before)
+        let actual = do_type_char(char_typed, before)
            .unwrap_or_else(|| panic!("typing `{}` did nothing", char_typed));
-        if after.contains("<|>") {
+        assert_eq_text!(after, &actual);
-            let (offset, after) = extract_offset(after);
-            assert_eq_text!(&after, &actual);
-            assert_eq!(file_change.cursor_position, Some(offset))
-        } else {
-            assert_eq_text!(after, &actual);
-        }
    }
    fn type_char_noop(char_typed: char, before: &str) {
@@ -346,6 +341,6 @@ fn foo() {
    #[test]
    fn adds_space_after_return_type() {
-        type_char('>', "fn foo() -<|>{ 92 }", "fn foo() -><|> { 92 }")
+        type_char('>', "fn foo() -<|>{ 92 }", "fn foo() -> { 92 }")
    }
 }
diff --git a/crates/ra_ide/src/typing/on_enter.rs b/crates/ra_ide/src/typing/on_enter.rs
index 30c8c5572..85be14ad3 100644
--- a/crates/ra_ide/src/typing/on_enter.rs
+++ b/crates/ra_ide/src/typing/on_enter.rs
@@ -38,17 +38,15 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Sour
    }
    let indent = node_indent(&file, comment.syntax())?;
-    let inserted = format!("\n{}{} ", indent, prefix);
+    let inserted = format!("\n{}{} $0", indent, prefix);
-    let cursor_position = position.offset + TextSize::of(&inserted);
    let edit = TextEdit::insert(position.offset, inserted);
-    Some(
+    let mut res = SourceChange::source_file_edit(
-        SourceChange::source_file_edit(
+        "On enter",
-            "on enter",
+        SourceFileEdit { edit, file_id: position.file_id },
-            SourceFileEdit { edit, file_id: position.file_id },
+    );
-        )
+    res.is_snippet = true;
-        .with_cursor(FilePosition { offset: cursor_position, file_id: position.file_id }),
+    Some(res)
-    )
 }
 fn followed_by_comment(comment: &ast::Comment) -> bool {
@@ -84,7 +82,7 @@ fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
 #[cfg(test)]
 mod tests {
-    use test_utils::{add_cursor, assert_eq_text, extract_offset};
+    use test_utils::{assert_eq_text, extract_offset};
    use crate::mock_analysis::single_file;
@@ -96,8 +94,8 @@ mod tests {
        let result = analysis.on_enter(FilePosition { offset, file_id }).unwrap()?;
        assert_eq!(result.source_file_edits.len(), 1);
-        let actual = result.source_file_edits[0].edit.apply(&before);
+        let mut actual = before.to_string();
-        let actual = add_cursor(&actual, result.cursor_position.unwrap().offset);
+        result.source_file_edits[0].edit.apply(&mut actual);
        Some(actual)
    }
@@ -120,7 +118,7 @@ fn foo() {
 ",
            r"
 /// Some docs
-/// <|>
+/// $0
 fn foo() {
 }
 ",
@@ -136,7 +134,7 @@ impl S {
            r"
 impl S {
    /// Some
-    /// <|> docs.
+    /// $0 docs.
    fn foo() {}
 }
 ",
@@ -150,7 +148,7 @@ fn foo() {
 ",
            r"
 ///
-/// <|> Some docs
+/// $0 Some docs
 fn foo() {
 }
 ",
@@ -174,7 +172,7 @@ fn main() {
            r"
 fn main() {
    // Fix
-    // <|> me
+    // $0 me
    let x = 1 + 1;
 }
 ",
@@ -194,7 +192,7 @@ fn main() {
            r"
 fn main() {
    // Fix
-    // <|>
+    // $0
    // me
    let x = 1 + 1;
 }
author	Galilée 'Bill' Enguehard <[email protected]>	2020-05-21 22:27:38 +0100
committer	Galilée 'Bill' Enguehard <[email protected]>	2020-05-21 22:27:38 +0100
commit	7fece3bdd2450c0807f7dd742239cae95f0cc65e (patch)
tree	866c4db826c959e79c63a6727bdb9f2c61e6fc4f /crates/ra_ide
parent	db926218b2082077750291f8426ddd28b284cd08 (diff)
parent	59732df8d40dfadc6dcf5951265416576399712a (diff)