28 files changed, 898 insertions, 275 deletions
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 8bdc43b1a..191300704 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -59,8 +59,8 @@ 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)?;
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 7fcd22525..02ac0166b 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -3,7 +3,7 @@
 use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use ra_syntax::AstNode;
 use rustc_hash::FxHashSet;
-use test_utils::tested_by;
+use test_utils::mark;
 use crate::completion::{CompletionContext, Completions};
@@ -20,7 +20,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
    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,
    };
@@ -40,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;
                            }
                        }
@@ -147,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;
@@ -158,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());
    }
@@ -226,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(
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_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index bd40af1cb..db791660a 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,7 +1,7 @@
 //! 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};
@@ -30,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;
                }
            }
@@ -66,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};
@@ -76,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#"
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index b6b9627de..da336973c 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -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.
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 6021f7279..cfb7c1e38 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -63,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_indels().len() == 1 {
+        if self.text_edit().len() == 1 {
-            let atom = &self.text_edit().as_indels()[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 87a0b80f1..3d83c0f71 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -21,7 +21,7 @@ use ra_syntax::{
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
-use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit};
+use crate::{Diagnostic, FileId, FileSystemEdit, Fix, SourceChange, SourceFileEdit};
 #[derive(Debug, Copy, Clone)]
 pub enum Severity {
@@ -63,8 +63,8 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            .parent()
            .unwrap_or_else(|| RelativePath::new(""))
            .join(&d.candidate);
-        let create_file = FileSystemEdit::CreateFile { source_root, path };
+        let fix =
-        let fix = SourceChange::file_system_edit("Create module", create_file);
+            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -88,14 +88,12 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
                field_list = field_list.append_field(&field);
            }
-            let mut builder = TextEditBuilder::default();
+            let edit = {
-            algo::diff(&d.ast(db).syntax(), &field_list.syntax()).into_text_edit(&mut builder);
+                let mut builder = TextEditBuilder::default();
+                algo::diff(&d.ast(db).syntax(), &field_list.syntax()).into_text_edit(&mut builder);
-            Some(SourceChange::source_file_edit_from(
+                builder.finish()
-                "Fill struct fields",
+            };
-                file_id,
+            Some(Fix::new("Fill struct fields", SourceFileEdit { file_id, edit }.into()))
-                builder.finish(),
-            ))
        };
        res.borrow_mut().push(Diagnostic {
@@ -117,7 +115,8 @@ 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 source_change = SourceChange::source_file_edit_from(file_id, edit);
+        let fix = Fix::new("Wrap with ok", source_change);
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -154,9 +153,9 @@ fn check_unnecessary_braces_in_use_statement(
            range,
            message: "Unnecessary braces in use statement".to_string(),
            severity: Severity::WeakWarning,
-            fix: Some(SourceChange::source_file_edit(
+            fix: Some(Fix::new(
                "Remove unnecessary braces",
-                SourceFileEdit { file_id, edit },
+                SourceFileEdit { file_id, edit }.into(),
            )),
        });
    }
@@ -198,9 +197,9 @@ fn check_struct_shorthand_initialization(
                    range: record_field.syntax().text_range(),
                    message: "Shorthand struct initialization".to_string(),
                    severity: Severity::WeakWarning,
-                    fix: Some(SourceChange::source_file_edit(
+                    fix: Some(Fix::new(
                        "Use struct shorthand initialization",
-                        SourceFileEdit { file_id, edit },
+                        SourceFileEdit { file_id, edit }.into(),
                    )),
                });
            }
@@ -240,7 +239,7 @@ mod tests {
        let diagnostic =
            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 edit = fix.source_change.source_file_edits.pop().unwrap().edit;
        let actual = {
            let mut actual = before.to_string();
            edit.apply(&mut actual);
@@ -258,7 +257,7 @@ mod tests {
        let (analysis, file_position) = analysis_and_position(fixture);
        let diagnostic = analysis.diagnostics(file_position.file_id).unwrap().pop().unwrap();
        let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_file_edits.pop().unwrap().edit;
+        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
        let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
        let actual = {
            let mut actual = target_file_contents.to_string();
@@ -295,7 +294,7 @@ mod tests {
        let (analysis, file_id) = single_file(before);
        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 edit = fix.source_change.source_file_edits.pop().unwrap().edit;
        let actual = {
            let mut actual = before.to_string();
            edit.apply(&mut actual);
@@ -616,22 +615,24 @@ mod tests {
            Diagnostic {
                message: "unresolved module",
                range: 0..8,
+                severity: Error,
                fix: Some(
-                    SourceChange {
+                    Fix {
                        label: "Create module",
-                        source_file_edits: [],
+                        source_change: SourceChange {
-                        file_system_edits: [
+                            source_file_edits: [],
-                            CreateFile {
+                            file_system_edits: [
-                                source_root: SourceRootId(
+                                CreateFile {
-                                    0,
+                                    source_root: SourceRootId(
-                                ),
+                                        0,
-                                path: "foo.rs",
+                                    ),
-                            },
+                                    path: "foo.rs",
-                        ],
+                                },
-                        cursor_position: None,
+                            ],
+                            is_snippet: false,
+                        },
                    },
                ),
-                severity: Error,
            },
        ]
        "###);
@@ -665,29 +666,31 @@ mod tests {
            Diagnostic {
                message: "Missing structure fields:\n- b",
                range: 224..233,
+                severity: Error,
                fix: Some(
-                    SourceChange {
+                    Fix {
                        label: "Fill struct fields",
-                        source_file_edits: [
+                        source_change: SourceChange {
-                            SourceFileEdit {
+                            source_file_edits: [
-                                file_id: FileId(
+                                SourceFileEdit {
-                                    1,
+                                    file_id: FileId(
-                                ),
+                                        1,
-                                edit: TextEdit {
+                                    ),
-                                    indels: [
+                                    edit: TextEdit {
-                                        Indel {
+                                        indels: [
-                                            insert: "{a:42, b: ()}",
+                                            Indel {
-                                            delete: 3..9,
+                                                insert: "{a:42, b: ()}",
-                                        },
+                                                delete: 3..9,
-                                    ],
+                                            },
+                                        ],
+                                    },
                                },
-                            },
+                            ],
-                        ],
+                            file_system_edits: [],
-                        file_system_edits: [],
+                            is_snippet: false,
-                        cursor_position: None,
+                        },
                    },
                ),
-                severity: Error,
            },
        ]
        "###);
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 722092de9..8bb312156 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -79,14 +79,14 @@ pub(crate) fn rust_code_markup_with_doc(
    doc: Option<&str>,
    mod_path: Option<&str>,
 ) -> String {
-    let mut buf = "```rust\n".to_owned();
+    let mut buf = String::new();
    if let Some(mod_path) = mod_path {
        if !mod_path.is_empty() {
-            format_to!(buf, "{}\n", mod_path);
+            format_to!(buf, "{}\n___\n\n", mod_path);
        }
    }
-    format_to!(buf, "{}\n```", code);
+    format_to!(buf, "```rust\n{}\n```", code);
    if let Some(doc) = doc {
        format_to!(buf, "\n\n{}", doc);
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 150895abb..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
@@ -245,7 +243,6 @@ mod tests {
    #[test]
    fn goto_def_for_use_alias() {
-        covers!(ra_ide_db::goto_def_for_use_alias);
        check_goto(
            "
            //- /lib.rs
@@ -370,7 +367,6 @@ mod tests {
    #[test]
    fn goto_def_for_methods() {
-        covers!(ra_ide_db::goto_def_for_methods);
        check_goto(
            "
            //- /lib.rs
@@ -390,7 +386,6 @@ mod tests {
    #[test]
    fn goto_def_for_fields() {
-        covers!(ra_ide_db::goto_def_for_fields);
        check_goto(
            r"
            //- /lib.rs
@@ -409,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
@@ -430,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
@@ -873,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 06d4f1c63..1f4f6b848 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -405,7 +405,7 @@ mod tests {
                };
            }
        "#,
-            &["Foo\nfield_a: u32"],
+            &["Foo\n___\n\n```rust\nfield_a: u32"],
        );
        // Hovering over the field in the definition
@@ -422,7 +422,7 @@ mod tests {
                };
            }
        "#,
-            &["Foo\nfield_a: u32"],
+            &["Foo\n___\n\n```rust\nfield_a: u32"],
        );
    }
@@ -475,7 +475,7 @@ fn main() {
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\nSome"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\n___\n\n```rust\nSome"));
        let (analysis, position) = single_file_with_position(
            "
@@ -503,6 +503,9 @@ fn main() {
        "#,
            &["
 Option
+___
+```rust
 None
 ```
@@ -524,6 +527,9 @@ The None variant
        "#,
            &["
 Option
+___
+```rust
 Some
 ```
@@ -606,7 +612,10 @@ fn func(foo: i32) { if true { <|>foo; }; }
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("wrapper::Thing\nfn new() -> Thing"));
+        assert_eq!(
+            trim_markup_opt(hover.info.first()),
+            Some("wrapper::Thing\n___\n\n```rust\nfn new() -> Thing")
+        );
    }
    #[test]
@@ -921,4 +930,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/join_lines.rs b/crates/ra_ide/src/join_lines.rs
index d3af780c4..af1ade8a1 100644
--- a/crates/ra_ide/src/join_lines.rs
+++ b/crates/ra_ide/src/join_lines.rs
@@ -166,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]
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 915199bd8..5ac002d82 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -42,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;
@@ -82,19 +77,19 @@ pub use crate::{
 };
 pub use hir::Documentation;
-pub use ra_assists::AssistId;
+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>;
@@ -102,8 +97,22 @@ pub type Cancelable<T> = Result<T, Canceled>;
 pub struct Diagnostic {
    pub message: String,
    pub range: TextRange,
-    pub fix: Option<SourceChange>,
    pub severity: Severity,
+    pub fix: Option<Fix>,
+}
+#[derive(Debug)]
+pub struct Fix {
+    pub label: String,
+    pub source_change: SourceChange,
+}
+impl Fix {
+    pub fn new(label: impl Into<String>, source_change: SourceChange) -> Self {
+        let label = label.into();
+        assert!(label.starts_with(char::is_uppercase) && !label.ends_with('.'));
+        Self { label, source_change }
+    }
 }
 /// Info associated with a text range.
@@ -176,14 +185,10 @@ 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
    }
 }
@@ -295,14 +300,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)
        })
    }
@@ -462,17 +463,17 @@ 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| {
-            ra_assists::Assist::resolved(db, frange)
+            ra_assists::Assist::resolved(db, config, frange)
                .into_iter()
                .map(|assist| Assist {
                    id: assist.assist.id,
@@ -506,7 +507,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("Structural Search Replace", edits))
+            Ok(SourceChange::source_file_edits(edits))
        })
    }
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
deleted file mode 100644
index 51ca4dde3..000000000
--- a/crates/ra_ide/src/marks.rs
+++ /dev/null
@@ -1,16 +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
-    test_rename_struct_field_for_shorthand
-    test_rename_local_for_field_shorthand
-);
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 2cbb82c1a..28c6349b1 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -4,14 +4,16 @@ 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 test_utils::tested_by;
+use std::convert::TryInto;
+use test_utils::mark;
 use crate::{
    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
-    SourceChange, SourceFileEdit, TextRange,
+    SourceChange, SourceFileEdit, TextRange, TextSize,
 };
 pub(crate) fn rename(
@@ -21,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)
    }
@@ -51,13 +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 => {
-            tested_by!(test_rename_struct_field_for_shorthand);
+            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 => {
-            tested_by!(test_rename_local_for_field_shorthand);
+            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())
@@ -122,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(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(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(edits)))
 }
 fn rename_reference(
@@ -141,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(edit)))
 }
 #[cfg(test)]
 mod tests {
    use insta::assert_debug_snapshot;
    use ra_text_edit::TextEditBuilder;
-    use test_utils::{assert_eq_text, covers};
+    use test_utils::{assert_eq_text, mark};
    use crate::{
        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
@@ -380,7 +492,7 @@ mod tests {
    #[test]
    fn test_rename_struct_field_for_shorthand() {
-        covers!(test_rename_struct_field_for_shorthand);
+        mark::check!(test_rename_struct_field_for_shorthand);
        test_rename(
            r#"
    struct Foo {
@@ -410,7 +522,7 @@ mod tests {
    #[test]
    fn test_rename_local_for_field_shorthand() {
-        covers!(test_rename_local_for_field_shorthand);
+        mark::check!(test_rename_local_for_field_shorthand);
        test_rename(
            r#"
    struct Foo {
@@ -530,7 +642,6 @@ mod tests {
            RangeInfo {
                range: 4..7,
                info: SourceChange {
-                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
@@ -557,7 +668,7 @@ mod tests {
                            dst_path: "bar/foo2.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
@@ -582,7 +693,6 @@ mod tests {
            RangeInfo {
                range: 4..7,
                info: SourceChange {
-                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
@@ -609,7 +719,7 @@ mod tests {
                            dst_path: "foo2/mod.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
@@ -665,7 +775,6 @@ mod tests {
            RangeInfo {
                range: 8..11,
                info: SourceChange {
-                    label: "Rename",
                    source_file_edits: [
                        SourceFileEdit {
                            file_id: FileId(
@@ -705,7 +814,7 @@ mod tests {
                            dst_path: "bar/foo2.rs",
                        },
                    ],
-                    cursor_position: None,
+                    is_snippet: false,
                },
            },
        )
@@ -774,6 +883,95 @@ mod tests {
        );
    }
+    #[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();
@@ -782,8 +980,8 @@ mod tests {
        if let Some(change) = source_change {
            for edit in change.info.source_file_edits {
                file_id = Some(edit.file_id);
-                for indel in edit.edit.as_indels() {
+                for indel in edit.edit.into_iter() {
-                    text_edit_builder.replace(indel.delete, indel.insert.clone());
+                    text_edit_builder.replace(indel.delete, indel.insert);
                }
            }
        }
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index fa8a9d92c..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::{
@@ -65,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)
@@ -238,6 +260,44 @@ mod tests {
    }
    #[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/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 4c27aade4..2ceadf2fc 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -27,12 +27,22 @@ 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="attribute">#[derive(Clone, Debug)]</span>
+<pre><code><span class="attribute">#[</span><span class="function attribute">derive</span><span class="attribute">(Clone, Debug)]</span>
 <span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
    <span class="keyword">pub</span> <span class="field declaration">x</span>: <span class="builtin_type">i32</span>,
    <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> {
@@ -63,6 +73,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
        <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>;
    <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index d53a39f57..b55cf748d 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -361,7 +361,9 @@ fn highlight_element(
        }
        // Highlight references like the definitions they resolve to
-        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => return None,
+        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
+            Highlight::from(HighlightTag::Function) | HighlightModifier::Attribute
+        }
        NAME_REF => {
            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
            match classify_name_ref(sema, &name_ref) {
@@ -403,12 +405,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,
            }
@@ -432,6 +435,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,
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index be1a0f12b..33e6619ec 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -45,8 +45,10 @@ pub enum HighlightTag {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum HighlightModifier {
+    /// Used to differentiate individual elements within attributes.
+    Attribute = 0,
    /// Used with keywords like `if` and `break`.
-    ControlFlow = 0,
+    ControlFlow,
    /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
    /// not.
    Definition,
@@ -95,6 +97,7 @@ impl fmt::Display for HighlightTag {
 impl HighlightModifier {
    const ALL: &'static [HighlightModifier] = &[
+        HighlightModifier::Attribute,
        HighlightModifier::ControlFlow,
        HighlightModifier::Definition,
        HighlightModifier::Mutable,
@@ -103,6 +106,7 @@ impl HighlightModifier {
    fn as_str(self) -> &'static str {
        match self {
+            HighlightModifier::Attribute => "attribute",
            HighlightModifier::ControlFlow => "control",
            HighlightModifier::Definition => "declaration",
            HighlightModifier::Mutable => "mutable",
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 13894869c..eb43a23da 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -17,6 +17,16 @@ 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 {
@@ -47,6 +57,10 @@ fn main() {
        STATIC_MUT = 1;
    }
+    for e in vec {
+        // Do nothing
+    }
    let mut x = 42;
    let y = &mut x;
    let z = &y;
diff --git a/crates/ra_ide/src/test_utils.rs b/crates/ra_ide/src/test_utils.rs
deleted file mode 100644
index 48c8fd1f4..000000000
--- a/crates/ra_ide/src/test_utils.rs
+++ /dev/null
@@ -1,25 +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 = {
-        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);
-}
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 6f04f0be4..39bb3b357 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -17,7 +17,7 @@ mod on_enter;
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
-use ra_ide_db::{source_change::SingleFileChange, RootDatabase};
+use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, AstToken},
@@ -40,15 +40,11 @@ pub(crate) fn on_char_typed(
    assert!(TRIGGER_CHARS.contains(char_typed));
    let file = &db.parse(position.file_id).tree();
    assert_eq!(file.syntax().text().char_at(position.offset), Some(char_typed));
-    let single_file_change = on_char_typed_inner(file, position.offset, char_typed)?;
+    let text_edit = on_char_typed_inner(file, position.offset, char_typed)?;
-    Some(single_file_change.into_source_change(position.file_id))
+    Some(SourceChange::source_file_edit_from(position.file_id, text_edit))
 }
-fn on_char_typed_inner(
+fn on_char_typed_inner(file: &SourceFile, offset: TextSize, char_typed: char) -> Option<TextEdit> {
-    file: &SourceFile,
-    offset: TextSize,
-    char_typed: char,
-) -> Option<SingleFileChange> {
    assert!(TRIGGER_CHARS.contains(char_typed));
    match char_typed {
        '.' => on_dot_typed(file, offset),
@@ -61,7 +57,7 @@ fn on_char_typed_inner(
 /// Returns an edit which should be applied after `=` was typed. Primarily,
 /// this works when adding `let =`.
 // FIXME: use a snippet completion instead of this hack here.
-fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange> {
+fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
    assert_eq!(file.syntax().text().char_at(offset), Some('='));
    let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
    if let_stmt.semicolon_token().is_some() {
@@ -79,15 +75,11 @@ fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange>
        return None;
    }
    let offset = let_stmt.syntax().text_range().end();
-    Some(SingleFileChange {
+    Some(TextEdit::insert(offset, ";".to_string()))
-        label: "add semicolon".to_string(),
-        edit: TextEdit::insert(offset, ";".to_string()),
-        cursor_position: None,
-    })
 }
 /// Returns an edit which should be applied when a dot ('.') is typed on a blank line, indenting the line appropriately.
-fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange> {
+fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
    assert_eq!(file.syntax().text().char_at(offset), Some('.'));
    let whitespace =
        file.syntax().token_at_offset(offset).left_biased().and_then(ast::Whitespace::cast)?;
@@ -108,15 +100,11 @@ fn on_dot_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange>
        return None;
    }
-    Some(SingleFileChange {
+    Some(TextEdit::replace(TextRange::new(offset - current_indent_len, offset), target_indent))
-        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('.')),
-    })
 }
 /// Adds a space after an arrow when `fn foo() { ... }` is turned into `fn foo() -> { ... }`
-fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChange> {
+fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
    let file_text = file.syntax().text();
    assert_eq!(file_text.char_at(offset), Some('>'));
    let after_arrow = offset + TextSize::of('>');
@@ -127,11 +115,7 @@ fn on_arrow_typed(file: &SourceFile, offset: TextSize) -> Option<SingleFileChang
        return None;
    }
-    Some(SingleFileChange {
+    Some(TextEdit::insert(after_arrow, " ".to_string()))
-        label: "add space after return type".to_string(),
-        edit: TextEdit::insert(after_arrow, " ".to_string()),
-        cursor_position: Some(after_arrow),
-    })
 }
 #[cfg(test)]
@@ -140,29 +124,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 mut before = before.to_string();
        edit.apply(&mut before);
        let parse = SourceFile::parse(&before);
        on_char_typed_inner(&parse.tree(), offset, char_typed).map(|it| {
-            it.edit.apply(&mut before);
+            it.apply(&mut before);
-            (before.to_string(), it)
+            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) {
@@ -350,6 +328,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 78a40cc94..e7d64b4f6 100644
--- a/crates/ra_ide/src/typing/on_enter.rs
+++ b/crates/ra_ide/src/typing/on_enter.rs
@@ -38,17 +38,12 @@ 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::from(SourceFileEdit { edit, file_id: position.file_id });
-        SourceChange::source_file_edit(
+    res.is_snippet = true;
-            "On enter",
+    Some(res)
-            SourceFileEdit { edit, file_id: position.file_id },
-        )
-        .with_cursor(FilePosition { offset: cursor_position, file_id: position.file_id }),
-    )
 }
 fn followed_by_comment(comment: &ast::Comment) -> bool {
@@ -84,7 +79,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;
@@ -98,7 +93,6 @@ mod tests {
        assert_eq!(result.source_file_edits.len(), 1);
        let mut actual = before.to_string();
        result.source_file_edits[0].edit.apply(&mut actual);
-        let actual = add_cursor(&actual, result.cursor_position.unwrap().offset);
        Some(actual)
    }
@@ -121,7 +115,7 @@ fn foo() {
 ",
            r"
 /// Some docs
-/// <|>
+/// $0
 fn foo() {
 }
 ",
@@ -137,7 +131,7 @@ impl S {
            r"
 impl S {
    /// Some
-    /// <|> docs.
+    /// $0 docs.
    fn foo() {}
 }
 ",
@@ -151,7 +145,7 @@ fn foo() {
 ",
            r"
 ///
-/// <|> Some docs
+/// $0 Some docs
 fn foo() {
 }
 ",
@@ -175,7 +169,7 @@ fn main() {
            r"
 fn main() {
    // Fix
-    // <|> me
+    // $0 me
    let x = 1 + 1;
 }
 ",
@@ -195,7 +189,7 @@ fn main() {
            r"
 fn main() {
    // Fix
-    // <|>
+    // $0
    // me
    let x = 1 + 1;
 }