72 files changed, 1194 insertions, 1158 deletions

diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 770049212..ab20c6649 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -86,11 +86,7 @@ mod tests {
 
     #[test]
     fn add_explicit_type_works_for_simple_expr() {
-        check_assist(
-            add_explicit_type,
-            "fn f() { let a<|> = 1; }",
-            "fn f() { let a<|>: i32 = 1; }",
-        );
+        check_assist(add_explicit_type, "fn f() { let a<|> = 1; }", "fn f() { let a: i32 = 1; }");
     }
 
     #[test]
@@ -98,7 +94,7 @@ mod tests {
         check_assist(
             add_explicit_type,
             "fn f() { let a<|>: _ = 1; }",
-            "fn f() { let a<|>: i32 = 1; }",
+            "fn f() { let a: i32 = 1; }",
         );
     }
 
@@ -122,7 +118,7 @@ mod tests {
             }
 
             fn f() {
-                let a<|>: Option<i32> = Option::Some(1);
+                let a: Option<i32> = Option::Some(1);
             }"#,
         );
     }
@@ -132,7 +128,7 @@ mod tests {
         check_assist(
             add_explicit_type,
             r"macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
-            r"macro_rules! v { () => {0u64} } fn f() { let a<|>: u64 = v!(); }",
+            r"macro_rules! v { () => {0u64} } fn f() { let a: u64 = v!(); }",
         );
     }
 
@@ -140,8 +136,8 @@ mod tests {
     fn add_explicit_type_works_for_macro_call_recursive() {
         check_assist(
             add_explicit_type,
-            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }",
-            "macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|>: u64 = v!(); }",
+            r#"macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }"#,
+            r#"macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a: u64 = v!(); }"#,
         );
     }
 
@@ -208,7 +204,7 @@ struct Test<K, T = u8> {
 }
 
 fn main() {
-    let test<|>: Test<i32> = Test { t: 23, k: 33 };
+    let test: Test<i32> = Test { t: 23, k: 33 };
 }"#,
         );
     }
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
index eb57b7231..6a675e812 100644
--- a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -1,6 +1,6 @@
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, AstNode, NameOwner};
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{utils::FamousDefs, AssistContext, AssistId, Assists};
 
@@ -39,7 +39,7 @@ pub(crate) fn add_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext) ->
     };
 
     if existing_from_impl(&ctx.sema, &variant).is_some() {
-        tested_by!(test_add_from_impl_already_exists);
+        mark::hit!(test_add_from_impl_already_exists);
         return None;
     }
 
@@ -90,7 +90,7 @@ fn existing_from_impl(
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::tests::{check_assist, check_assist_not_applicable};
 
@@ -101,7 +101,7 @@ mod tests {
         check_assist(
             add_from_impl_for_enum,
             "enum A { <|>One(u32) }",
-            r#"enum A { <|>One(u32) }
+            r#"enum A { One(u32) }
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
@@ -116,7 +116,7 @@ impl From<u32> for A {
         check_assist(
             add_from_impl_for_enum,
             r#"enum A { <|>One(foo::bar::baz::Boo) }"#,
-            r#"enum A { <|>One(foo::bar::baz::Boo) }
+            r#"enum A { One(foo::bar::baz::Boo) }
 
 impl From<foo::bar::baz::Boo> for A {
     fn from(v: foo::bar::baz::Boo) -> Self {
@@ -149,7 +149,7 @@ impl From<foo::bar::baz::Boo> for A {
 
     #[test]
     fn test_add_from_impl_already_exists() {
-        covers!(test_add_from_impl_already_exists);
+        mark::check!(test_add_from_impl_already_exists);
         check_not_applicable(
             r#"
 enum A { <|>One(u32), }
@@ -178,7 +178,7 @@ impl From<String> for A {
 pub trait From<T> {
     fn from(T) -> Self;
 }"#,
-            r#"enum A { <|>One(u32), Two(String), }
+            r#"enum A { One(u32), Two(String), }
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index fe7451dcf..837aa8377 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
     ast::{
         self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
     },
-    TextSize, T,
+    T,
 };
 use stdx::{format_to, SepBy};
 
@@ -25,7 +25,7 @@ use crate::{AssistContext, AssistId, Assists};
 // }
 //
 // impl<T: Clone> Ctx<T> {
-//     fn new(data: T) -> Self { Self { data } }
+//     fn $0new(data: T) -> Self { Self { data } }
 // }
 //
 // ```
@@ -42,31 +42,26 @@ pub(crate) fn add_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let impl_def = find_struct_impl(&ctx, &strukt)?;
 
     let target = strukt.syntax().text_range();
-    acc.add(AssistId("add_new"), "Add default constructor", target, |edit| {
+    acc.add(AssistId("add_new"), "Add default constructor", target, |builder| {
         let mut buf = String::with_capacity(512);
 
         if impl_def.is_some() {
             buf.push('\n');
         }
 
-        let vis = strukt.visibility().map(|v| format!("{} ", v));
-        let vis = vis.as_deref().unwrap_or("");
+        let vis = strukt.visibility().map_or(String::new(), |v| format!("{} ", v));
 
         let params = field_list
             .fields()
             .filter_map(|f| {
-                Some(format!(
-                    "{}: {}",
-                    f.name()?.syntax().text(),
-                    f.ascribed_type()?.syntax().text()
-                ))
+                Some(format!("{}: {}", f.name()?.syntax(), f.ascribed_type()?.syntax()))
             })
             .sep_by(", ");
         let fields = field_list.fields().filter_map(|f| f.name()).sep_by(", ");
 
         format_to!(buf, "    {}fn new({}) -> Self {{ Self {{ {} }} }}", vis, params, fields);
 
-        let (start_offset, end_offset) = impl_def
+        let start_offset = impl_def
             .and_then(|impl_def| {
                 buf.push('\n');
                 let start = impl_def
@@ -76,17 +71,20 @@ pub(crate) fn add_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
                     .text_range()
                     .end();
 
-                Some((start, TextSize::of("\n")))
+                Some(start)
             })
             .unwrap_or_else(|| {
                 buf = generate_impl_text(&strukt, &buf);
-                let start = strukt.syntax().text_range().end();
-
-                (start, TextSize::of("\n}\n"))
+                strukt.syntax().text_range().end()
             });
 
-        edit.set_cursor(start_offset + TextSize::of(&buf) - end_offset);
-        edit.insert(start_offset, buf);
+        match ctx.config.snippet_cap {
+            None => builder.insert(start_offset, buf),
+            Some(cap) => {
+                buf = buf.replace("fn new", "fn $0new");
+                builder.insert_snippet(cap, start_offset, buf);
+            }
+        }
     })
 }
 
@@ -191,7 +189,7 @@ mod tests {
 "struct Foo {}
 
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -201,7 +199,7 @@ impl Foo {
 "struct Foo<T: Clone> {}
 
 impl<T: Clone> Foo<T> {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -211,7 +209,7 @@ impl<T: Clone> Foo<T> {
 "struct Foo<'a, T: Foo<'a>> {}
 
 impl<'a, T: Foo<'a>> Foo<'a, T> {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -221,7 +219,7 @@ impl<'a, T: Foo<'a>> Foo<'a, T> {
 "struct Foo { baz: String }
 
 impl Foo {
-    fn new(baz: String) -> Self { Self { baz } }<|>
+    fn $0new(baz: String) -> Self { Self { baz } }
 }
 ",
         );
@@ -231,7 +229,7 @@ impl Foo {
 "struct Foo { baz: String, qux: Vec<i32> }
 
 impl Foo {
-    fn new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }<|>
+    fn $0new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }
 }
 ",
         );
@@ -243,7 +241,7 @@ impl Foo {
 "struct Foo { pub baz: String, pub qux: Vec<i32> }
 
 impl Foo {
-    fn new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }<|>
+    fn $0new(baz: String, qux: Vec<i32>) -> Self { Self { baz, qux } }
 }
 ",
         );
@@ -258,7 +256,7 @@ impl Foo {}
 "struct Foo {}
 
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -273,7 +271,7 @@ impl Foo {
 "struct Foo {}
 
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 
     fn qux(&self) {}
 }
@@ -294,7 +292,7 @@ impl Foo {
 "struct Foo {}
 
 impl Foo {
-    fn new() -> Self { Self {  } }<|>
+    fn $0new() -> Self { Self {  } }
 
     fn qux(&self) {}
     fn baz() -> i32 {
@@ -311,7 +309,7 @@ impl Foo {
 "pub struct Foo {}
 
 impl Foo {
-    pub fn new() -> Self { Self {  } }<|>
+    pub fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -321,7 +319,7 @@ impl Foo {
 "pub(crate) struct Foo {}
 
 impl Foo {
-    pub(crate) fn new() -> Self { Self {  } }<|>
+    pub(crate) fn $0new() -> Self { Self {  } }
 }
 ",
         );
@@ -414,7 +412,7 @@ pub struct Source<T> {
 }
 
 impl<T> Source<T> {
-    pub fn new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }<|>
+    pub fn $0new(file_id: HirFileId, ast: T) -> Self { Self { file_id, ast } }
 
     pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
         Source { file_id: self.file_id, ast: f(self.ast) }
diff --git a/crates/ra_assists/src/handlers/add_turbo_fish.rs b/crates/ra_assists/src/handlers/add_turbo_fish.rs
index a0363bc78..26acf81f2 100644
--- a/crates/ra_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ra_assists/src/handlers/add_turbo_fish.rs
@@ -1,11 +1,11 @@
 use ra_ide_db::defs::{classify_name_ref, Definition, NameRefClass};
 use ra_syntax::{ast, AstNode, SyntaxKind, T};
+use test_utils::mark;
 
 use crate::{
     assist_context::{AssistContext, Assists},
     AssistId,
 };
-use test_utils::tested_by;
 
 // Assist: add_turbo_fish
 //
@@ -28,7 +28,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
     let ident = ctx.find_token_at_offset(SyntaxKind::IDENT)?;
     let next_token = ident.next_token()?;
     if next_token.kind() == T![::] {
-        tested_by!(add_turbo_fish_one_fish_is_enough);
+        mark::hit!(add_turbo_fish_one_fish_is_enough);
         return None;
     }
     let name_ref = ast::NameRef::cast(ident.parent())?;
@@ -42,7 +42,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
     };
     let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
     if generics.is_empty() {
-        tested_by!(add_turbo_fish_non_generic);
+        mark::hit!(add_turbo_fish_non_generic);
         return None;
     }
     acc.add(AssistId("add_turbo_fish"), "Add `::<>`", ident.text_range(), |builder| {
@@ -58,7 +58,7 @@ mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
-    use test_utils::covers;
+    use test_utils::mark;
 
     #[test]
     fn add_turbo_fish_function() {
@@ -106,7 +106,7 @@ fn main() {
 
     #[test]
     fn add_turbo_fish_one_fish_is_enough() {
-        covers!(add_turbo_fish_one_fish_is_enough);
+        mark::check!(add_turbo_fish_one_fish_is_enough);
         check_assist_not_applicable(
             add_turbo_fish,
             r#"
@@ -120,7 +120,7 @@ fn main() {
 
     #[test]
     fn add_turbo_fish_non_generic() {
-        covers!(add_turbo_fish_non_generic);
+        mark::check!(add_turbo_fish_non_generic);
         check_assist_not_applicable(
             add_turbo_fish,
             r#"
diff --git a/crates/ra_assists/src/handlers/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 0feba5e11..233e8fb8e 100644
--- a/crates/ra_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ra_assists/src/handlers/apply_demorgan.rs
@@ -63,22 +63,22 @@ mod tests {
 
     #[test]
     fn demorgan_turns_and_into_or() {
-        check_assist(apply_demorgan, "fn f() { !x &&<|> !x }", "fn f() { !(x ||<|> x) }")
+        check_assist(apply_demorgan, "fn f() { !x &&<|> !x }", "fn f() { !(x || x) }")
     }
 
     #[test]
     fn demorgan_turns_or_into_and() {
-        check_assist(apply_demorgan, "fn f() { !x ||<|> !x }", "fn f() { !(x &&<|> x) }")
+        check_assist(apply_demorgan, "fn f() { !x ||<|> !x }", "fn f() { !(x && x) }")
     }
 
     #[test]
     fn demorgan_removes_inequality() {
-        check_assist(apply_demorgan, "fn f() { x != x ||<|> !x }", "fn f() { !(x == x &&<|> x) }")
+        check_assist(apply_demorgan, "fn f() { x != x ||<|> !x }", "fn f() { !(x == x && x) }")
     }
 
     #[test]
     fn demorgan_general_case() {
-        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x &&<|> !x) }")
+        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x && !x) }")
     }
 
     #[test]
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 78d23150d..edf96d50e 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -50,7 +50,12 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
             format!("Import `{}`", &import),
             range,
             |builder| {
-                insert_use_statement(&auto_import_assets.syntax_under_caret, &import, ctx, builder);
+                insert_use_statement(
+                    &auto_import_assets.syntax_under_caret,
+                    &import,
+                    ctx,
+                    builder.text_edit_builder(),
+                );
             },
         );
     }
@@ -293,7 +298,7 @@ mod tests {
             }
             ",
             r"
-            <|>use PubMod::PubStruct;
+            use PubMod::PubStruct;
 
             PubStruct
 
@@ -324,7 +329,7 @@ mod tests {
             macro_rules! foo {
                 ($i:ident) => { fn foo(a: $i) {} }
             }
-            foo!(Pub<|>Struct);
+            foo!(PubStruct);
 
             pub mod PubMod {
                 pub struct PubStruct;
@@ -355,7 +360,7 @@ mod tests {
             use PubMod::{PubStruct2, PubStruct1};
 
             struct Test {
-                test: Pub<|>Struct2<u8>,
+                test: PubStruct2<u8>,
             }
 
             pub mod PubMod {
@@ -388,7 +393,7 @@ mod tests {
             r"
             use PubMod3::PubStruct;
 
-            PubSt<|>ruct
+            PubStruct
 
             pub mod PubMod1 {
                 pub struct PubStruct;
@@ -469,7 +474,7 @@ mod tests {
             r"
             use PubMod::test_function;
 
-            test_function<|>
+            test_function
 
             pub mod PubMod {
                 pub fn test_function() {};
@@ -496,7 +501,7 @@ mod tests {
             r"use crate_with_macro::foo;
 
 fn main() {
-    foo<|>
+    foo
 }
 ",
         );
@@ -582,7 +587,7 @@ fn main() {
             }
 
             fn main() {
-                TestStruct::test_function<|>
+                TestStruct::test_function
             }
             ",
         );
@@ -615,7 +620,7 @@ fn main() {
             }
 
             fn main() {
-                TestStruct::TEST_CONST<|>
+                TestStruct::TEST_CONST
             }
             ",
         );
@@ -654,7 +659,7 @@ fn main() {
             }
 
             fn main() {
-                test_mod::TestStruct::test_function<|>
+                test_mod::TestStruct::test_function
             }
             ",
         );
@@ -725,7 +730,7 @@ fn main() {
             }
 
             fn main() {
-                test_mod::TestStruct::TEST_CONST<|>
+                test_mod::TestStruct::TEST_CONST
             }
             ",
         );
@@ -798,7 +803,7 @@ fn main() {
 
             fn main() {
                 let test_struct = test_mod::TestStruct {};
-                test_struct.test_meth<|>od()
+                test_struct.test_method()
             }
             ",
         );
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index 5c907097e..c6baa0a57 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -1,8 +1,6 @@
 use ra_syntax::{
     ast::{self, BlockExpr, Expr, LoopBodyOwner},
-    AstNode,
-    SyntaxKind::{COMMENT, WHITESPACE},
-    SyntaxNode, TextSize,
+    AstNode, SyntaxNode,
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -16,39 +14,40 @@ use crate::{AssistContext, AssistId, Assists};
 // ```
 // ->
 // ```
-// fn foo() -> Result<i32, > { Ok(42i32) }
+// fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
 // ```
 pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let fn_def = ctx.find_node_at_offset::<ast::FnDef>();
-    let fn_def = &mut fn_def?;
-    let ret_type = &fn_def.ret_type()?.type_ref()?;
-    if ret_type.syntax().text().to_string().starts_with("Result<") {
+    let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
+    // FIXME: extend to lambdas as well
+    let fn_def = ret_type.syntax().parent().and_then(ast::FnDef::cast)?;
+
+    let type_ref = &ret_type.type_ref()?;
+    if type_ref.syntax().text().to_string().starts_with("Result<") {
         return None;
     }
 
     let block_expr = &fn_def.body()?;
-    let cursor_in_ret_type =
-        fn_def.ret_type()?.syntax().text_range().contains_range(ctx.frange.range);
-    if !cursor_in_ret_type {
-        return None;
-    }
 
     acc.add(
         AssistId("change_return_type_to_result"),
         "Change return type to Result",
-        ret_type.syntax().text_range(),
-        |edit| {
+        type_ref.syntax().text_range(),
+        |builder| {
             let mut tail_return_expr_collector = TailReturnCollector::new();
             tail_return_expr_collector.collect_jump_exprs(block_expr, false);
             tail_return_expr_collector.collect_tail_exprs(block_expr);
 
             for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap {
-                edit.replace_node_and_indent(&ret_expr_arg, format!("Ok({})", ret_expr_arg));
+                builder.replace_node_and_indent(&ret_expr_arg, format!("Ok({})", ret_expr_arg));
             }
-            edit.replace_node_and_indent(ret_type.syntax(), format!("Result<{}, >", ret_type));
 
-            if let Some(node_start) = result_insertion_offset(&ret_type) {
-                edit.set_cursor(node_start + TextSize::of(&format!("Result<{}, ", ret_type)));
+            match ctx.config.snippet_cap {
+                Some(cap) => {
+                    let snippet = format!("Result<{}, ${{0:_}}>", type_ref);
+                    builder.replace_snippet(cap, type_ref.syntax().text_range(), snippet)
+                }
+                None => builder
+                    .replace(type_ref.syntax().text_range(), format!("Result<{}, _>", type_ref)),
             }
         },
     )
@@ -250,17 +249,8 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
     }
 }
 
-fn result_insertion_offset(ret_type: &ast::TypeRef) -> Option<TextSize> {
-    let non_ws_child = ret_type
-        .syntax()
-        .children_with_tokens()
-        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
-    Some(non_ws_child.text_range().start())
-}
-
 #[cfg(test)]
 mod tests {
-
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
@@ -273,7 +263,7 @@ mod tests {
                 let test = "test";
                 return 42i32;
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 return Ok(42i32);
             }"#,
@@ -288,7 +278,7 @@ mod tests {
                 let test = "test";
                 return 42i32;
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 return Ok(42i32);
             }"#,
@@ -314,7 +304,7 @@ mod tests {
                 let test = "test";
                 return 42i32;
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 return Ok(42i32);
             }"#,
@@ -329,7 +319,7 @@ mod tests {
                 let test = "test";
                 42i32
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 Ok(42i32)
             }"#,
@@ -343,7 +333,7 @@ mod tests {
             r#"fn foo() -> i32<|> {
                 42i32
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 Ok(42i32)
             }"#,
         );
@@ -359,7 +349,7 @@ mod tests {
                     24i32
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 if true {
                     Ok(42i32)
                 } else {
@@ -384,7 +374,7 @@ mod tests {
                     24i32
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 if true {
                     if false {
                         Ok(1)
@@ -413,7 +403,7 @@ mod tests {
                     24i32.await
                 }
             }"#,
-            r#"async fn foo() -> Result<i32, <|>> {
+            r#"async fn foo() -> Result<i32, ${0:_}> {
                 if true {
                     if false {
                         Ok(1.await)
@@ -434,7 +424,7 @@ mod tests {
             r#"fn foo() -> [i32;<|> 3] {
                 [1, 2, 3]
             }"#,
-            r#"fn foo() -> Result<[i32; 3], <|>> {
+            r#"fn foo() -> Result<[i32; 3], ${0:_}> {
                 Ok([1, 2, 3])
             }"#,
         );
@@ -455,7 +445,7 @@ mod tests {
                     24 as i32
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 if true {
                     if false {
                         Ok(1 as i32)
@@ -480,7 +470,7 @@ mod tests {
                     _ => 24i32,
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = 5;
                 match my_var {
                     5 => Ok(42i32),
@@ -503,7 +493,7 @@ mod tests {
 
                 my_var
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = 5;
                 loop {
                     println!("test");
@@ -526,7 +516,7 @@ mod tests {
 
                 my_var
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = let x = loop {
                     break 1;
                 };
@@ -549,7 +539,7 @@ mod tests {
 
                 res
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = 5;
                 let res = match my_var {
                     5 => 42i32,
@@ -572,7 +562,7 @@ mod tests {
 
                 res
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = 5;
                 let res = if my_var == 5 {
                     42i32
@@ -608,7 +598,7 @@ mod tests {
                     },
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let my_var = 5;
                 match my_var {
                     5 => {
@@ -641,7 +631,7 @@ mod tests {
                 }
                 53i32
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 if test == "test" {
                     return Ok(24i32);
@@ -672,7 +662,7 @@ mod tests {
 
                 the_field
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 let true_closure = || {
                     return true;
                 };
@@ -711,7 +701,7 @@ mod tests {
 
                 t.unwrap_or_else(|| the_field)
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 let true_closure = || {
                     return true;
                 };
@@ -749,7 +739,7 @@ mod tests {
                     i += 1;
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 if test == "test" {
                     return Ok(24i32);
@@ -781,7 +771,7 @@ mod tests {
                     }
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 if test == "test" {
                     return Ok(24i32);
@@ -819,7 +809,7 @@ mod tests {
                     }
                 }
             }"#,
-            r#"fn foo() -> Result<i32, <|>> {
+            r#"fn foo() -> Result<i32, ${0:_}> {
                 let test = "test";
                 let other = 5;
                 if test == "test" {
@@ -860,7 +850,7 @@ mod tests {
 
                 the_field
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 if the_field < 5 {
                     let mut i = 0;
                     loop {
@@ -894,7 +884,7 @@ mod tests {
 
                 the_field
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 if the_field < 5 {
                     let mut i = 0;
 
@@ -923,7 +913,7 @@ mod tests {
 
                 the_field
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 if the_field < 5 {
                     let mut i = 0;
 
@@ -953,7 +943,7 @@ mod tests {
 
                 the_field
             }"#,
-            r#"fn foo(the_field: u32) -> Result<u32, <|>> {
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
                 if the_field < 5 {
                     let mut i = 0;
 
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index 40cf4b422..c21d75be0 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -5,14 +5,11 @@ use ra_syntax::{
         ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
         WHITESPACE,
     },
-    SyntaxNode, TextRange, TextSize, T,
+    SyntaxNode, TextSize, T,
 };
-
-use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{AssistContext, AssistId, Assists};
-use ra_db::FileId;
 
 // Assist: change_visibility
 //
@@ -30,8 +27,6 @@ pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Optio
         return change_vis(acc, vis);
     }
     add_vis(acc, ctx)
-        .or_else(|| add_vis_to_referenced_module_def(acc, ctx))
-        .or_else(|| add_vis_to_referenced_record_field(acc, ctx))
 }
 
 fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
@@ -55,7 +50,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     } else if let Some(field_name) = ctx.find_node_at_offset::<ast::Name>() {
         let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
         if field.name()? != field_name {
-            tested_by!(change_visibility_field_false_positive);
+            mark::hit!(change_visibility_field_false_positive);
             return None;
         }
         if field.visibility().is_some() {
@@ -73,147 +68,9 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 
     acc.add(AssistId("change_visibility"), "Change visibility to pub(crate)", target, |edit| {
         edit.insert(offset, "pub(crate) ");
-        edit.set_cursor(offset);
-    })
-}
-
-fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let path: ast::Path = ctx.find_node_at_offset()?;
-    let path_res = ctx.sema.resolve_path(&path)?;
-    let def = match path_res {
-        PathResolution::Def(def) => def,
-        _ => return None,
-    };
-
-    let current_module = ctx.sema.scope(&path.syntax()).module()?;
-    let target_module = def.module(ctx.db)?;
-
-    let vis = target_module.visibility_of(ctx.db, &def)?;
-    if vis.is_visible_from(ctx.db, current_module.into()) {
-        return None;
-    };
-
-    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
-
-    let missing_visibility =
-        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
-
-    let assist_label = match target_name {
-        None => format!("Change visibility to {}", missing_visibility),
-        Some(name) => format!("Change visibility of {} to {}", name, missing_visibility),
-    };
-
-    acc.add(AssistId("change_visibility"), assist_label, target, |edit| {
-        edit.set_file(target_file);
-        edit.insert(offset, format!("{} ", missing_visibility));
-        edit.set_cursor(offset);
-    })
-}
-
-fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
-    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
-
-    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
-    let visibility = record_field_def.visibility(ctx.db);
-    if visibility.is_visible_from(ctx.db, current_module.into()) {
-        return None;
-    }
-
-    let parent = record_field_def.parent_def(ctx.db);
-    let parent_name = parent.name(ctx.db);
-    let target_module = parent.module(ctx.db);
-
-    let in_file_source = record_field_def.source(ctx.db);
-    let (offset, target) = match in_file_source.value {
-        hir::FieldSource::Named(it) => {
-            let s = it.syntax();
-            (vis_offset(s), s.text_range())
-        }
-        hir::FieldSource::Pos(it) => {
-            let s = it.syntax();
-            (vis_offset(s), s.text_range())
-        }
-    };
-
-    let missing_visibility =
-        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
-    let target_file = in_file_source.file_id.original_file(ctx.db);
-
-    let target_name = record_field_def.name(ctx.db);
-    let assist_label =
-        format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
-
-    acc.add(AssistId("change_visibility"), assist_label, target, |edit| {
-        edit.set_file(target_file);
-        edit.insert(offset, format!("{} ", missing_visibility));
-        edit.set_cursor(offset)
     })
 }
 
-fn target_data_for_def(
-    db: &dyn HirDatabase,
-    def: hir::ModuleDef,
-) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
-    fn offset_target_and_file_id<S, Ast>(
-        db: &dyn HirDatabase,
-        x: S,
-    ) -> (TextSize, TextRange, FileId)
-    where
-        S: HasSource<Ast = Ast>,
-        Ast: AstNode,
-    {
-        let source = x.source(db);
-        let in_file_syntax = source.syntax();
-        let file_id = in_file_syntax.file_id;
-        let syntax = in_file_syntax.value;
-        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
-    }
-
-    let target_name;
-    let (offset, target, target_file) = match def {
-        hir::ModuleDef::Function(f) => {
-            target_name = Some(f.name(db));
-            offset_target_and_file_id(db, f)
-        }
-        hir::ModuleDef::Adt(adt) => {
-            target_name = Some(adt.name(db));
-            match adt {
-                hir::Adt::Struct(s) => offset_target_and_file_id(db, s),
-                hir::Adt::Union(u) => offset_target_and_file_id(db, u),
-                hir::Adt::Enum(e) => offset_target_and_file_id(db, e),
-            }
-        }
-        hir::ModuleDef::Const(c) => {
-            target_name = c.name(db);
-            offset_target_and_file_id(db, c)
-        }
-        hir::ModuleDef::Static(s) => {
-            target_name = s.name(db);
-            offset_target_and_file_id(db, s)
-        }
-        hir::ModuleDef::Trait(t) => {
-            target_name = Some(t.name(db));
-            offset_target_and_file_id(db, t)
-        }
-        hir::ModuleDef::TypeAlias(t) => {
-            target_name = Some(t.name(db));
-            offset_target_and_file_id(db, t)
-        }
-        hir::ModuleDef::Module(m) => {
-            target_name = m.name(db);
-            let in_file_source = m.declaration_source(db)?;
-            let file_id = in_file_source.file_id.original_file(db.upcast());
-            let syntax = in_file_source.value.syntax();
-            (vis_offset(syntax), syntax.text_range(), file_id)
-        }
-        // Enum variants can't be private, we can't modify builtin types
-        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
-    };
-
-    Some((offset, target, target_file, target_name))
-}
-
 fn vis_offset(node: &SyntaxNode) -> TextSize {
     node.children_with_tokens()
         .skip_while(|it| match it.kind() {
@@ -234,7 +91,6 @@ fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
             target,
             |edit| {
                 edit.replace(vis.syntax().text_range(), "pub(crate)");
-                edit.set_cursor(vis.syntax().text_range().start())
             },
         );
     }
@@ -246,7 +102,6 @@ fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
             target,
             |edit| {
                 edit.replace(vis.syntax().text_range(), "pub");
-                edit.set_cursor(vis.syntax().text_range().start());
             },
         );
     }
@@ -255,7 +110,7 @@ fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
@@ -263,17 +118,13 @@ mod tests {
 
     #[test]
     fn change_visibility_adds_pub_crate_to_items() {
-        check_assist(change_visibility, "<|>fn foo() {}", "<|>pub(crate) fn foo() {}");
-        check_assist(change_visibility, "f<|>n foo() {}", "<|>pub(crate) fn foo() {}");
-        check_assist(change_visibility, "<|>struct Foo {}", "<|>pub(crate) struct Foo {}");
-        check_assist(change_visibility, "<|>mod foo {}", "<|>pub(crate) mod foo {}");
-        check_assist(change_visibility, "<|>trait Foo {}", "<|>pub(crate) trait Foo {}");
-        check_assist(change_visibility, "m<|>od {}", "<|>pub(crate) mod {}");
-        check_assist(
-            change_visibility,
-            "unsafe f<|>n foo() {}",
-            "<|>pub(crate) unsafe fn foo() {}",
-        );
+        check_assist(change_visibility, "<|>fn foo() {}", "pub(crate) fn foo() {}");
+        check_assist(change_visibility, "f<|>n foo() {}", "pub(crate) fn foo() {}");
+        check_assist(change_visibility, "<|>struct Foo {}", "pub(crate) struct Foo {}");
+        check_assist(change_visibility, "<|>mod foo {}", "pub(crate) mod foo {}");
+        check_assist(change_visibility, "<|>trait Foo {}", "pub(crate) trait Foo {}");
+        check_assist(change_visibility, "m<|>od {}", "pub(crate) mod {}");
+        check_assist(change_visibility, "unsafe f<|>n foo() {}", "pub(crate) unsafe fn foo() {}");
     }
 
     #[test]
@@ -281,14 +132,14 @@ mod tests {
         check_assist(
             change_visibility,
             r"struct S { <|>field: u32 }",
-            r"struct S { <|>pub(crate) field: u32 }",
+            r"struct S { pub(crate) field: u32 }",
         );
-        check_assist(change_visibility, r"struct S ( <|>u32 )", r"struct S ( <|>pub(crate) u32 )");
+        check_assist(change_visibility, r"struct S ( <|>u32 )", r"struct S ( pub(crate) u32 )");
     }
 
     #[test]
     fn change_visibility_field_false_positive() {
-        covers!(change_visibility_field_false_positive);
+        mark::check!(change_visibility_field_false_positive);
         check_assist_not_applicable(
             change_visibility,
             r"struct S { field: [(); { let <|>x = ();}] }",
@@ -297,17 +148,17 @@ mod tests {
 
     #[test]
     fn change_visibility_pub_to_pub_crate() {
-        check_assist(change_visibility, "<|>pub fn foo() {}", "<|>pub(crate) fn foo() {}")
+        check_assist(change_visibility, "<|>pub fn foo() {}", "pub(crate) fn foo() {}")
     }
 
     #[test]
     fn change_visibility_pub_crate_to_pub() {
-        check_assist(change_visibility, "<|>pub(crate) fn foo() {}", "<|>pub fn foo() {}")
+        check_assist(change_visibility, "<|>pub(crate) fn foo() {}", "pub fn foo() {}")
     }
 
     #[test]
     fn change_visibility_const() {
-        check_assist(change_visibility, "<|>const FOO = 3u8;", "<|>pub(crate) const FOO = 3u8;");
+        check_assist(change_visibility, "<|>const FOO = 3u8;", "pub(crate) const FOO = 3u8;");
     }
 
     #[test]
@@ -328,199 +179,12 @@ mod tests {
             // comments
 
             #[derive(Debug)]
-            <|>pub(crate) struct Foo;
+            pub(crate) struct Foo;
             ",
         )
     }
 
     #[test]
-    fn change_visibility_of_fn_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { fn foo() {} }
-              fn main() { foo::foo<|>() } ",
-            r"mod foo { <|>pub(crate) fn foo() {} }
-              fn main() { foo::foo() } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub fn foo() {} }
-              fn main() { foo::foo<|>() } ",
-        )
-    }
-
-    #[test]
-    fn change_visibility_of_adt_in_submodule_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { struct Foo; }
-              fn main() { foo::Foo<|> } ",
-            r"mod foo { <|>pub(crate) struct Foo; }
-              fn main() { foo::Foo } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub struct Foo; }
-              fn main() { foo::Foo<|> } ",
-        );
-        check_assist(
-            change_visibility,
-            r"mod foo { enum Foo; }
-              fn main() { foo::Foo<|> } ",
-            r"mod foo { <|>pub(crate) enum Foo; }
-              fn main() { foo::Foo } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub enum Foo; }
-              fn main() { foo::Foo<|> } ",
-        );
-        check_assist(
-            change_visibility,
-            r"mod foo { union Foo; }
-              fn main() { foo::Foo<|> } ",
-            r"mod foo { <|>pub(crate) union Foo; }
-              fn main() { foo::Foo } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub union Foo; }
-              fn main() { foo::Foo<|> } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_adt_in_other_file_via_path() {
-        check_assist(
-            change_visibility,
-            r"
-              //- /main.rs
-              mod foo;
-              fn main() { foo::Foo<|> }
-
-              //- /foo.rs
-              struct Foo;
-              ",
-            r"<|>pub(crate) struct Foo;
-
-",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_struct_field_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { pub struct Foo { bar: (), } }
-              fn main() { foo::Foo { <|>bar: () }; } ",
-            r"mod foo { pub struct Foo { <|>pub(crate) bar: (), } }
-              fn main() { foo::Foo { bar: () }; } ",
-        );
-        check_assist(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { bar: () }
-              ",
-            r"pub struct Foo { <|>pub(crate) bar: () }
-
-",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub struct Foo { pub bar: (), } }
-              fn main() { foo::Foo { <|>bar: () }; } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { pub bar: () }
-              ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_enum_variant_field_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { pub enum Foo { Bar { bar: () } } }
-              fn main() { foo::Foo::Bar { <|>bar: () }; } ",
-            r"mod foo { pub enum Foo { Bar { <|>pub(crate) bar: () } } }
-              fn main() { foo::Foo::Bar { bar: () }; } ",
-        );
-        check_assist(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo::Bar { <|>bar: () }; }
-              //- /foo.rs
-              pub enum Foo { Bar { bar: () } }
-              ",
-            r"pub enum Foo { Bar { <|>pub(crate) bar: () } }
-
-",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub struct Foo { pub bar: (), } }
-              fn main() { foo::Foo { <|>bar: () }; } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub struct Foo { pub bar: () }
-              ",
-        );
-    }
-
-    #[test]
-    #[ignore]
-    // FIXME reenable this test when `Semantics::resolve_record_field` works with union fields
-    fn change_visibility_of_union_field_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { pub union Foo { bar: (), } }
-              fn main() { foo::Foo { <|>bar: () }; } ",
-            r"mod foo { pub union Foo { <|>pub(crate) bar: (), } }
-              fn main() { foo::Foo { bar: () }; } ",
-        );
-        check_assist(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub union Foo { bar: () }
-              ",
-            r"pub union Foo { <|>pub(crate) bar: () }
-
-",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub union Foo { pub bar: (), } }
-              fn main() { foo::Foo { <|>bar: () }; } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"//- /lib.rs
-              mod foo;
-              fn main() { foo::Foo { <|>bar: () }; }
-              //- /foo.rs
-              pub union Foo { pub bar: () }
-              ",
-        );
-    }
-
-    #[test]
     fn not_applicable_for_enum_variants() {
         check_assist_not_applicable(
             change_visibility,
@@ -530,182 +194,6 @@ mod tests {
     }
 
     #[test]
-    fn change_visibility_of_const_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { const FOO: () = (); }
-              fn main() { foo::FOO<|> } ",
-            r"mod foo { <|>pub(crate) const FOO: () = (); }
-              fn main() { foo::FOO } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub const FOO: () = (); }
-              fn main() { foo::FOO<|> } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_static_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { static FOO: () = (); }
-              fn main() { foo::FOO<|> } ",
-            r"mod foo { <|>pub(crate) static FOO: () = (); }
-              fn main() { foo::FOO } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub static FOO: () = (); }
-              fn main() { foo::FOO<|> } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_trait_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { trait Foo { fn foo(&self) {} } }
-              fn main() { let x: &dyn foo::<|>Foo; } ",
-            r"mod foo { <|>pub(crate) trait Foo { fn foo(&self) {} } }
-              fn main() { let x: &dyn foo::Foo; } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub trait Foo { fn foo(&self) {} } }
-              fn main() { let x: &dyn foo::Foo<|>; } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_type_alias_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { type Foo = (); }
-              fn main() { let x: foo::Foo<|>; } ",
-            r"mod foo { <|>pub(crate) type Foo = (); }
-              fn main() { let x: foo::Foo; } ",
-        );
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub type Foo = (); }
-              fn main() { let x: foo::Foo<|>; } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_module_via_path() {
-        check_assist(
-            change_visibility,
-            r"mod foo { mod bar { fn bar() {} } }
-              fn main() { foo::bar<|>::bar(); } ",
-            r"mod foo { <|>pub(crate) mod bar { fn bar() {} } }
-              fn main() { foo::bar::bar(); } ",
-        );
-
-        check_assist(
-            change_visibility,
-            r"
-            //- /main.rs
-            mod foo;
-            fn main() { foo::bar<|>::baz(); }
-
-            //- /foo.rs
-            mod bar {
-                pub fn baz() {}
-            }
-            ",
-            r"<|>pub(crate) mod bar {
-    pub fn baz() {}
-}
-
-",
-        );
-
-        check_assist_not_applicable(
-            change_visibility,
-            r"mod foo { pub mod bar { pub fn bar() {} } }
-              fn main() { foo::bar<|>::bar(); } ",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_inline_module_in_other_file_via_path() {
-        check_assist(
-            change_visibility,
-            r"
-            //- /main.rs
-            mod foo;
-            fn main() { foo::bar<|>::baz(); }
-
-            //- /foo.rs
-            mod bar;
-
-            //- /foo/bar.rs
-            pub fn baz() {}
-            }
-            ",
-            r"<|>pub(crate) mod bar;
-",
-        );
-    }
-
-    #[test]
-    fn change_visibility_of_module_declaration_in_other_file_via_path() {
-        check_assist(
-            change_visibility,
-            r"//- /main.rs
-              mod foo;
-              fn main() { foo::bar<|>>::baz(); }
-
-              //- /foo.rs
-              mod bar {
-                  pub fn baz() {}
-              }",
-            r"<|>pub(crate) mod bar {
-    pub fn baz() {}
-}
-",
-        );
-    }
-
-    #[test]
-    #[ignore]
-    // FIXME handle reexports properly
-    fn change_visibility_of_reexport() {
-        check_assist(
-            change_visibility,
-            r"
-            mod foo {
-                use bar::Baz;
-                mod bar { pub(super) struct Baz; }
-            }
-            foo::Baz<|>
-            ",
-            r"
-            mod foo {
-                <|>pub(crate) use bar::Baz;
-                mod bar { pub(super) struct Baz; }
-            }
-            foo::Baz
-            ",
-        )
-    }
-
-    #[test]
-    fn adds_pub_when_target_is_in_another_crate() {
-        check_assist(
-            change_visibility,
-            r"//- /main.rs crate:a deps:foo
-              foo::Bar<|>
-              //- /lib.rs crate:foo
-              struct Bar;",
-            r"<|>pub struct Bar;
-",
-        )
-    }
-
-    #[test]
     fn change_visibility_target() {
         check_assist_target(change_visibility, "<|>fn foo() {}", "fn");
         check_assist_target(change_visibility, "pub(crate)<|> fn foo() {}", "pub(crate)");
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 13c1e7e80..cc303285b 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -4,8 +4,12 @@ use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
+use test_utils::mark;
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{
+    utils::{render_snippet, Cursor, FamousDefs},
+    AssistContext, AssistId, Assists,
+};
 
 // Assist: fill_match_arms
 //
@@ -26,7 +30,7 @@ use crate::{AssistContext, AssistId, Assists};
 //
 // fn handle(action: Action) {
 //     match action {
-//         Action::Move { distance } => {}
+//         $0Action::Move { distance } => {}
 //         Action::Stop => {}
 //     }
 // }
@@ -49,12 +53,18 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
         let variants = enum_def.variants(ctx.db);
 
-        variants
+        let mut variants = variants
             .into_iter()
             .filter_map(|variant| build_pat(ctx.db, module, variant))
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
-            .collect()
+            .collect::<Vec<_>>();
+        if Some(enum_def) == FamousDefs(&ctx.sema, module.krate()).core_option_Option() {
+            // Match `Some` variant first.
+            mark::hit!(option_order);
+            variants.reverse()
+        }
+        variants
     } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
         // Partial fill not currently supported for tuple of enums.
         if !arms.is_empty() {
@@ -93,10 +103,23 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     }
 
     let target = match_expr.syntax().text_range();
-    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |edit| {
-        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
-        edit.set_cursor(expr.syntax().text_range().start());
-        edit.replace_ast(match_arm_list, new_arm_list);
+    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |builder| {
+        let new_arm_list = match_arm_list.remove_placeholder();
+        let n_old_arms = new_arm_list.arms().count();
+        let new_arm_list = new_arm_list.append_arms(missing_arms);
+        let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+        let old_range = match_arm_list.syntax().text_range();
+        match (first_new_arm, ctx.config.snippet_cap) {
+            (Some(first_new_arm), Some(cap)) => {
+                let snippet = render_snippet(
+                    cap,
+                    new_arm_list.syntax(),
+                    Cursor::Before(first_new_arm.syntax()),
+                );
+                builder.replace_snippet(cap, old_range, snippet);
+            }
+            _ => builder.replace(old_range, new_arm_list.to_string()),
+        }
     })
 }
 
@@ -167,7 +190,12 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+    use test_utils::mark;
+
+    use crate::{
+        tests::{check_assist, check_assist_not_applicable, check_assist_target},
+        utils::FamousDefs,
+    };
 
     use super::fill_match_arms;
 
@@ -214,12 +242,12 @@ mod tests {
             r#"
             enum A {
                 As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                 Cs(i32, Option<i32>),
             }
             fn main() {
                 match A::As<|> {
-                    A::Bs{x,y:Some(_)} => {}
+                    A::Bs { x, y: Some(_) } => {}
                     A::Cs(_, Some(_)) => {}
                 }
             }
@@ -227,14 +255,14 @@ mod tests {
             r#"
             enum A {
                 As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                 Cs(i32, Option<i32>),
             }
             fn main() {
-                match <|>A::As {
-                    A::Bs{x,y:Some(_)} => {}
+                match A::As {
+                    A::Bs { x, y: Some(_) } => {}
                     A::Cs(_, Some(_)) => {}
-                    A::As => {}
+                    $0A::As => {}
                 }
             }
             "#,
@@ -264,9 +292,9 @@ mod tests {
                 Cs(Option<i32>),
             }
             fn main() {
-                match <|>A::As {
+                match A::As {
                     A::Cs(_) | A::Bs => {}
-                    A::As => {}
+                    $0A::As => {}
                 }
             }
             "#,
@@ -310,11 +338,11 @@ mod tests {
                 Ys,
             }
             fn main() {
-                match <|>A::As {
+                match A::As {
                     A::Bs if 0 < 1 => {}
                     A::Ds(_value) => { let x = 1; }
                     A::Es(B::Xs) => (),
-                    A::As => {}
+                    $0A::As => {}
                     A::Cs => {}
                 }
             }
@@ -332,7 +360,7 @@ mod tests {
                 Bs,
                 Cs(String),
                 Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn main() {
@@ -346,13 +374,13 @@ mod tests {
                 Bs,
                 Cs(String),
                 Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn main() {
                 let a = A::As;
-                match <|>a {
-                    A::As => {}
+                match a {
+                    $0A::As => {}
                     A::Bs => {}
                     A::Cs(_) => {}
                     A::Ds(_, _) => {}
@@ -368,14 +396,8 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -384,20 +406,14 @@ mod tests {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
                 let b = B::One;
-                match <|>(a, b) {
-                    (A::One, B::One) => {}
+                match (a, b) {
+                    $0(A::One, B::One) => {}
                     (A::One, B::Two) => {}
                     (A::Two, B::One) => {}
                     (A::Two, B::Two) => {}
@@ -412,14 +428,8 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -428,20 +438,14 @@ mod tests {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
                 let b = B::One;
-                match <|>(&a, &b) {
-                    (A::One, B::One) => {}
+                match (&a, &b) {
+                    $0(A::One, B::One) => {}
                     (A::One, B::Two) => {}
                     (A::Two, B::One) => {}
                     (A::Two, B::Two) => {}
@@ -456,14 +460,8 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -481,14 +479,8 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -512,10 +504,7 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -531,9 +520,7 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-            }
+            enum A { As }
 
             fn foo(a: &A) {
                 match a<|> {
@@ -541,13 +528,11 @@ mod tests {
             }
             "#,
             r#"
-            enum A {
-                As,
-            }
+            enum A { As }
 
             fn foo(a: &A) {
-                match <|>a {
-                    A::As => {}
+                match a {
+                    $0A::As => {}
                 }
             }
             "#,
@@ -557,7 +542,7 @@ mod tests {
             fill_match_arms,
             r#"
             enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn foo(a: &mut A) {
@@ -567,12 +552,12 @@ mod tests {
             "#,
             r#"
             enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn foo(a: &mut A) {
-                match <|>a {
-                    A::Es { x, y } => {}
+                match a {
+                    $0A::Es { x, y } => {}
                 }
             }
             "#,
@@ -611,8 +596,8 @@ mod tests {
             enum E { X, Y }
 
             fn main() {
-                match <|>E::X {
-                    E::X => {}
+                match E::X {
+                    $0E::X => {}
                     E::Y => {}
                 }
             }
@@ -639,8 +624,8 @@ mod tests {
             use foo::E::X;
 
             fn main() {
-                match <|>X {
-                    X => {}
+                match X {
+                    $0X => {}
                     foo::E::Y => {}
                 }
             }
@@ -653,10 +638,7 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
                 match a {
                     // foo bar baz<|>
@@ -666,16 +648,13 @@ mod tests {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
-                match <|>a {
+                match a {
                     // foo bar baz
                     A::One => {}
                     // This is where the rest should be
-                    A::Two => {}
+                    $0A::Two => {}
                 }
             }
             "#,
@@ -687,10 +666,7 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
                 match a {
                     // foo bar baz<|>
@@ -698,14 +674,11 @@ mod tests {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
-                match <|>a {
+                match a {
                     // foo bar baz
-                    A::One => {}
+                    $0A::One => {}
                     A::Two => {}
                 }
             }
@@ -728,12 +701,37 @@ mod tests {
             r#"
             enum A { One, Two, }
             fn foo(a: A) {
-                match <|>a {
-                    A::One => {}
+                match a {
+                    $0A::One => {}
                     A::Two => {}
                 }
             }
             "#,
         );
     }
+
+    #[test]
+    fn option_order() {
+        mark::check!(option_order);
+        let before = r#"
+fn foo(opt: Option<i32>) {
+    match opt<|> {
+    }
+}"#;
+        let before =
+            &format!("//- main.rs crate:main deps:core\n{}{}", before, FamousDefs::FIXTURE);
+
+        check_assist(
+            fill_match_arms,
+            before,
+            r#"
+fn foo(opt: Option<i32>) {
+    match opt {
+        $0Some(_) => {}
+        None => {}
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
new file mode 100644
index 000000000..9ec42f568
--- /dev/null
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -0,0 +1,559 @@
+use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
+use ra_db::FileId;
+use ra_syntax::{
+    ast, AstNode,
+    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
+    SyntaxNode, TextRange, TextSize,
+};
+
+use crate::{AssistContext, AssistId, Assists};
+
+// FIXME: this really should be a fix for diagnostic, rather than an assist.
+
+// Assist: fix_visibility
+//
+// Makes inaccessible item public.
+//
+// ```
+// mod m {
+//     fn frobnicate() {}
+// }
+// fn main() {
+//     m::frobnicate<|>() {}
+// }
+// ```
+// ->
+// ```
+// mod m {
+//     $0pub(crate) fn frobnicate() {}
+// }
+// fn main() {
+//     m::frobnicate() {}
+// }
+// ```
+pub(crate) fn fix_visibility(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    add_vis_to_referenced_module_def(acc, ctx)
+        .or_else(|| add_vis_to_referenced_record_field(acc, ctx))
+}
+
+fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let path: ast::Path = ctx.find_node_at_offset()?;
+    let path_res = ctx.sema.resolve_path(&path)?;
+    let def = match path_res {
+        PathResolution::Def(def) => def,
+        _ => return None,
+    };
+
+    let current_module = ctx.sema.scope(&path.syntax()).module()?;
+    let target_module = def.module(ctx.db)?;
+
+    let vis = target_module.visibility_of(ctx.db, &def)?;
+    if vis.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    };
+
+    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
+
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+
+    let assist_label = match target_name {
+        None => format!("Change visibility to {}", missing_visibility),
+        Some(name) => format!("Change visibility of {} to {}", name, missing_visibility),
+    };
+
+    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+        builder.set_file(target_file);
+        match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            None => builder.insert(offset, format!("{} ", missing_visibility)),
+        }
+    })
+}
+
+fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
+    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
+
+    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
+    let visibility = record_field_def.visibility(ctx.db);
+    if visibility.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    }
+
+    let parent = record_field_def.parent_def(ctx.db);
+    let parent_name = parent.name(ctx.db);
+    let target_module = parent.module(ctx.db);
+
+    let in_file_source = record_field_def.source(ctx.db);
+    let (offset, target) = match in_file_source.value {
+        hir::FieldSource::Named(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+        hir::FieldSource::Pos(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+    };
+
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+    let target_file = in_file_source.file_id.original_file(ctx.db);
+
+    let target_name = record_field_def.name(ctx.db);
+    let assist_label =
+        format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
+
+    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+        builder.set_file(target_file);
+        match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            None => builder.insert(offset, format!("{} ", missing_visibility)),
+        }
+    })
+}
+
+fn target_data_for_def(
+    db: &dyn HirDatabase,
+    def: hir::ModuleDef,
+) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
+    fn offset_target_and_file_id<S, Ast>(
+        db: &dyn HirDatabase,
+        x: S,
+    ) -> (TextSize, TextRange, FileId)
+    where
+        S: HasSource<Ast = Ast>,
+        Ast: AstNode,
+    {
+        let source = x.source(db);
+        let in_file_syntax = source.syntax();
+        let file_id = in_file_syntax.file_id;
+        let syntax = in_file_syntax.value;
+        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
+    }
+
+    let target_name;
+    let (offset, target, target_file) = match def {
+        hir::ModuleDef::Function(f) => {
+            target_name = Some(f.name(db));
+            offset_target_and_file_id(db, f)
+        }
+        hir::ModuleDef::Adt(adt) => {
+            target_name = Some(adt.name(db));
+            match adt {
+                hir::Adt::Struct(s) => offset_target_and_file_id(db, s),
+                hir::Adt::Union(u) => offset_target_and_file_id(db, u),
+                hir::Adt::Enum(e) => offset_target_and_file_id(db, e),
+            }
+        }
+        hir::ModuleDef::Const(c) => {
+            target_name = c.name(db);
+            offset_target_and_file_id(db, c)
+        }
+        hir::ModuleDef::Static(s) => {
+            target_name = s.name(db);
+            offset_target_and_file_id(db, s)
+        }
+        hir::ModuleDef::Trait(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::TypeAlias(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::Module(m) => {
+            target_name = m.name(db);
+            let in_file_source = m.declaration_source(db)?;
+            let file_id = in_file_source.file_id.original_file(db.upcast());
+            let syntax = in_file_source.value.syntax();
+            (vis_offset(syntax), syntax.text_range(), file_id)
+        }
+        // Enum variants can't be private, we can't modify builtin types
+        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+    };
+
+    Some((offset, target, target_file, target_name))
+}
+
+fn vis_offset(node: &SyntaxNode) -> TextSize {
+    node.children_with_tokens()
+        .skip_while(|it| match it.kind() {
+            WHITESPACE | COMMENT | ATTR => true,
+            _ => false,
+        })
+        .next()
+        .map(|it| it.text_range().start())
+        .unwrap_or_else(|| node.text_range().start())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn fix_visibility_of_fn() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+            r"mod foo { $0pub(crate) fn foo() {} }
+              fn main() { foo::foo() } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+        )
+    }
+
+    #[test]
+    fn fix_visibility_of_adt_in_submodule() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { struct Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) struct Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"mod foo { enum Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) enum Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub enum Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"mod foo { union Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { $0pub(crate) union Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub union Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_adt_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"
+              //- /main.rs
+              mod foo;
+              fn main() { foo::Foo<|> }
+
+              //- /foo.rs
+              struct Foo;
+              ",
+            r"$0pub(crate) struct Foo;
+
+",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_struct_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub struct Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub struct Foo { $0pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { bar: () }
+              ",
+            r"pub struct Foo { $0pub(crate) bar: () }
+
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_enum_variant_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub enum Foo { Bar { bar: () } } }
+              fn main() { foo::Foo::Bar { <|>bar: () }; } ",
+            r"mod foo { pub enum Foo { Bar { $0pub(crate) bar: () } } }
+              fn main() { foo::Foo::Bar { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo::Bar { <|>bar: () }; }
+              //- /foo.rs
+              pub enum Foo { Bar { bar: () } }
+              ",
+            r"pub enum Foo { Bar { $0pub(crate) bar: () } }
+
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    #[ignore]
+    // FIXME reenable this test when `Semantics::resolve_record_field` works with union fields
+    fn fix_visibility_of_union_field() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { pub union Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub union Foo { $0pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { bar: () }
+              ",
+            r"pub union Foo { $0pub(crate) bar: () }
+
+",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub union Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_const() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { $0pub(crate) const FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_static() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { $0pub(crate) static FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_trait() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::<|>Foo; } ",
+            r"mod foo { $0pub(crate) trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo<|>; } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_type_alias() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+            r"mod foo { $0pub(crate) type Foo = (); }
+              fn main() { let x: foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_module() {
+        check_assist(
+            fix_visibility,
+            r"mod foo { mod bar { fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+            r"mod foo { $0pub(crate) mod bar { fn bar() {} } }
+              fn main() { foo::bar::bar(); } ",
+        );
+
+        check_assist(
+            fix_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+
+            //- /foo.rs
+            mod bar {
+                pub fn baz() {}
+            }
+            ",
+            r"$0pub(crate) mod bar {
+    pub fn baz() {}
+}
+
+",
+        );
+
+        check_assist_not_applicable(
+            fix_visibility,
+            r"mod foo { pub mod bar { pub fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_inline_module_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+
+            //- /foo.rs
+            mod bar;
+
+            //- /foo/bar.rs
+            pub fn baz() {}
+            }
+            ",
+            r"$0pub(crate) mod bar;
+",
+        );
+    }
+
+    #[test]
+    fn fix_visibility_of_module_declaration_in_other_file() {
+        check_assist(
+            fix_visibility,
+            r"//- /main.rs
+              mod foo;
+              fn main() { foo::bar<|>>::baz(); }
+
+              //- /foo.rs
+              mod bar {
+                  pub fn baz() {}
+              }",
+            r"$0pub(crate) mod bar {
+    pub fn baz() {}
+}
+",
+        );
+    }
+
+    #[test]
+    fn adds_pub_when_target_is_in_another_crate() {
+        check_assist(
+            fix_visibility,
+            r"//- /main.rs crate:a deps:foo
+              foo::Bar<|>
+              //- /lib.rs crate:foo
+              struct Bar;",
+            r"$0pub struct Bar;
+",
+        )
+    }
+
+    #[test]
+    #[ignore]
+    // FIXME handle reexports properly
+    fn fix_visibility_of_reexport() {
+        check_assist(
+            fix_visibility,
+            r"
+            mod foo {
+                use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz<|>
+            ",
+            r"
+            mod foo {
+                $0pub(crate) use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz
+            ",
+        )
+    }
+}
diff --git a/crates/ra_assists/src/handlers/flip_binexpr.rs b/crates/ra_assists/src/handlers/flip_binexpr.rs
index 692ba4895..573196576 100644
--- a/crates/ra_assists/src/handlers/flip_binexpr.rs
+++ b/crates/ra_assists/src/handlers/flip_binexpr.rs
@@ -85,17 +85,13 @@ mod tests {
         check_assist(
             flip_binexpr,
             "fn f() { let res = 1 ==<|> 2; }",
-            "fn f() { let res = 2 ==<|> 1; }",
+            "fn f() { let res = 2 == 1; }",
         )
     }
 
     #[test]
     fn flip_binexpr_works_for_gt() {
-        check_assist(
-            flip_binexpr,
-            "fn f() { let res = 1 ><|> 2; }",
-            "fn f() { let res = 2 <<|> 1; }",
-        )
+        check_assist(flip_binexpr, "fn f() { let res = 1 ><|> 2; }", "fn f() { let res = 2 < 1; }")
     }
 
     #[test]
@@ -103,7 +99,7 @@ mod tests {
         check_assist(
             flip_binexpr,
             "fn f() { let res = 1 <=<|> 2; }",
-            "fn f() { let res = 2 >=<|> 1; }",
+            "fn f() { let res = 2 >= 1; }",
         )
     }
 
@@ -112,7 +108,7 @@ mod tests {
         check_assist(
             flip_binexpr,
             "fn f() { let res = (1 + 1) ==<|> (2 + 2); }",
-            "fn f() { let res = (2 + 2) ==<|> (1 + 1); }",
+            "fn f() { let res = (2 + 2) == (1 + 1); }",
         )
     }
 
@@ -132,7 +128,7 @@ mod tests {
             fn dyn_eq(&self, other: &dyn Diagnostic) -> bool {
                 match other.downcast_ref::<Self>() {
                     None => false,
-                    Some(it) => self ==<|> it,
+                    Some(it) => self == it,
                 }
             }
             "#,
diff --git a/crates/ra_assists/src/handlers/flip_comma.rs b/crates/ra_assists/src/handlers/flip_comma.rs
index dfe2a7fed..a57a1c463 100644
--- a/crates/ra_assists/src/handlers/flip_comma.rs
+++ b/crates/ra_assists/src/handlers/flip_comma.rs
@@ -45,7 +45,7 @@ mod tests {
         check_assist(
             flip_comma,
             "fn foo(x: i32,<|> y: Result<(), ()>) {}",
-            "fn foo(y: Result<(), ()>,<|> x: i32) {}",
+            "fn foo(y: Result<(), ()>, x: i32) {}",
         )
     }
 
diff --git a/crates/ra_assists/src/handlers/flip_trait_bound.rs b/crates/ra_assists/src/handlers/flip_trait_bound.rs
index 8a08702ab..0115adc8b 100644
--- a/crates/ra_assists/src/handlers/flip_trait_bound.rs
+++ b/crates/ra_assists/src/handlers/flip_trait_bound.rs
@@ -60,7 +60,7 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "struct S<T> where T: A <|>+ B { }",
-            "struct S<T> where T: B <|>+ A { }",
+            "struct S<T> where T: B + A { }",
         )
     }
 
@@ -69,13 +69,13 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "impl X for S<T> where T: A +<|> B { }",
-            "impl X for S<T> where T: B +<|> A { }",
+            "impl X for S<T> where T: B + A { }",
         )
     }
 
     #[test]
     fn flip_trait_bound_works_for_fn() {
-        check_assist(flip_trait_bound, "fn f<T: A <|>+ B>(t: T) { }", "fn f<T: B <|>+ A>(t: T) { }")
+        check_assist(flip_trait_bound, "fn f<T: A <|>+ B>(t: T) { }", "fn f<T: B + A>(t: T) { }")
     }
 
     #[test]
@@ -83,7 +83,7 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "fn f<T>(t: T) where T: A +<|> B { }",
-            "fn f<T>(t: T) where T: B +<|> A { }",
+            "fn f<T>(t: T) where T: B + A { }",
         )
     }
 
@@ -92,7 +92,7 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "fn f<T>(t: T) where T: A <|>+ 'static { }",
-            "fn f<T>(t: T) where T: 'static <|>+ A { }",
+            "fn f<T>(t: T) where T: 'static + A { }",
         )
     }
 
@@ -101,7 +101,7 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "struct S<T> where T: A<T> <|>+ b_mod::B<T> + C<T> { }",
-            "struct S<T> where T: b_mod::B<T> <|>+ A<T> + C<T> { }",
+            "struct S<T> where T: b_mod::B<T> + A<T> + C<T> { }",
         )
     }
 
@@ -110,7 +110,7 @@ mod tests {
         check_assist(
             flip_trait_bound,
             "struct S<T> where T: A + B + C + D + E + F +<|> G + H + I + J { }",
-            "struct S<T> where T: A + B + C + D + E + G +<|> F + H + I + J { }",
+            "struct S<T> where T: A + B + C + D + E + G + F + H + I + J { }",
         )
     }
 }
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index 5b26814d3..46d675a4e 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
     ast::{self, AstNode, AstToken},
     TextRange,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     assist_context::{AssistContext, Assists},
@@ -33,11 +33,11 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
         _ => return None,
     };
     if bind_pat.mut_token().is_some() {
-        tested_by!(test_not_inline_mut_variable);
+        mark::hit!(test_not_inline_mut_variable);
         return None;
     }
     if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
-        tested_by!(not_applicable_outside_of_bind_pat);
+        mark::hit!(not_applicable_outside_of_bind_pat);
         return None;
     }
     let initializer_expr = let_stmt.initializer()?;
@@ -46,7 +46,7 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
     let def = Definition::Local(def);
     let refs = def.find_usages(ctx.db, None);
     if refs.is_empty() {
-        tested_by!(test_not_applicable_if_variable_unused);
+        mark::hit!(test_not_applicable_if_variable_unused);
         return None;
     };
 
@@ -122,7 +122,7 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::tests::{check_assist, check_assist_not_applicable};
 
@@ -330,7 +330,7 @@ fn foo() {
 
     #[test]
     fn test_not_inline_mut_variable() {
-        covers!(test_not_inline_mut_variable);
+        mark::check!(test_not_inline_mut_variable);
         check_assist_not_applicable(
             inline_local_variable,
             r"
@@ -663,7 +663,7 @@ fn foo() {
 
     #[test]
     fn test_not_applicable_if_variable_unused() {
-        covers!(test_not_applicable_if_variable_unused);
+        mark::check!(test_not_applicable_if_variable_unused);
         check_assist_not_applicable(
             inline_local_variable,
             r"
@@ -676,7 +676,7 @@ fn foo() {
 
     #[test]
     fn not_applicable_outside_of_bind_pat() {
-        covers!(not_applicable_outside_of_bind_pat);
+        mark::check!(not_applicable_outside_of_bind_pat);
         check_assist_not_applicable(
             inline_local_variable,
             r"
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index fdf3ada0d..56c610fed 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -7,7 +7,7 @@ use ra_syntax::{
     SyntaxNode, TextSize,
 };
 use stdx::format_to;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{AssistContext, AssistId, Assists};
 
@@ -33,7 +33,7 @@ pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Opti
     }
     let node = ctx.covering_element();
     if node.kind() == COMMENT {
-        tested_by!(introduce_var_in_comment_is_not_applicable);
+        mark::hit!(introduce_var_in_comment_is_not_applicable);
         return None;
     }
     let expr = node.ancestors().find_map(valid_target_expr)?;
@@ -61,7 +61,7 @@ pub(crate) fn introduce_variable(acc: &mut Assists, ctx: &AssistContext) -> Opti
             false
         };
         if is_full_stmt {
-            tested_by!(test_introduce_var_expr_stmt);
+            mark::hit!(test_introduce_var_expr_stmt);
             if full_stmt.unwrap().semicolon_token().is_none() {
                 buf.push_str(";");
             }
@@ -113,7 +113,7 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
     expr.syntax().ancestors().find_map(|node| {
         if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
             if expr.syntax() == &node {
-                tested_by!(test_introduce_var_last_expr);
+                mark::hit!(test_introduce_var_last_expr);
                 return Some((node, false));
             }
         }
@@ -134,7 +134,7 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::mark;
 
     use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
@@ -158,13 +158,13 @@ fn foo() {
 
     #[test]
     fn introduce_var_in_comment_is_not_applicable() {
-        covers!(introduce_var_in_comment_is_not_applicable);
+        mark::check!(introduce_var_in_comment_is_not_applicable);
         check_assist_not_applicable(introduce_variable, "fn main() { 1 + /* <|>comment<|> */ 1; }");
     }
 
     #[test]
     fn test_introduce_var_expr_stmt() {
-        covers!(test_introduce_var_expr_stmt);
+        mark::check!(test_introduce_var_expr_stmt);
         check_assist(
             introduce_variable,
             "
@@ -209,7 +209,7 @@ fn foo() {
 
     #[test]
     fn test_introduce_var_last_expr() {
-        covers!(test_introduce_var_last_expr);
+        mark::check!(test_introduce_var_last_expr);
         check_assist(
             introduce_variable,
             "
diff --git a/crates/ra_assists/src/handlers/invert_if.rs b/crates/ra_assists/src/handlers/invert_if.rs
index 527c7caef..59d278eb9 100644
--- a/crates/ra_assists/src/handlers/invert_if.rs
+++ b/crates/ra_assists/src/handlers/invert_if.rs
@@ -72,7 +72,7 @@ mod tests {
         check_assist(
             invert_if,
             "fn f() { i<|>f x != 3 { 1 } else { 3 + 2 } }",
-            "fn f() { i<|>f x == 3 { 3 + 2 } else { 1 } }",
+            "fn f() { if x == 3 { 3 + 2 } else { 1 } }",
         )
     }
 
@@ -81,7 +81,7 @@ mod tests {
         check_assist(
             invert_if,
             "fn f() { <|>if !cond { 3 * 2 } else { 1 } }",
-            "fn f() { <|>if cond { 1 } else { 3 * 2 } }",
+            "fn f() { if cond { 1 } else { 3 * 2 } }",
         )
     }
 
@@ -90,7 +90,7 @@ mod tests {
         check_assist(
             invert_if,
             "fn f() { i<|>f cond { 3 * 2 } else { 1 } }",
-            "fn f() { i<|>f !cond { 1 } else { 3 * 2 } }",
+            "fn f() { if !cond { 1 } else { 3 * 2 } }",
         )
     }
 
diff --git a/crates/ra_assists/src/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index a41aacfc3..be2a7eddc 100644
--- a/crates/ra_assists/src/handlers/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -99,7 +99,7 @@ mod tests {
             fn foo<T: u32, <|>F: FnOnce(T) -> T>() {}
             "#,
             r#"
-            fn foo<T, <|>F>() where T: u32, F: FnOnce(T) -> T {}
+            fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
             "#,
         );
     }
@@ -112,7 +112,7 @@ mod tests {
             impl<U: u32, <|>T> A<U, T> {}
             "#,
             r#"
-            impl<U, <|>T> A<U, T> where U: u32 {}
+            impl<U, T> A<U, T> where U: u32 {}
             "#,
         );
     }
@@ -125,7 +125,7 @@ mod tests {
             struct A<<|>T: Iterator<Item = u32>> {}
             "#,
             r#"
-            struct A<<|>T> where T: Iterator<Item = u32> {}
+            struct A<T> where T: Iterator<Item = u32> {}
             "#,
         );
     }
@@ -138,7 +138,7 @@ mod tests {
             struct Pair<<|>T: u32>(T, T);
             "#,
             r#"
-            struct Pair<<|>T>(T, T) where T: u32;
+            struct Pair<T>(T, T) where T: u32;
             "#,
         );
     }
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index c20ffe0b3..16002d2ac 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -164,7 +164,7 @@ mod test {
             "#,
             r##"
             fn f() {
-                let s = <|>r#"random
+                let s = r#"random
 string"#;
             }
             "##,
@@ -182,7 +182,7 @@ string"#;
             "#,
             r##"
             fn f() {
-                format!(<|>r#"x = {}"#, 92)
+                format!(r#"x = {}"#, 92)
             }
             "##,
         )
@@ -199,7 +199,7 @@ string"#;
             "###,
             r####"
             fn f() {
-                let s = <|>r#"#random##
+                let s = r#"#random##
 string"#;
             }
             "####,
@@ -217,7 +217,7 @@ string"#;
             "###,
             r####"
             fn f() {
-                let s = <|>r###"#random"##
+                let s = r###"#random"##
 string"###;
             }
             "####,
@@ -235,7 +235,7 @@ string"###;
             "#,
             r##"
             fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
             }
             "##,
         )
@@ -289,7 +289,7 @@ string"###;
             "#,
             r##"
             fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
             }
             "##,
         )
@@ -306,7 +306,7 @@ string"###;
             "##,
             r###"
             fn f() {
-                let s = <|>r##"random"string"##;
+                let s = r##"random"string"##;
             }
             "###,
         )
@@ -348,7 +348,7 @@ string"###;
             "##,
             r#"
             fn f() {
-                let s = <|>r"random string";
+                let s = r"random string";
             }
             "#,
         )
@@ -365,7 +365,7 @@ string"###;
             "##,
             r#"
             fn f() {
-                let s = <|>r"random\"str\"ing";
+                let s = r"random\"str\"ing";
             }
             "#,
         )
@@ -382,7 +382,7 @@ string"###;
             "###,
             r##"
             fn f() {
-                let s = <|>r#"random string"#;
+                let s = r#"random string"#;
             }
             "##,
         )
@@ -436,7 +436,7 @@ string"###;
             "##,
             r#"
             fn f() {
-                let s = <|>"random string";
+                let s = "random string";
             }
             "#,
         )
@@ -453,7 +453,7 @@ string"###;
             "##,
             r#"
             fn f() {
-                let s = <|>"random\"str\"ing";
+                let s = "random\"str\"ing";
             }
             "#,
         )
@@ -470,7 +470,7 @@ string"###;
             "###,
             r##"
             fn f() {
-                let s = <|>"random string";
+                let s = "random string";
             }
             "##,
         )
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index 757f6406e..30229edc2 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -140,7 +140,7 @@ mod tests {
         "#,
             r#"
         struct Foo {foo: i32, bar: i32};
-        const test: Foo = <|>Foo {foo: 1, bar: 0}
+        const test: Foo = Foo {foo: 1, bar: 0}
         "#,
         )
     }
@@ -164,7 +164,7 @@ mod tests {
 
         fn f(f: Foo) -> {
             match f {
-                <|>Foo { ref mut bar, baz: 0, .. } => (),
+                Foo { ref mut bar, baz: 0, .. } => (),
                 _ => ()
             }
         }
@@ -202,7 +202,7 @@ mod tests {
             impl Foo {
                 fn new() -> Foo {
                     let foo = String::new();
-                    <|>Foo {
+                    Foo {
                         foo,
                         bar: foo.clone(),
                         extra: "Extra field",
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 1a81d8a0e..0197a8cf0 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -39,7 +39,7 @@ pub(crate) fn replace_qualified_name_with_use(
         target,
         |builder| {
             let path_to_import = hir_path.mod_path().clone();
-            insert_use_statement(path.syntax(), &path_to_import, ctx, builder);
+            insert_use_statement(path.syntax(), &path_to_import, ctx, builder.text_edit_builder());
 
             if let Some(last) = path.segment() {
                 // Here we are assuming the assist will provide a correct use statement
@@ -89,7 +89,7 @@ std::fmt::Debug<|>
             "
 use std::fmt::Debug;
 
-Debug<|>
+Debug
     ",
         );
     }
@@ -106,7 +106,7 @@ fn main() {
             "
 use std::fmt::Debug;
 
-Debug<|>
+Debug
 
 fn main() {
 }
@@ -130,7 +130,7 @@ use std::fmt::Debug;
 fn main() {
 }
 
-Debug<|>
+Debug
     ",
         );
     }
@@ -145,7 +145,7 @@ std::fmt<|>::Debug
             "
 use std::fmt;
 
-fmt<|>::Debug
+fmt::Debug
     ",
         );
     }
@@ -164,7 +164,7 @@ impl std::fmt::Debug<|> for Foo {
 use stdx;
 use std::fmt::Debug;
 
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
     ",
         );
@@ -181,7 +181,7 @@ impl std::fmt::Debug<|> for Foo {
             "
 use std::fmt::Debug;
 
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
     ",
         );
@@ -198,7 +198,7 @@ impl Debug<|> for Foo {
             "
     use std::fmt::Debug;
 
-    impl Debug<|> for Foo {
+    impl Debug for Foo {
     }
     ",
         );
@@ -217,7 +217,7 @@ impl std::io<|> for Foo {
             "
 use std::{io, fmt};
 
-impl io<|> for Foo {
+impl io for Foo {
 }
     ",
         );
@@ -236,7 +236,7 @@ impl std::fmt::Debug<|> for Foo {
             "
 use std::fmt::{self, Debug, };
 
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
     ",
         );
@@ -255,7 +255,7 @@ impl std::fmt<|> for Foo {
             "
 use std::fmt::{self, Debug};
 
-impl fmt<|> for Foo {
+impl fmt for Foo {
 }
     ",
         );
@@ -274,7 +274,7 @@ impl std::fmt::nested<|> for Foo {
             "
 use std::fmt::{Debug, nested::{Display, self}};
 
-impl nested<|> for Foo {
+impl nested for Foo {
 }
 ",
         );
@@ -293,7 +293,7 @@ impl std::fmt::nested<|> for Foo {
             "
 use std::fmt::{Debug, nested::{self, Display}};
 
-impl nested<|> for Foo {
+impl nested for Foo {
 }
 ",
         );
@@ -312,7 +312,7 @@ impl std::fmt::nested::Debug<|> for Foo {
             "
 use std::fmt::{Debug, nested::{Display, Debug}};
 
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
 ",
         );
@@ -331,7 +331,7 @@ impl std::fmt::nested::Display<|> for Foo {
             "
 use std::fmt::{nested::Display, Debug};
 
-impl Display<|> for Foo {
+impl Display for Foo {
 }
 ",
         );
@@ -350,7 +350,7 @@ impl std::fmt::Display<|> for Foo {
             "
 use std::fmt::{Display, nested::Debug};
 
-impl Display<|> for Foo {
+impl Display for Foo {
 }
 ",
         );
@@ -374,7 +374,7 @@ use crate::{
     AssocItem,
 };
 
-fn foo() { lower<|>::trait_env() }
+fn foo() { lower::trait_env() }
 ",
         );
     }
@@ -392,7 +392,7 @@ impl foo::Debug<|> for Foo {
             "
 use std::fmt as foo;
 
-impl Debug<|> for Foo {
+impl Debug for Foo {
 }
 ",
         );
@@ -435,7 +435,7 @@ mod foo {
     mod bar {
         use std::fmt::Debug;
 
-        Debug<|>
+        Debug
     }
 }
     ",
@@ -458,7 +458,7 @@ fn main() {
 use std::fmt::Debug;
 
 fn main() {
-    Debug<|>
+    Debug
 }
     ",
         );
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index e52ec557e..b76182d79 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,8 +1,10 @@
-use crate::{AssistContext, AssistId, Assists};
-
-use ast::{ElseBranch, Expr, LoopBodyOwner};
 use ra_fmt::unwrap_trivial_block;
-use ra_syntax::{ast, match_ast, AstNode, TextRange, T};
+use ra_syntax::{
+    ast::{self, ElseBranch, Expr, LoopBodyOwner},
+    match_ast, AstNode, TextRange, T,
+};
+
+use crate::{AssistContext, AssistId, Assists};
 
 // Assist: unwrap_block
 //
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 339f24100..464bc03dd 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -12,7 +12,6 @@ macro_rules! eprintln {
 
 mod assist_config;
 mod assist_context;
-mod marks;
 #[cfg(test)]
 mod tests;
 pub mod utils;
@@ -117,6 +116,7 @@ mod handlers {
     mod change_visibility;
     mod early_return;
     mod fill_match_arms;
+    mod fix_visibility;
     mod flip_binexpr;
     mod flip_comma;
     mod flip_trait_bound;
@@ -155,6 +155,7 @@ mod handlers {
             change_visibility::change_visibility,
             early_return::convert_to_guarded_return,
             fill_match_arms::fill_match_arms,
+            fix_visibility::fix_visibility,
             flip_binexpr::flip_binexpr,
             flip_comma::flip_comma,
             flip_trait_bound::flip_trait_bound,
diff --git a/crates/ra_assists/src/marks.rs b/crates/ra_assists/src/marks.rs
deleted file mode 100644
index d579e627f..000000000
--- a/crates/ra_assists/src/marks.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks![
-    introduce_var_in_comment_is_not_applicable
-    test_introduce_var_expr_stmt
-    test_introduce_var_last_expr
-    not_applicable_outside_of_bind_pat
-    test_not_inline_mut_variable
-    test_not_applicable_if_variable_unused
-    change_visibility_field_false_positive
-    test_add_from_impl_already_exists
-    add_turbo_fish_one_fish_is_enough
-    add_turbo_fish_non_generic
-];
diff --git a/crates/ra_assists/src/tests.rs b/crates/ra_assists/src/tests.rs
index 9ba3da786..373a7f7cc 100644
--- a/crates/ra_assists/src/tests.rs
+++ b/crates/ra_assists/src/tests.rs
@@ -105,18 +105,9 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult) {
             change.edit.apply(&mut actual);
 
             if !source_change.is_snippet {
-                match source_change.cursor_position {
-                    None => {
-                        if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
-                            let off = change
-                                .edit
-                                .apply_to_offset(before_cursor_pos)
-                                .expect("cursor position is affected by the edit");
-                            actual = add_cursor(&actual, off)
-                        }
-                    }
-                    Some(off) => actual = add_cursor(&actual, off.offset),
-                };
+                if let Some(off) = source_change.cursor_position {
+                    actual = add_cursor(&actual, off.offset)
+                }
             }
             assert_eq_text!(after, &actual);
         }
diff --git a/crates/ra_assists/src/tests/generated.rs b/crates/ra_assists/src/tests/generated.rs
index 3808aded1..3e6654c17 100644
--- a/crates/ra_assists/src/tests/generated.rs
+++ b/crates/ra_assists/src/tests/generated.rs
@@ -204,7 +204,7 @@ struct Ctx<T: Clone> {
 }
 
 impl<T: Clone> Ctx<T> {
-    fn new(data: T) -> Self { Self { data } }
+    fn $0new(data: T) -> Self { Self { data } }
 }
 
 "#####,
@@ -276,7 +276,7 @@ fn doctest_change_return_type_to_result() {
 fn foo() -> i32<|> { 42i32 }
 "#####,
         r#####"
-fn foo() -> Result<i32, > { Ok(42i32) }
+fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
 "#####,
     )
 }
@@ -336,7 +336,7 @@ enum Action { Move { distance: u32 }, Stop }
 
 fn handle(action: Action) {
     match action {
-        Action::Move { distance } => {}
+        $0Action::Move { distance } => {}
         Action::Stop => {}
     }
 }
@@ -345,6 +345,29 @@ fn handle(action: Action) {
 }
 
 #[test]
+fn doctest_fix_visibility() {
+    check_doc_test(
+        "fix_visibility",
+        r#####"
+mod m {
+    fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate<|>() {}
+}
+"#####,
+        r#####"
+mod m {
+    $0pub(crate) fn frobnicate() {}
+}
+fn main() {
+    m::frobnicate() {}
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_flip_binexpr() {
     check_doc_test(
         "flip_binexpr",
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 9af27180b..0038a9764 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -3,7 +3,7 @@ pub(crate) mod insert_use;
 
 use std::{iter, ops};
 
-use hir::{Adt, Crate, Semantics, Trait, Type};
+use hir::{Adt, Crate, Enum, ScopeDef, Semantics, Trait, Type};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, make, NameOwner},
@@ -200,13 +200,19 @@ impl FamousDefs<'_, '_> {
     #[cfg(test)]
     pub(crate) const FIXTURE: &'static str = r#"
 //- /libcore.rs crate:core
-pub mod convert{
+pub mod convert {
     pub trait From<T> {
         fn from(T) -> Self;
     }
 }
 
-pub mod prelude { pub use crate::convert::From }
+pub mod option {
+    pub enum Option<T> { None, Some(T)}
+}
+
+pub mod prelude {
+    pub use crate::{convert::From, option::Option::{self, *}};
+}
 #[prelude_import]
 pub use prelude::*;
 "#;
@@ -215,7 +221,25 @@ pub use prelude::*;
         self.find_trait("core:convert:From")
     }
 
+    pub(crate) fn core_option_Option(&self) -> Option<Enum> {
+        self.find_enum("core:option:Option")
+    }
+
     fn find_trait(&self, path: &str) -> Option<Trait> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
+            _ => None,
+        }
+    }
+
+    fn find_enum(&self, path: &str) -> Option<Enum> {
+        match self.find_def(path)? {
+            hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
+            _ => None,
+        }
+    }
+
+    fn find_def(&self, path: &str) -> Option<ScopeDef> {
         let db = self.0.db;
         let mut path = path.split(':');
         let trait_ = path.next_back()?;
@@ -240,9 +264,6 @@ pub use prelude::*;
         }
         let def =
             module.scope(db, None).into_iter().find(|(name, _def)| &name.to_string() == trait_)?.1;
-        match def {
-            hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
-            _ => None,
-        }
+        Some(def)
     }
 }
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index 1214e3cd4..0ee43482f 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEditBuilder;
 
-use crate::assist_context::{AssistBuilder, AssistContext};
+use crate::assist_context::AssistContext;
 
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
@@ -21,7 +21,7 @@ pub(crate) fn insert_use_statement(
     position: &SyntaxNode,
     path_to_import: &ModPath,
     ctx: &AssistContext,
-    builder: &mut AssistBuilder,
+    builder: &mut TextEditBuilder,
 ) {
     let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
     let container = ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
@@ -33,7 +33,7 @@ pub(crate) fn insert_use_statement(
 
     if let Some(container) = container {
         let action = best_action_for_target(container, position.clone(), &target);
-        make_assist(&action, &target, builder.text_edit_builder());
+        make_assist(&action, &target, builder);
     }
 }
 
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index c69e0efea..e08d62dd6 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -15,7 +15,7 @@ use ra_syntax::{
     },
     AstNode, AstPtr,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     adt::StructKind,
@@ -226,7 +226,7 @@ impl ExprCollector<'_> {
                         None => self.collect_expr_opt(condition.expr()),
                         // if let -- desugar to match
                         Some(pat) => {
-                            tested_by!(infer_resolve_while_let);
+                            mark::hit!(infer_resolve_while_let);
                             let pat = self.collect_pat(pat);
                             let match_expr = self.collect_expr_opt(condition.expr());
                             let placeholder_pat = self.missing_pat();
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 86f953c80..09e92b74e 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -174,7 +174,7 @@ mod tests {
     use hir_expand::{name::AsName, InFile};
     use ra_db::{fixture::WithFixture, FileId, SourceDatabase};
     use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
-    use test_utils::{assert_eq_text, covers, extract_offset};
+    use test_utils::{assert_eq_text, extract_offset, mark};
 
     use crate::{db::DefDatabase, test_db::TestDB, FunctionId, ModuleDefId};
 
@@ -388,7 +388,7 @@ mod tests {
 
     #[test]
     fn while_let_desugaring() {
-        covers!(infer_resolve_while_let);
+        mark::check!(infer_resolve_while_let);
         do_check_local_name(
             r#"
 fn test() {
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 2eb12ec8f..68d3cde08 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -4,7 +4,7 @@ use std::sync::Arc;
 
 use hir_expand::name::{known, AsName, Name};
 use ra_prof::profile;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     db::DefDatabase,
@@ -164,17 +164,19 @@ fn find_path_inner(
 
 fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
     if old_path.starts_with_std() && new_path.can_start_with_std() {
-        tested_by!(prefer_std_paths);
         if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
             new_path
         } else {
+            mark::hit!(prefer_std_paths);
             old_path
         }
     } else if new_path.starts_with_std() && old_path.can_start_with_std() {
-        tested_by!(prefer_std_paths);
         if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
             old_path
         } else {
+            mark::hit!(prefer_std_paths);
             new_path
         }
     } else if new_path.len() < old_path.len() {
@@ -251,12 +253,14 @@ pub(crate) fn importable_locations_of_query(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::test_db::TestDB;
     use hir_expand::hygiene::Hygiene;
     use ra_db::fixture::WithFixture;
     use ra_syntax::ast::AstNode;
-    use test_utils::covers;
+    use test_utils::mark;
+
+    use crate::test_db::TestDB;
+
+    use super::*;
 
     /// `code` needs to contain a cursor marker; checks that `find_path` for the
     /// item the `path` refers to returns that same path when called from the
@@ -511,7 +515,7 @@ mod tests {
 
     #[test]
     fn prefer_std_paths_over_alloc() {
-        covers!(prefer_std_paths);
+        mark::check!(prefer_std_paths);
         let code = r#"
         //- /main.rs crate:main deps:alloc,std
         <|>
@@ -530,51 +534,50 @@ mod tests {
     }
 
     #[test]
-    fn prefer_alloc_paths_over_std() {
-        covers!(prefer_std_paths);
+    fn prefer_core_paths_over_std() {
+        mark::check!(prefer_no_std_paths);
         let code = r#"
-        //- /main.rs crate:main deps:alloc,std
+        //- /main.rs crate:main deps:core,std
         #![no_std]
 
         <|>
 
-        //- /std.rs crate:std deps:alloc
+        //- /std.rs crate:std deps:core
 
-        pub mod sync {
-            pub use alloc::sync::Arc;
+        pub mod fmt {
+            pub use core::fmt::Error;
         }
 
-        //- /zzz.rs crate:alloc
+        //- /zzz.rs crate:core
 
-        pub mod sync {
-            pub struct Arc;
+        pub mod fmt {
+            pub struct Error;
         }
         "#;
-        check_found_path(code, "alloc::sync::Arc");
+        check_found_path(code, "core::fmt::Error");
     }
 
     #[test]
-    fn prefer_core_paths_over_std() {
-        covers!(prefer_std_paths);
+    fn prefer_alloc_paths_over_std() {
         let code = r#"
-        //- /main.rs crate:main deps:core,std
+        //- /main.rs crate:main deps:alloc,std
         #![no_std]
 
         <|>
 
-        //- /std.rs crate:std deps:core
+        //- /std.rs crate:std deps:alloc
 
-        pub mod fmt {
-            pub use core::fmt::Error;
+        pub mod sync {
+            pub use alloc::sync::Arc;
         }
 
-        //- /zzz.rs crate:core
+        //- /zzz.rs crate:alloc
 
-        pub mod fmt {
-            pub struct Error;
+        pub mod sync {
+            pub struct Arc;
         }
         "#;
-        check_found_path(code, "core::fmt::Error");
+        check_found_path(code, "alloc::sync::Arc");
     }
 
     #[test]
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 518772e8a..5325a2760 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -46,8 +46,6 @@ pub mod find_path;
 
 #[cfg(test)]
 mod test_db;
-#[cfg(test)]
-mod marks;
 
 use std::hash::Hash;
 
diff --git a/crates/ra_hir_def/src/marks.rs b/crates/ra_hir_def/src/marks.rs
deleted file mode 100644
index daa49d5f1..000000000
--- a/crates/ra_hir_def/src/marks.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks!(
-    bogus_paths
-    name_res_works_for_broken_modules
-    can_import_enum_variant
-    glob_enum
-    glob_enum_group
-    glob_across_crates
-    std_prelude
-    macro_rules_from_other_crates_are_visible_with_macro_use
-    prelude_is_macro_use
-    macro_dollar_crate_self
-    macro_dollar_crate_other
-    infer_resolve_while_let
-    prefer_std_paths
-);
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index db994122a..353a31ad4 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -14,7 +14,7 @@ use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId, ProcMacroId};
 use ra_syntax::ast;
 use rustc_hash::FxHashMap;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     attr::Attrs,
@@ -302,7 +302,7 @@ impl DefCollector<'_> {
         );
 
         if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
-            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
+            mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
             self.import_all_macros_exported(current_module_id, m.krate);
         }
     }
@@ -412,10 +412,10 @@ impl DefCollector<'_> {
             match def.take_types() {
                 Some(ModuleDefId::ModuleId(m)) => {
                     if import.is_prelude {
-                        tested_by!(std_prelude);
+                        mark::hit!(std_prelude);
                         self.def_map.prelude = Some(m);
                     } else if m.krate != self.def_map.krate {
-                        tested_by!(glob_across_crates);
+                        mark::hit!(glob_across_crates);
                         // glob import from other crate => we can just import everything once
                         let item_map = self.db.crate_def_map(m.krate);
                         let scope = &item_map[m.local_id].scope;
@@ -461,7 +461,7 @@ impl DefCollector<'_> {
                     }
                 }
                 Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
-                    tested_by!(glob_enum);
+                    mark::hit!(glob_enum);
                     // glob import from enum => just import all the variants
 
                     // XXX: urgh, so this works by accident! Here, we look at
@@ -510,7 +510,7 @@ impl DefCollector<'_> {
 
                     self.update(module_id, &[(name, def)], vis);
                 }
-                None => tested_by!(bogus_paths),
+                None => mark::hit!(bogus_paths),
             }
         }
     }
@@ -683,7 +683,7 @@ impl ModCollector<'_, '_> {
         // Prelude module is always considered to be `#[macro_use]`.
         if let Some(prelude_module) = self.def_collector.def_map.prelude {
             if prelude_module.krate != self.def_collector.def_map.krate {
-                tested_by!(prelude_is_macro_use);
+                mark::hit!(prelude_is_macro_use);
                 self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
             }
         }
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 35a0a0c98..19692e70c 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -14,7 +14,7 @@ use std::iter::successors;
 
 use hir_expand::name::Name;
 use ra_db::Edition;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     db::DefDatabase,
@@ -108,7 +108,7 @@ impl CrateDefMap {
         let mut curr_per_ns: PerNs = match path.kind {
             PathKind::DollarCrate(krate) => {
                 if krate == self.krate {
-                    tested_by!(macro_dollar_crate_self);
+                    mark::hit!(macro_dollar_crate_self);
                     PerNs::types(
                         ModuleId { krate: self.krate, local_id: self.root }.into(),
                         Visibility::Public,
@@ -116,7 +116,7 @@ impl CrateDefMap {
                 } else {
                     let def_map = db.crate_def_map(krate);
                     let module = ModuleId { krate, local_id: def_map.root };
-                    tested_by!(macro_dollar_crate_other);
+                    mark::hit!(macro_dollar_crate_other);
                     PerNs::types(module.into(), Visibility::Public)
                 }
             }
@@ -221,7 +221,7 @@ impl CrateDefMap {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
                     // enum variant
-                    tested_by!(can_import_enum_variant);
+                    mark::hit!(can_import_enum_variant);
                     let enum_data = db.enum_data(e);
                     match enum_data.variant(&segment) {
                         Some(local_id) => {
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index f2716a295..4e628b14d 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -18,7 +18,7 @@ use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner, VisibilityOwner},
     AstNode,
 };
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     attr::Attrs,
@@ -346,7 +346,7 @@ impl RawItemsCollector {
             self.push_item(current_module, attrs, RawItemKind::Module(item));
             return;
         }
-        tested_by!(name_res_works_for_broken_modules);
+        mark::hit!(name_res_works_for_broken_modules);
     }
 
     fn add_use_item(&mut self, current_module: Option<Idx<ModuleData>>, use_item: ast::UseItem) {
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 1b66c1aac..05cd0297d 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -8,7 +8,7 @@ use std::sync::Arc;
 
 use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, SourceDatabase};
-use test_utils::covers;
+use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
@@ -132,7 +132,7 @@ fn crate_def_map_fn_mod_same_name() {
 
 #[test]
 fn bogus_paths() {
-    covers!(bogus_paths);
+    mark::check!(bogus_paths);
     let map = def_map(
         "
         //- /lib.rs
@@ -247,7 +247,7 @@ fn re_exports() {
 
 #[test]
 fn std_prelude() {
-    covers!(std_prelude);
+    mark::check!(std_prelude);
     let map = def_map(
         "
         //- /main.rs crate:main deps:test_crate
@@ -271,7 +271,7 @@ fn std_prelude() {
 
 #[test]
 fn can_import_enum_variant() {
-    covers!(can_import_enum_variant);
+    mark::check!(can_import_enum_variant);
     let map = def_map(
         "
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index ee8df3a26..2b12c0daa 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -152,7 +152,7 @@ fn glob_privacy_2() {
 
 #[test]
 fn glob_across_crates() {
-    covers!(glob_across_crates);
+    mark::check!(glob_across_crates);
     let map = def_map(
         r"
         //- /main.rs crate:main deps:test_crate
@@ -171,7 +171,6 @@ fn glob_across_crates() {
 
 #[test]
 fn glob_privacy_across_crates() {
-    covers!(glob_across_crates);
     let map = def_map(
         r"
         //- /main.rs crate:main deps:test_crate
@@ -191,7 +190,7 @@ fn glob_privacy_across_crates() {
 
 #[test]
 fn glob_enum() {
-    covers!(glob_enum);
+    mark::check!(glob_enum);
     let map = def_map(
         "
         //- /lib.rs
@@ -212,7 +211,7 @@ fn glob_enum() {
 
 #[test]
 fn glob_enum_group() {
-    covers!(glob_enum_group);
+    mark::check!(glob_enum_group);
     let map = def_map(
         r"
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
index 40289e3ca..84480d9f6 100644
--- a/crates/ra_hir_def/src/nameres/tests/macros.rs
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -212,7 +212,7 @@ fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
 
 #[test]
 fn macro_rules_from_other_crates_are_visible_with_macro_use() {
-    covers!(macro_rules_from_other_crates_are_visible_with_macro_use);
+    mark::check!(macro_rules_from_other_crates_are_visible_with_macro_use);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -262,7 +262,7 @@ fn macro_rules_from_other_crates_are_visible_with_macro_use() {
 
 #[test]
 fn prelude_is_macro_use() {
-    covers!(prelude_is_macro_use);
+    mark::check!(prelude_is_macro_use);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -544,8 +544,7 @@ fn path_qualified_macros() {
 
 #[test]
 fn macro_dollar_crate_is_correct_in_item() {
-    covers!(macro_dollar_crate_self);
-    covers!(macro_dollar_crate_other);
+    mark::check!(macro_dollar_crate_self);
     let map = def_map(
         "
         //- /main.rs crate:main deps:foo
@@ -603,7 +602,7 @@ fn macro_dollar_crate_is_correct_in_item() {
 
 #[test]
 fn macro_dollar_crate_is_correct_in_indirect_deps() {
-    covers!(macro_dollar_crate_other);
+    mark::check!(macro_dollar_crate_other);
     // From std
     let map = def_map(
         r#"
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index 37fcdfb8c..b43b294ca 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -2,7 +2,7 @@ use super::*;
 
 #[test]
 fn name_res_works_for_broken_modules() {
-    covers!(name_res_works_for_broken_modules);
+    mark::check!(name_res_works_for_broken_modules);
     let map = def_map(
         r"
         //- /lib.rs
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index 5b6854b0f..7cc655487 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -6,7 +6,7 @@ use std::iter;
 use either::Either;
 use hir_expand::{hygiene::Hygiene, name::AsName};
 use ra_syntax::ast::{self, NameOwner};
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::path::{ImportAlias, ModPath, PathKind};
 
@@ -54,7 +54,7 @@ pub(crate) fn lower_use_tree(
         // FIXME: report errors somewhere
         // We get here if we do
         } else if is_glob {
-            tested_by!(glob_enum_group);
+            mark::hit!(glob_enum_group);
             if let Some(prefix) = prefix {
                 cb(prefix, &tree, is_glob, None)
             }
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 149f65042..3e6e1e333 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -1946,6 +1946,23 @@ mod tests {
 
         check_no_diagnostic(content);
     }
+
+    #[test]
+    fn expr_diverges_missing_arm() {
+        let content = r"
+            enum Either {
+                A,
+                B,
+            }
+            fn test_fn() {
+                match loop {} {
+                    Either::A => (),
+                }
+            }
+        ";
+
+        check_no_diagnostic(content);
+    }
 }
 
 #[cfg(test)]
@@ -1998,26 +2015,6 @@ mod false_negatives {
     }
 
     #[test]
-    fn expr_diverges_missing_arm() {
-        let content = r"
-            enum Either {
-                A,
-                B,
-            }
-            fn test_fn() {
-                match loop {} {
-                    Either::A => (),
-                }
-            }
-        ";
-
-        // This is a false negative.
-        // Even though the match expression diverges, rustc fails
-        // to compile here since `Either::B` is missing.
-        check_no_diagnostic(content);
-    }
-
-    #[test]
     fn expr_loop_missing_arm() {
         let content = r"
             enum Either {
@@ -2035,7 +2032,7 @@ mod false_negatives {
         // We currently infer the type of `loop { break Foo::A }` to `!`, which
         // causes us to skip the diagnostic since `Either::A` doesn't type check
         // with `!`.
-        check_no_diagnostic(content);
+        check_diagnostic(content);
     }
 
     #[test]
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 2876cb141..957d6e0b5 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -218,6 +218,7 @@ struct InferenceContext<'a> {
 #[derive(Clone, Debug)]
 struct BreakableContext {
     pub may_break: bool,
+    pub break_ty: Ty,
 }
 
 impl<'a> InferenceContext<'a> {
diff --git a/crates/ra_hir_ty/src/infer/coerce.rs b/crates/ra_hir_ty/src/infer/coerce.rs
index 173ec59ed..2ee9adb16 100644
--- a/crates/ra_hir_ty/src/infer/coerce.rs
+++ b/crates/ra_hir_ty/src/infer/coerce.rs
@@ -5,7 +5,7 @@
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
 use hir_def::{lang_item::LangItemTarget, type_ref::Mutability};
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{autoderef, traits::Solution, Obligation, Substs, TraitRef, Ty, TypeCtor};
 
@@ -34,7 +34,7 @@ impl<'a> InferenceContext<'a> {
             ty1.clone()
         } else {
             if let (ty_app!(TypeCtor::FnDef(_)), ty_app!(TypeCtor::FnDef(_))) = (ty1, ty2) {
-                tested_by!(coerce_fn_reification);
+                mark::hit!(coerce_fn_reification);
                 // Special case: two function types. Try to coerce both to
                 // pointers to have a chance at getting a match. See
                 // https://github.com/rust-lang/rust/blob/7b805396bf46dce972692a6846ce2ad8481c5f85/src/librustc_typeck/check/coercion.rs#L877-L916
@@ -44,7 +44,7 @@ impl<'a> InferenceContext<'a> {
                 let ptr_ty2 = Ty::fn_ptr(sig2);
                 self.coerce_merge_branch(&ptr_ty1, &ptr_ty2)
             } else {
-                tested_by!(coerce_merge_fail_fallback);
+                mark::hit!(coerce_merge_fail_fallback);
                 // For incompatible types, we use the latter one as result
                 // to be better recovery for `if` without `else`.
                 ty2.clone()
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 0b67d216a..b28724f0e 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -93,22 +93,25 @@ impl<'a> InferenceContext<'a> {
                 Ty::Unknown
             }
             Expr::Loop { body } => {
-                self.breakables.push(BreakableContext { may_break: false });
+                self.breakables.push(BreakableContext {
+                    may_break: false,
+                    break_ty: self.table.new_type_var(),
+                });
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
 
                 let ctxt = self.breakables.pop().expect("breakable stack broken");
                 if ctxt.may_break {
                     self.diverges = Diverges::Maybe;
                 }
-                // FIXME handle break with value
+
                 if ctxt.may_break {
-                    Ty::unit()
+                    ctxt.break_ty
                 } else {
                     Ty::simple(TypeCtor::Never)
                 }
             }
             Expr::While { condition, body } => {
-                self.breakables.push(BreakableContext { may_break: false });
+                self.breakables.push(BreakableContext { may_break: false, break_ty: Ty::Unknown });
                 // while let is desugared to a match loop, so this is always simple while
                 self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
                 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
@@ -120,7 +123,7 @@ impl<'a> InferenceContext<'a> {
             Expr::For { iterable, body, pat } => {
                 let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
 
-                self.breakables.push(BreakableContext { may_break: false });
+                self.breakables.push(BreakableContext { may_break: false, break_ty: Ty::Unknown });
                 let pat_ty =
                     self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item());
 
@@ -229,17 +232,29 @@ impl<'a> InferenceContext<'a> {
             }
             Expr::Continue => Ty::simple(TypeCtor::Never),
             Expr::Break { expr } => {
-                if let Some(expr) = expr {
-                    // FIXME handle break with value
-                    self.infer_expr(*expr, &Expectation::none());
-                }
+                let val_ty = if let Some(expr) = expr {
+                    self.infer_expr(*expr, &Expectation::none())
+                } else {
+                    Ty::unit()
+                };
+
+                let last_ty = if let Some(ctxt) = self.breakables.last() {
+                    ctxt.break_ty.clone()
+                } else {
+                    Ty::Unknown
+                };
+
+                let merged_type = self.coerce_merge_branch(&last_ty, &val_ty);
+
                 if let Some(ctxt) = self.breakables.last_mut() {
+                    ctxt.break_ty = merged_type;
                     ctxt.may_break = true;
                 } else {
                     self.push_diagnostic(InferenceDiagnostic::BreakOutsideOfLoop {
                         expr: tgt_expr,
                     });
                 }
+
                 Ty::simple(TypeCtor::Never)
             }
             Expr::Return { expr } => {
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 54ec870df..4006f595d 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -10,7 +10,7 @@ use hir_def::{
     FieldId,
 };
 use hir_expand::name::Name;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use super::{BindingMode, Expectation, InferenceContext};
 use crate::{utils::variant_data, Substs, Ty, TypeCtor};
@@ -111,7 +111,7 @@ impl<'a> InferenceContext<'a> {
                 }
             }
         } else if let Pat::Ref { .. } = &body[pat] {
-            tested_by!(match_ergonomics_ref);
+            mark::hit!(match_ergonomics_ref);
             // When you encounter a `&pat` pattern, reset to Move.
             // This is so that `w` is by value: `let (_, &w) = &(1, &2);`
             default_bm = BindingMode::Move;
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index ab0bc8b70..269495ca0 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -4,7 +4,7 @@ use std::borrow::Cow;
 
 use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 
-use test_utils::tested_by;
+use test_utils::mark;
 
 use super::{InferenceContext, Obligation};
 use crate::{
@@ -313,7 +313,7 @@ impl InferenceTable {
         // more than once
         for i in 0..3 {
             if i > 0 {
-                tested_by!(type_var_resolves_to_int_var);
+                mark::hit!(type_var_resolves_to_int_var);
             }
             match &*ty {
                 Ty::Infer(tv) => {
@@ -342,7 +342,7 @@ impl InferenceTable {
             Ty::Infer(tv) => {
                 let inner = tv.to_inner();
                 if tv_stack.contains(&inner) {
-                    tested_by!(type_var_cycles_resolve_as_possible);
+                    mark::hit!(type_var_cycles_resolve_as_possible);
                     // recursive type
                     return tv.fallback_value();
                 }
@@ -369,7 +369,7 @@ impl InferenceTable {
             Ty::Infer(tv) => {
                 let inner = tv.to_inner();
                 if tv_stack.contains(&inner) {
-                    tested_by!(type_var_cycles_resolve_completely);
+                    mark::hit!(type_var_cycles_resolve_completely);
                     // recursive type
                     return tv.fallback_value();
                 }
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index daea02f88..c87ee06ce 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -42,7 +42,6 @@ pub mod expr;
 mod tests;
 #[cfg(test)]
 mod test_db;
-mod marks;
 mod _match;
 
 use std::ops::Deref;
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 9ad6dbe07..35ac86a46 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -812,7 +812,7 @@ impl TraitEnvironment {
                 // add `Self: Trait<T1, T2, ...>` to the environment in trait
                 // function default implementations (and hypothetical code
                 // inside consts or type aliases)
-                test_utils::tested_by!(trait_self_implements_self);
+                test_utils::mark::hit!(trait_self_implements_self);
                 let substs = Substs::type_params(db, trait_id);
                 let trait_ref = TraitRef { trait_: trait_id, substs };
                 let pred = GenericPredicate::Implemented(trait_ref);
diff --git a/crates/ra_hir_ty/src/marks.rs b/crates/ra_hir_ty/src/marks.rs
deleted file mode 100644
index a39740143..000000000
--- a/crates/ra_hir_ty/src/marks.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks!(
-    type_var_cycles_resolve_completely
-    type_var_cycles_resolve_as_possible
-    type_var_resolves_to_int_var
-    impl_self_type_match_without_receiver
-    match_ergonomics_ref
-    coerce_merge_fail_fallback
-    coerce_fn_reification
-    trait_self_implements_self
-);
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 0851e16a8..e19628fdf 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -469,7 +469,7 @@ fn iterate_inherent_methods<T>(
                 // already happens in `is_valid_candidate` above; if not, we
                 // check it here
                 if receiver_ty.is_none() && inherent_impl_substs(db, impl_def, self_ty).is_none() {
-                    test_utils::tested_by!(impl_self_type_match_without_receiver);
+                    test_utils::mark::hit!(impl_self_type_match_without_receiver);
                     continue;
                 }
                 if let Some(result) = callback(&self_ty.value, item) {
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 6dc4b2cd1..2cc4f4bf9 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -1,6 +1,6 @@
 use super::infer_with_mismatches;
 use insta::assert_snapshot;
-use test_utils::covers;
+use test_utils::mark;
 
 // Infer with some common definitions and impls.
 fn infer(source: &str) -> String {
@@ -339,7 +339,7 @@ fn test(i: i32) {
 
 #[test]
 fn coerce_merge_one_by_one1() {
-    covers!(coerce_merge_fail_fallback);
+    mark::check!(coerce_merge_fail_fallback);
 
     assert_snapshot!(
         infer(r#"
@@ -547,7 +547,7 @@ fn test() {
 
 #[test]
 fn coerce_fn_items_in_match_arms() {
-    covers!(coerce_fn_reification);
+    mark::check!(coerce_fn_reification);
     assert_snapshot!(
         infer_with_mismatches(r#"
 fn foo1(x: u32) -> isize { 1 }
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index 9c2c9e1d2..558a70022 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -984,7 +984,7 @@ fn test() { S2.into()<|>; }
 
 #[test]
 fn method_resolution_overloaded_method() {
-    test_utils::covers!(impl_self_type_match_without_receiver);
+    test_utils::mark::check!(impl_self_type_match_without_receiver);
     let t = type_at(
         r#"
 //- main.rs
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index d83ff5e0e..0c5f972a2 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -1,5 +1,5 @@
 use insta::assert_snapshot;
-use test_utils::covers;
+use test_utils::mark;
 
 use super::{infer, infer_with_mismatches};
 
@@ -197,7 +197,7 @@ fn test() {
 
 #[test]
 fn infer_pattern_match_ergonomics_ref() {
-    covers!(match_ergonomics_ref);
+    mark::check!(match_ergonomics_ref);
     assert_snapshot!(
         infer(r#"
 fn test() {
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index c2168222e..1f004bd63 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,9 +1,10 @@
 use insta::assert_snapshot;
-use test_utils::covers;
+use ra_db::fixture::WithFixture;
+use test_utils::mark;
 
-use super::infer;
 use crate::test_db::TestDB;
-use ra_db::fixture::WithFixture;
+
+use super::infer;
 
 #[test]
 fn bug_484() {
@@ -89,8 +90,8 @@ fn quux() {
 
 #[test]
 fn recursive_vars() {
-    covers!(type_var_cycles_resolve_completely);
-    covers!(type_var_cycles_resolve_as_possible);
+    mark::check!(type_var_cycles_resolve_completely);
+    mark::check!(type_var_cycles_resolve_as_possible);
     assert_snapshot!(
         infer(r#"
 fn test() {
@@ -112,8 +113,6 @@ fn test() {
 
 #[test]
 fn recursive_vars_2() {
-    covers!(type_var_cycles_resolve_completely);
-    covers!(type_var_cycles_resolve_as_possible);
     assert_snapshot!(
         infer(r#"
 fn test() {
@@ -170,7 +169,7 @@ fn write() {
 
 #[test]
 fn infer_std_crash_2() {
-    covers!(type_var_resolves_to_int_var);
+    mark::check!(type_var_resolves_to_int_var);
     // caused "equating two type variables, ...", taken from std
     assert_snapshot!(
         infer(r#"
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 72122c070..fd2208af2 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1860,3 +1860,66 @@ fn test() {
     "###
     );
 }
+
+#[test]
+fn infer_loop_break_with_val() {
+    assert_snapshot!(
+        infer(r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn test() {
+    let x = loop {
+        if false {
+            break None;
+        }
+
+        break Some(true);
+    };
+}
+"#),
+        @r###"
+    60..169 '{     ...  }; }': ()
+    70..71 'x': Option<bool>
+    74..166 'loop {...     }': Option<bool>
+    79..166 '{     ...     }': ()
+    89..133 'if fal...     }': ()
+    92..97 'false': bool
+    98..133 '{     ...     }': ()
+    112..122 'break None': !
+    118..122 'None': Option<bool>
+    143..159 'break ...(true)': !
+    149..153 'Some': Some<bool>(bool) -> Option<bool>
+    149..159 'Some(true)': Option<bool>
+    154..158 'true': bool
+    "###
+    );
+}
+
+#[test]
+fn infer_loop_break_without_val() {
+    assert_snapshot!(
+        infer(r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn test() {
+    let x = loop {
+        if false {
+            break;
+        }
+    };
+}
+"#),
+        @r###"
+    60..137 '{     ...  }; }': ()
+    70..71 'x': ()
+    74..134 'loop {...     }': ()
+    79..134 '{     ...     }': ()
+    89..128 'if fal...     }': ()
+    92..97 'false': bool
+    98..128 '{     ...     }': ()
+    112..117 'break': !
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index c49aacf98..34f4b9039 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,10 +1,11 @@
 use insta::assert_snapshot;
-
 use ra_db::fixture::WithFixture;
+use test_utils::mark;
 
-use super::{infer, infer_with_mismatches, type_at, type_at_pos};
 use crate::test_db::TestDB;
 
+use super::{infer, infer_with_mismatches, type_at, type_at_pos};
+
 #[test]
 fn infer_await() {
     let (db, pos) = TestDB::with_position(
@@ -301,7 +302,7 @@ fn test() {
 
 #[test]
 fn trait_default_method_self_bound_implements_trait() {
-    test_utils::covers!(trait_self_implements_self);
+    mark::check!(trait_self_implements_self);
     assert_snapshot!(
         infer(r#"
 trait Trait {
@@ -324,7 +325,6 @@ trait Trait {
 
 #[test]
 fn trait_default_method_self_bound_implements_super_trait() {
-    test_utils::covers!(trait_self_implements_self);
     assert_snapshot!(
         infer(r#"
 trait SuperTrait {
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/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index db7430454..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};
 
@@ -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());
     }
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/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 077cf9647..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::{
@@ -121,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))
@@ -176,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)
             }
         };
@@ -330,14 +330,14 @@ pub(crate) fn compute_score(
     // 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;
@@ -398,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))
@@ -457,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},
@@ -607,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"
@@ -992,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"
@@ -1115,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"
@@ -1181,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"
@@ -1271,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"
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/lib.rs b/crates/ra_ide/src/lib.rs
index 66125f2f5..83cb498f7 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -43,8 +43,6 @@ mod expand_macro;
 mod ssr;
 
 #[cfg(test)]
-mod marks;
-#[cfg(test)]
 mod test_utils;
 
 use std::sync::Arc;
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 074284b42..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;
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 68a53ad4b..62ec8d85d 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -9,7 +9,7 @@ use ra_syntax::{
 };
 use ra_text_edit::TextEdit;
 use std::convert::TryInto;
-use test_utils::tested_by;
+use test_utils::mark;
 
 use crate::{
     references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
@@ -57,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())
@@ -260,7 +260,7 @@ fn rename_reference(
 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,
@@ -492,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 {
@@ -522,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 {
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 60c11178e..8b06cbfc5 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -14,7 +14,6 @@ use ra_syntax::{
     ast::{self, AstNode},
     match_ast,
 };
-use test_utils::tested_by;
 
 use crate::RootDatabase;
 
@@ -118,7 +117,6 @@ fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Opti
     match_ast! {
         match parent {
             ast::Alias(it) => {
-                tested_by!(goto_def_for_use_alias; force);
                 let use_tree = it.syntax().parent().and_then(ast::UseTree::cast)?;
                 let path = use_tree.path()?;
                 let path_segment = path.segment()?;
@@ -203,6 +201,8 @@ impl NameRefClass {
     }
 }
 
+// Note: we don't have unit-tests for this rather important function.
+// It is primarily exercised via goto definition tests in `ra_ide`.
 pub fn classify_name_ref(
     sema: &Semantics<RootDatabase>,
     name_ref: &ast::NameRef,
@@ -212,22 +212,18 @@ pub fn classify_name_ref(
     let parent = name_ref.syntax().parent()?;
 
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
-        tested_by!(goto_def_for_methods; force);
         if let Some(func) = sema.resolve_method_call(&method_call) {
             return Some(NameRefClass::Definition(Definition::ModuleDef(func.into())));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
-        tested_by!(goto_def_for_fields; force);
         if let Some(field) = sema.resolve_field(&field_expr) {
             return Some(NameRefClass::Definition(Definition::Field(field)));
         }
     }
 
     if let Some(record_field) = ast::RecordField::for_field_name(name_ref) {
-        tested_by!(goto_def_for_record_fields; force);
-        tested_by!(goto_def_for_field_init_shorthand; force);
         if let Some((field, local)) = sema.resolve_record_field(&record_field) {
             let field = Definition::Field(field);
             let res = match local {
@@ -239,7 +235,6 @@ pub fn classify_name_ref(
     }
 
     if let Some(record_field_pat) = ast::RecordFieldPat::cast(parent.clone()) {
-        tested_by!(goto_def_for_record_field_pats; force);
         if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) {
             let field = Definition::Field(field);
             return Some(NameRefClass::Definition(field));
@@ -247,7 +242,6 @@ pub fn classify_name_ref(
     }
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
-        tested_by!(goto_def_for_macros; force);
         if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
             return Some(NameRefClass::Definition(Definition::Macro(macro_def)));
         }
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index 52fcd7b6f..4f37954bf 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -2,7 +2,6 @@
 //!
 //! It is mainly a `HirDatabase` for semantic analysis, plus a `SymbolsDatabase`, for fuzzy search.
 
-pub mod marks;
 pub mod line_index;
 pub mod line_index_utils;
 pub mod symbol_index;
diff --git a/crates/ra_ide_db/src/marks.rs b/crates/ra_ide_db/src/marks.rs
deleted file mode 100644
index 386fe605c..000000000
--- a/crates/ra_ide_db/src/marks.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! See test_utils/src/marks.rs
-
-test_utils::marks![
-    goto_def_for_macros
-    goto_def_for_use_alias
-    goto_def_for_methods
-    goto_def_for_fields
-    goto_def_for_record_fields
-    goto_def_for_field_init_shorthand
-    goto_def_for_record_field_pats
-    search_filters_by_range
-];
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index b464959fc..589f44771 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -12,7 +12,6 @@ use ra_db::{FileId, FileRange, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{ast, match_ast, AstNode, TextRange, TextSize};
 use rustc_hash::FxHashMap;
-use test_utils::tested_by;
 
 use crate::{
     defs::{classify_name_ref, Definition, NameRefClass},
@@ -209,7 +208,6 @@ impl Definition {
             for (idx, _) in text.match_indices(pat) {
                 let offset: TextSize = idx.try_into().unwrap();
                 if !search_range.contains_inclusive(offset) {
-                    tested_by!(search_filters_by_range; force);
                     continue;
                 }
 
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index b1e3c328f..be2cfbaa2 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -7,7 +7,7 @@
 //! * marks (see the eponymous module).
 
 #[macro_use]
-pub mod marks;
+pub mod mark;
 
 use std::{
     fs,
diff --git a/crates/test_utils/src/marks.rs b/crates/test_utils/src/mark.rs
index c3185e860..7c309a894 100644
--- a/crates/test_utils/src/marks.rs
+++ b/crates/test_utils/src/mark.rs
@@ -7,18 +7,18 @@
 //! ```
 //! #[test]
 //! fn test_foo() {
-//!     covers!(test_foo);
+//!     mark::check!(test_foo);
 //! }
 //! ```
 //!
 //! and in the code under test you write
 //!
 //! ```
-//! # use test_utils::tested_by;
+//! # use test_utils::mark;
 //! # fn some_condition() -> bool { true }
 //! fn foo() {
 //!     if some_condition() {
-//!         tested_by!(test_foo);
+//!         mark::hit!(test_foo);
 //!     }
 //! }
 //! ```
@@ -29,43 +29,31 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 #[macro_export]
-macro_rules! tested_by {
-    ($ident:ident; force) => {{
-        {
-            // sic! use call-site crate
-            crate::marks::$ident.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
-        }
-    }};
+macro_rules! _hit {
     ($ident:ident) => {{
         #[cfg(test)]
         {
-            // sic! use call-site crate
-            crate::marks::$ident.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            extern "C" {
+                #[no_mangle]
+                static $ident: std::sync::atomic::AtomicUsize;
+            }
+            unsafe {
+                $ident.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            }
         }
     }};
 }
+pub use _hit as hit;
 
 #[macro_export]
-macro_rules! covers {
-    // sic! use call-site crate
+macro_rules! _check {
     ($ident:ident) => {
-        $crate::covers!(crate::$ident)
-    };
-    ($krate:ident :: $ident:ident) => {
-        let _checker = $crate::marks::MarkChecker::new(&$krate::marks::$ident);
-    };
-}
-
-#[macro_export]
-macro_rules! marks {
-    ($($ident:ident)*) => {
-        $(
-        #[allow(bad_style)]
-        pub static $ident: std::sync::atomic::AtomicUsize =
-            std::sync::atomic::AtomicUsize::new(0);
-        )*
+        #[no_mangle]
+        static $ident: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+        let _checker = $crate::mark::MarkChecker::new(&$ident);
     };
 }
+pub use _check as check;
 
 pub struct MarkChecker {
     mark: &'static AtomicUsize,