12 files changed, 414 insertions, 90 deletions

diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index f6aaaeda4..107bd8432 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -10,6 +10,7 @@ edition = "2018"
 doctest = false
 
 [dependencies]
+cov-mark = "1.1"
 either = "1.5.3"
 indexmap = "1.4.0"
 itertools = "0.10.0"
@@ -26,7 +27,6 @@ text_edit = { path = "../text_edit", version = "0.0.0" }
 ide_db = { path = "../ide_db", version = "0.0.0" }
 cfg = { path = "../cfg", version = "0.0.0" }
 profile = { path = "../profile", version = "0.0.0" }
-test_utils = { path = "../test_utils", version = "0.0.0" }
 ide_assists = { path = "../ide_assists", version = "0.0.0" }
 ide_ssr = { path = "../ide_ssr", version = "0.0.0" }
 ide_completion = { path = "../ide_completion", version = "0.0.0" }
@@ -36,4 +36,5 @@ ide_completion = { path = "../ide_completion", version = "0.0.0" }
 hir = { path = "../hir", version = "0.0.0" }
 
 [dev-dependencies]
+test_utils = { path = "../test_utils" }
 expect-test = "1.1"
diff --git a/crates/ide/src/display/short_label.rs b/crates/ide/src/display/short_label.rs
index 84b8883de..2df9266b4 100644
--- a/crates/ide/src/display/short_label.rs
+++ b/crates/ide/src/display/short_label.rs
@@ -71,11 +71,7 @@ impl ShortLabel for ast::TypeAlias {
 
 impl ShortLabel for ast::Const {
     fn short_label(&self) -> Option<String> {
-        let mut new_buf = short_label_from_ty(self, self.ty(), "const ")?;
-        if let Some(expr) = self.body() {
-            format_to!(new_buf, " = {}", expr.syntax());
-        }
-        Some(new_buf)
+        short_label_from_ty(self, self.ty(), "const ")
     }
 }
 
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index a9454cfa3..ea45086ce 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,3 +1,4 @@
+use either::Either;
 use hir::{
     Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
     HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
@@ -11,7 +12,6 @@ use ide_db::{
 use itertools::Itertools;
 use stdx::format_to;
 use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
-use test_utils::mark;
 
 use crate::{
     display::{macro_label, ShortLabel, TryToNav},
@@ -193,8 +193,8 @@ fn runnable_action(
             ModuleDef::Function(func) => {
                 let src = func.source(sema.db)?;
                 if src.file_id != file_id.into() {
-                    mark::hit!(hover_macro_generated_struct_fn_doc_comment);
-                    mark::hit!(hover_macro_generated_struct_fn_doc_attr);
+                    cov_mark::hit!(hover_macro_generated_struct_fn_doc_comment);
+                    cov_mark::hit!(hover_macro_generated_struct_fn_doc_attr);
                     return None;
                 }
 
@@ -367,7 +367,7 @@ fn hover_for_definition(
                 .and_then(|fd| hover_for_builtin(fd, it))
                 .or_else(|| Some(Markup::fenced_block(&it.name()))),
         },
-        Definition::Local(it) => Some(Markup::fenced_block(&it.ty(db).display(db))),
+        Definition::Local(it) => hover_for_local(it, db),
         Definition::SelfType(impl_def) => {
             impl_def.target_ty(db).as_adt().and_then(|adt| match adt {
                 Adt::Struct(it) => from_def_source(db, it, mod_path),
@@ -406,6 +406,29 @@ fn hover_for_definition(
     }
 }
 
+fn hover_for_local(it: hir::Local, db: &RootDatabase) -> Option<Markup> {
+    let ty = it.ty(db);
+    let ty = ty.display(db);
+    let is_mut = if it.is_mut(db) { "mut " } else { "" };
+    let desc = match it.source(db).value {
+        Either::Left(ident) => {
+            let name = it.name(db).unwrap();
+            let let_kw = if ident
+                .syntax()
+                .parent()
+                .map_or(false, |p| p.kind() == LET_STMT || p.kind() == CONDITION)
+            {
+                "let "
+            } else {
+                ""
+            };
+            format!("{}{}{}: {}", let_kw, is_mut, name, ty)
+        }
+        Either::Right(_) => format!("{}self: {}", is_mut, ty),
+    };
+    hover_markup(None, Some(desc), None)
+}
+
 fn hover_for_keyword(
     sema: &Semantics<RootDatabase>,
     links_in_hover: bool,
@@ -575,7 +598,7 @@ fn main() {
                 *iter*
 
                 ```rust
-                Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>>
+                let mut iter: Iter<Scan<OtherStruct<OtherStruct<i32>>, |&mut u32, &u32, &mut u32| -> Option<u32>, u32>>
                 ```
             "#]],
         );
@@ -799,7 +822,7 @@ fn main() {
                 ```
 
                 ```rust
-                const foo: u32 = 123
+                const foo: u32
                 ```
             "#]],
         );
@@ -832,7 +855,7 @@ fn main() {
                 *zz*
 
                 ```rust
-                Test<i32, u8>
+                let zz: Test<i32, u8>
                 ```
             "#]],
         );
@@ -871,7 +894,7 @@ fn main() { let b$0ar = Some(12); }
                 *bar*
 
                 ```rust
-                Option<i32>
+                let bar: Option<i32>
                 ```
             "#]],
         );
@@ -939,7 +962,7 @@ fn main() {
                 *foo*
 
                 ```rust
-                i32
+                foo: i32
                 ```
             "#]],
         )
@@ -953,7 +976,7 @@ fn main() {
                 *foo*
 
                 ```rust
-                i32
+                foo: i32
                 ```
             "#]],
         )
@@ -967,7 +990,7 @@ fn main() {
                 *foo*
 
                 ```rust
-                i32
+                foo: i32
                 ```
             "#]],
         )
@@ -981,7 +1004,7 @@ fn main() {
                 *foo*
 
                 ```rust
-                i32
+                foo: i32
                 ```
             "#]],
         )
@@ -1001,7 +1024,7 @@ fn main() {
                 *_x*
 
                 ```rust
-                impl Deref<Target = u8> + DerefMut<Target = u8>
+                _x: impl Deref<Target = u8> + DerefMut<Target = u8>
                 ```
             "#]],
         )
@@ -1023,7 +1046,7 @@ fn main() { let foo_$0test = Thing::new(); }
                 *foo_test*
 
                 ```rust
-                Thing
+                let foo_test: Thing
                 ```
             "#]],
         )
@@ -1082,7 +1105,7 @@ fn main() {
                 ```
 
                 ```rust
-                const C: u32 = 1
+                const C: u32
                 ```
             "#]],
         )
@@ -1183,7 +1206,7 @@ fn y() {
                 *x*
 
                 ```rust
-                i32
+                let x: i32
                 ```
             "#]],
         )
@@ -1260,7 +1283,7 @@ fn foo(bar:u32) { let a = id!(ba$0r); }
                 *bar*
 
                 ```rust
-                u32
+                bar: u32
                 ```
             "#]],
         );
@@ -1278,7 +1301,7 @@ fn foo(bar:u32) { let a = id!(ba$0r); }
                 *bar*
 
                 ```rust
-                u32
+                bar: u32
                 ```
             "#]],
         );
@@ -2101,7 +2124,7 @@ pub fn fo$0o() {}
 
     #[test]
     fn test_hover_macro_generated_struct_fn_doc_comment() {
-        mark::check!(hover_macro_generated_struct_fn_doc_comment);
+        cov_mark::check!(hover_macro_generated_struct_fn_doc_comment);
 
         check(
             r#"
@@ -2139,7 +2162,7 @@ fn foo() { let bar = Bar; bar.fo$0o(); }
 
     #[test]
     fn test_hover_macro_generated_struct_fn_doc_attr() {
-        mark::check!(hover_macro_generated_struct_fn_doc_attr);
+        cov_mark::check!(hover_macro_generated_struct_fn_doc_attr);
 
         check(
             r#"
@@ -3303,7 +3326,7 @@ fn main() {
                 *f*
 
                 ```rust
-                &i32
+                f: &i32
                 ```
             "#]],
         );
@@ -3322,7 +3345,7 @@ impl Foo {
                 *self*
 
                 ```rust
-                &Foo
+                self: &Foo
                 ```
             "#]],
         );
@@ -3342,7 +3365,7 @@ impl Foo {
                 *self*
 
                 ```rust
-                Arc<Foo>
+                self: Arc<Foo>
                 ```
             "#]],
         );
@@ -3538,7 +3561,7 @@ fn foo() {
                 ```
 
                 ```rust
-                const FOO: usize = 3
+                const FOO: usize
                 ```
 
                 ---
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 7fcae13e0..20a920ddb 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -7,7 +7,7 @@ use syntax::{
     SyntaxKind::{self, USE_TREE, WHITESPACE},
     SyntaxNode, SyntaxToken, TextRange, TextSize, T,
 };
-use test_utils::mark;
+
 use text_edit::{TextEdit, TextEditBuilder};
 
 // Feature: Join Lines
@@ -60,7 +60,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextS
         let mut string_open_quote = false;
         if let Some(string) = ast::String::cast(token.clone()) {
             if let Some(range) = string.open_quote_text_range() {
-                mark::hit!(join_string_literal);
+                cov_mark::hit!(join_string_literal);
                 string_open_quote = range.end() == offset;
             }
         }
@@ -206,7 +206,7 @@ fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
 #[cfg(test)]
 mod tests {
     use syntax::SourceFile;
-    use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range, mark};
+    use test_utils::{add_cursor, assert_eq_text, extract_offset, extract_range};
 
     use super::*;
 
@@ -786,7 +786,7 @@ fn foo() {
 
     #[test]
     fn join_string_literal() {
-        mark::check!(join_string_literal);
+        cov_mark::check!(join_string_literal);
         check_join_lines(
             r#"
 fn main() {
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index b600178ee..0a493d2f3 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -41,6 +41,7 @@ mod parent_module;
 mod references;
 mod fn_references;
 mod runnables;
+mod ssr;
 mod status;
 mod syntax_highlighting;
 mod syntax_tree;
@@ -51,6 +52,7 @@ mod doc_links;
 use std::sync::Arc;
 
 use cfg::CfgOptions;
+
 use ide_db::base_db::{
     salsa::{self, ParallelDatabase},
     CheckCanceled, Env, FileLoader, FileSet, SourceDatabase, VfsPath,
@@ -85,7 +87,7 @@ pub use crate::{
 pub use hir::{Documentation, Semantics};
 pub use ide_assists::{Assist, AssistConfig, AssistId, AssistKind};
 pub use ide_completion::{
-    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
+    CompletionConfig, CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit,
     InsertTextFormat,
 };
 pub use ide_db::{
@@ -478,7 +480,6 @@ impl Analysis {
         position: FilePosition,
         full_import_path: &str,
         imported_name: String,
-        import_for_trait_assoc_item: bool,
     ) -> Cancelable<Vec<TextEdit>> {
         Ok(self
             .with_db(|db| {
@@ -488,7 +489,6 @@ impl Analysis {
                     position,
                     full_import_path,
                     imported_name,
-                    import_for_trait_assoc_item,
                 )
             })?
             .unwrap_or_default())
@@ -504,7 +504,11 @@ impl Analysis {
         resolve: bool,
         frange: FileRange,
     ) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| Assist::get(db, config, resolve, frange))
+        self.with_db(|db| {
+            let mut acc = Assist::get(db, config, resolve, frange);
+            ssr::add_ssr_assist(db, &mut acc, resolve, frange);
+            acc
+        })
     }
 
     /// Computes the set of diagnostics for the given file.
diff --git a/crates/ide/src/matching_brace.rs b/crates/ide/src/matching_brace.rs
index 1bfa1439d..000c412d9 100644
--- a/crates/ide/src/matching_brace.rs
+++ b/crates/ide/src/matching_brace.rs
@@ -2,7 +2,6 @@ use syntax::{
     ast::{self, AstNode},
     SourceFile, SyntaxKind, TextSize, T,
 };
-use test_utils::mark;
 
 // Feature: Matching Brace
 //
@@ -28,7 +27,7 @@ pub(crate) fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<Text
         .next()?;
     let parent = brace_token.parent();
     if brace_token.kind() == T![|] && !ast::ParamList::can_cast(parent.kind()) {
-        mark::hit!(pipes_not_braces);
+        cov_mark::hit!(pipes_not_braces);
         return None;
     }
     let matching_kind = BRACES[brace_idx ^ 1];
@@ -63,7 +62,7 @@ mod tests {
         do_check("fn main() { $0|x: i32| x * 2;}", "fn main() { |x: i32$0| x * 2;}");
 
         {
-            mark::check!(pipes_not_braces);
+            cov_mark::check!(pipes_not_braces);
             do_check(
                 "fn main() { match 92 { 1 | 2 |$0 3 => 92 } }",
                 "fn main() { match 92 { 1 | 2 |$0 3 => 92 } }",
diff --git a/crates/ide/src/parent_module.rs b/crates/ide/src/parent_module.rs
index ddbaf22b7..03d71b380 100644
--- a/crates/ide/src/parent_module.rs
+++ b/crates/ide/src/parent_module.rs
@@ -5,7 +5,6 @@ use syntax::{
     algo::find_node_at_offset,
     ast::{self, AstNode},
 };
-use test_utils::mark;
 
 use crate::NavigationTarget;
 
@@ -33,7 +32,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))
         {
-            mark::hit!(test_resolve_parent_module_on_module_decl);
+            cov_mark::hit!(test_resolve_parent_module_on_module_decl);
             module = m.syntax().ancestors().skip(1).find_map(ast::Module::cast);
         }
     }
@@ -64,7 +63,6 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
 #[cfg(test)]
 mod tests {
     use ide_db::base_db::FileRange;
-    use test_utils::mark;
 
     use crate::fixture;
 
@@ -92,7 +90,7 @@ $0// empty
 
     #[test]
     fn test_resolve_parent_module_on_module_decl() {
-        mark::check!(test_resolve_parent_module_on_module_decl);
+        cov_mark::check!(test_resolve_parent_module_on_module_decl);
         check(
             r#"
 //- /lib.rs
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 1919639a3..1e378279d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -14,14 +14,14 @@ use syntax::{
     ast::{self, NameOwner},
     lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
 };
-use test_utils::mark;
+
 use text_edit::TextEdit;
 
 use crate::{display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, SourceChange, TextRange};
 
 type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
-pub struct RenameError(pub(crate) String);
+pub struct RenameError(String);
 
 impl fmt::Display for RenameError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -47,16 +47,15 @@ pub(crate) fn prepare_rename(
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
-    let range = match &sema
+    let name_like = sema
         .find_node_at_offset_with_descend(&syntax, position.offset)
-        .ok_or_else(|| format_err!("No references found at position"))?
-    {
+        .ok_or_else(|| format_err!("No references found at position"))?;
+    let node = match &name_like {
         ast::NameLike::Name(it) => it.syntax(),
         ast::NameLike::NameRef(it) => it.syntax(),
         ast::NameLike::Lifetime(it) => it.syntax(),
-    }
-    .text_range();
-    Ok(RangeInfo::new(range, ()))
+    };
+    Ok(RangeInfo::new(sema.original_range(node).range, ()))
 }
 
 // Feature: Rename
@@ -94,6 +93,7 @@ pub(crate) fn rename_with_semantics(
     }
 }
 
+/// Called by the client when it is about to rename a file.
 pub(crate) fn will_rename_file(
     db: &RootDatabase,
     file_id: FileId,
@@ -226,34 +226,36 @@ fn rename_reference(
         | (IdentifierKind::Ident, _)
             if def_is_lbl_or_lt =>
         {
-            mark::hit!(rename_not_a_lifetime_ident_ref);
+            cov_mark::hit!(rename_not_a_lifetime_ident_ref);
             bail!("Invalid name `{}`: not a lifetime identifier", new_name)
         }
-        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => cov_mark::hit!(rename_lifetime),
         (IdentifierKind::Lifetime, _) => {
-            mark::hit!(rename_not_an_ident_ref);
+            cov_mark::hit!(rename_not_an_ident_ref);
             bail!("Invalid name `{}`: not an identifier", new_name)
         }
         (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
             // no-op
-            mark::hit!(rename_self_to_self);
+            cov_mark::hit!(rename_self_to_self);
             return Ok(SourceChange::default());
         }
         (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
-            mark::hit!(rename_self_to_param);
+            cov_mark::hit!(rename_self_to_param);
             return rename_self_to_param(sema, local, new_name, ident_kind);
         }
         (IdentifierKind::ToSelf, Definition::Local(local)) => {
-            mark::hit!(rename_to_self);
+            cov_mark::hit!(rename_to_self);
             return rename_to_self(sema, local);
         }
         (IdentifierKind::ToSelf, _) => bail!("Invalid name `{}`: not an identifier", new_name),
-        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
+        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => {
+            cov_mark::hit!(rename_ident)
+        }
     }
 
     let usages = def.usages(sema).all();
     if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
-        mark::hit!(rename_underscore_multiple);
+        cov_mark::hit!(rename_underscore_multiple);
         bail!("Cannot rename reference to `_` as it is being referenced multiple times");
     }
     let mut source_change = SourceChange::default();
@@ -444,7 +446,7 @@ fn source_edit_from_name_ref(
             (Some(field_name), Some(init)) => {
                 if field_name == *name_ref {
                     if init.text() == new_name {
-                        mark::hit!(test_rename_field_put_init_shorthand);
+                        cov_mark::hit!(test_rename_field_put_init_shorthand);
                         // same names, we can use a shorthand here instead.
                         // we do not want to erase attributes hence this range start
                         let s = field_name.syntax().text_range().start();
@@ -453,7 +455,7 @@ fn source_edit_from_name_ref(
                     }
                 } else if init == *name_ref {
                     if field_name.text() == new_name {
-                        mark::hit!(test_rename_local_put_init_shorthand);
+                        cov_mark::hit!(test_rename_local_put_init_shorthand);
                         // same names, we can use a shorthand here instead.
                         // we do not want to erase attributes hence this range start
                         let s = field_name.syntax().text_range().start();
@@ -467,12 +469,12 @@ fn source_edit_from_name_ref(
             // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
             // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
             (None, Some(_)) if matches!(def, Definition::Field(_)) => {
-                mark::hit!(test_rename_field_in_field_shorthand);
+                cov_mark::hit!(test_rename_field_in_field_shorthand);
                 let s = name_ref.syntax().text_range().start();
                 Some((TextRange::empty(s), format!("{}: ", new_name)))
             }
             (None, Some(_)) if matches!(def, Definition::Local(_)) => {
-                mark::hit!(test_rename_local_in_field_shorthand);
+                cov_mark::hit!(test_rename_local_in_field_shorthand);
                 let s = name_ref.syntax().text_range().end();
                 Some((TextRange::empty(s), format!(": {}", new_name)))
             }
@@ -486,7 +488,7 @@ fn source_edit_from_name_ref(
             (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
                 // field name is being renamed
                 if pat.name().map_or(false, |it| it.text() == new_name) {
-                    mark::hit!(test_rename_field_put_init_shorthand_pat);
+                    cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
                     // same names, we can use a shorthand here instead/
                     // we do not want to erase attributes hence this range start
                     let s = field_name.syntax().text_range().start();
@@ -538,11 +540,13 @@ fn source_edit_from_def(
 mod tests {
     use expect_test::{expect, Expect};
     use stdx::trim_indent;
-    use test_utils::{assert_eq_text, mark};
+    use test_utils::assert_eq_text;
     use text_edit::TextEdit;
 
     use crate::{fixture, FileId};
 
+    use super::{RangeInfo, RenameError};
+
     fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
         let ra_fixture_after = &trim_indent(ra_fixture_after);
         let (analysis, position) = fixture::position(ra_fixture_before);
@@ -588,6 +592,45 @@ mod tests {
         expect.assert_debug_eq(&source_change)
     }
 
+    fn check_prepare(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let result = analysis
+            .prepare_rename(position)
+            .unwrap_or_else(|err| panic!("PrepareRename was cancelled: {}", err));
+        match result {
+            Ok(RangeInfo { range, info: () }) => {
+                let source = analysis.file_text(position.file_id).unwrap();
+                expect.assert_eq(&format!("{:?}: {}", range, &source[range]))
+            }
+            Err(RenameError(err)) => expect.assert_eq(&err),
+        };
+    }
+
+    #[test]
+    fn test_prepare_rename_namelikes() {
+        check_prepare(r"fn name$0<'lifetime>() {}", expect![[r#"3..7: name"#]]);
+        check_prepare(r"fn name<'lifetime$0>() {}", expect![[r#"8..17: 'lifetime"#]]);
+        check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
+    }
+
+    #[test]
+    fn test_prepare_rename_in_macro() {
+        check_prepare(
+            r"macro_rules! foo {
+    ($ident:ident) => {
+        pub struct $ident;
+    }
+}
+foo!(Foo$0);",
+            expect![[r#"83..86: Foo"#]],
+        );
+    }
+
+    #[test]
+    fn test_prepare_rename_keyword() {
+        check_prepare(r"struct$0 Foo;", expect![[r#"No references found at position"#]]);
+    }
+
     #[test]
     fn test_rename_to_underscore() {
         check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
@@ -627,7 +670,7 @@ mod tests {
 
     #[test]
     fn test_rename_to_invalid_identifier_lifetime() {
-        mark::check!(rename_not_an_ident_ref);
+        cov_mark::check!(rename_not_an_ident_ref);
         check(
             "'foo",
             r#"fn main() { let i$0 = 1; }"#,
@@ -637,7 +680,7 @@ mod tests {
 
     #[test]
     fn test_rename_to_invalid_identifier_lifetime2() {
-        mark::check!(rename_not_a_lifetime_ident_ref);
+        cov_mark::check!(rename_not_a_lifetime_ident_ref);
         check(
             "foo",
             r#"fn main<'a>(_: &'a$0 ()) {}"#,
@@ -647,7 +690,7 @@ mod tests {
 
     #[test]
     fn test_rename_to_underscore_invalid() {
-        mark::check!(rename_underscore_multiple);
+        cov_mark::check!(rename_underscore_multiple);
         check(
             "_",
             r#"fn main(foo$0: ()) {foo;}"#,
@@ -666,7 +709,7 @@ mod tests {
 
     #[test]
     fn test_rename_for_local() {
-        mark::check!(rename_ident);
+        cov_mark::check!(rename_ident);
         check(
             "k",
             r#"
@@ -829,7 +872,7 @@ impl Foo {
 
     #[test]
     fn test_rename_field_in_field_shorthand() {
-        mark::check!(test_rename_field_in_field_shorthand);
+        cov_mark::check!(test_rename_field_in_field_shorthand);
         check(
             "j",
             r#"
@@ -855,7 +898,7 @@ impl Foo {
 
     #[test]
     fn test_rename_local_in_field_shorthand() {
-        mark::check!(test_rename_local_in_field_shorthand);
+        cov_mark::check!(test_rename_local_in_field_shorthand);
         check(
             "j",
             r#"
@@ -1261,7 +1304,7 @@ fn foo(f: foo::Foo) {
 
     #[test]
     fn test_parameter_to_self() {
-        mark::check!(rename_to_self);
+        cov_mark::check!(rename_to_self);
         check(
             "self",
             r#"
@@ -1401,7 +1444,7 @@ impl Foo {
 
     #[test]
     fn test_owned_self_to_parameter() {
-        mark::check!(rename_self_to_param);
+        cov_mark::check!(rename_self_to_param);
         check(
             "foo",
             r#"
@@ -1454,7 +1497,7 @@ impl Foo {
 
     #[test]
     fn test_rename_field_put_init_shorthand() {
-        mark::check!(test_rename_field_put_init_shorthand);
+        cov_mark::check!(test_rename_field_put_init_shorthand);
         check(
             "bar",
             r#"
@@ -1476,7 +1519,7 @@ fn foo(bar: i32) -> Foo {
 
     #[test]
     fn test_rename_local_put_init_shorthand() {
-        mark::check!(test_rename_local_put_init_shorthand);
+        cov_mark::check!(test_rename_local_put_init_shorthand);
         check(
             "i",
             r#"
@@ -1498,7 +1541,7 @@ fn foo(i: i32) -> Foo {
 
     #[test]
     fn test_struct_field_pat_into_shorthand() {
-        mark::check!(test_rename_field_put_init_shorthand_pat);
+        cov_mark::check!(test_rename_field_put_init_shorthand_pat);
         check(
             "baz",
             r#"
@@ -1610,7 +1653,7 @@ fn foo(foo: Foo) {
 
     #[test]
     fn test_rename_lifetimes() {
-        mark::check!(rename_lifetime);
+        cov_mark::check!(rename_lifetime);
         check(
             "'yeeee",
             r#"
@@ -1698,7 +1741,7 @@ fn foo<'a>() -> &'a () {
 
     #[test]
     fn test_self_to_self() {
-        mark::check!(rename_self_to_self);
+        cov_mark::check!(rename_self_to_self);
         check(
             "self",
             r#"
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 65f60891e..280565563 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -9,7 +9,6 @@ use syntax::{
     ast::{self, AstNode, AttrsOwner},
     match_ast, SyntaxNode,
 };
-use test_utils::mark;
 
 use crate::{
     display::{ToNav, TryToNav},
@@ -130,7 +129,9 @@ fn runnables_mod(sema: &Semantics<RootDatabase>, acc: &mut Vec<Runnable>, module
         if let hir::ModuleDef::Module(submodule) = def {
             match submodule.definition_source(sema.db).value {
                 hir::ModuleSource::Module(_) => runnables_mod(sema, acc, submodule),
-                hir::ModuleSource::SourceFile(_) => mark::hit!(dont_recurse_in_outline_submodules),
+                hir::ModuleSource::SourceFile(_) => {
+                    cov_mark::hit!(dont_recurse_in_outline_submodules)
+                }
                 hir::ModuleSource::BlockExpr(_) => {} // inner items aren't runnable
             }
         }
@@ -328,7 +329,6 @@ fn has_test_function_or_multiple_test_submodules(
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use test_utils::mark;
 
     use crate::fixture;
 
@@ -1056,7 +1056,7 @@ mod tests {
 
     #[test]
     fn dont_recurse_in_outline_submodules() {
-        mark::check!(dont_recurse_in_outline_submodules);
+        cov_mark::check!(dont_recurse_in_outline_submodules);
         check(
             r#"
 //- /lib.rs
diff --git a/crates/ide/src/ssr.rs b/crates/ide/src/ssr.rs
new file mode 100644
index 000000000..f3638d928
--- /dev/null
+++ b/crates/ide/src/ssr.rs
@@ -0,0 +1,259 @@
+//! This module provides an SSR assist. It is not desirable to include this
+//! assist in ide_assists because that would require the ide_assists crate
+//! depend on the ide_ssr crate.
+
+use ide_assists::{Assist, AssistId, AssistKind, GroupLabel};
+use ide_db::{base_db::FileRange, label::Label, source_change::SourceChange, RootDatabase};
+
+pub(crate) fn add_ssr_assist(
+    db: &RootDatabase,
+    base: &mut Vec<Assist>,
+    resolve: bool,
+    frange: FileRange,
+) -> Option<()> {
+    let (match_finder, comment_range) = ide_ssr::ssr_from_comment(db, frange)?;
+
+    let (source_change_for_file, source_change_for_workspace) = if resolve {
+        let edits = match_finder.edits();
+
+        let source_change_for_file = {
+            let text_edit_for_file = edits.get(&frange.file_id).cloned().unwrap_or_default();
+            SourceChange::from_text_edit(frange.file_id, text_edit_for_file)
+        };
+
+        let source_change_for_workspace = SourceChange::from(match_finder.edits());
+
+        (Some(source_change_for_file), Some(source_change_for_workspace))
+    } else {
+        (None, None)
+    };
+
+    let assists = vec![
+        ("Apply SSR in file", source_change_for_file),
+        ("Apply SSR in workspace", source_change_for_workspace),
+    ];
+
+    for (label, source_change) in assists.into_iter() {
+        let assist = Assist {
+            id: AssistId("ssr", AssistKind::RefactorRewrite),
+            label: Label::new(label),
+            group: Some(GroupLabel("Apply SSR".into())),
+            target: comment_range,
+            source_change,
+        };
+
+        base.push(assist);
+    }
+    Some(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use expect_test::expect;
+    use ide_assists::Assist;
+    use ide_db::{
+        base_db::{fixture::WithFixture, salsa::Durability, FileRange},
+        symbol_index::SymbolsDatabase,
+        RootDatabase,
+    };
+    use rustc_hash::FxHashSet;
+
+    use super::add_ssr_assist;
+
+    fn get_assists(ra_fixture: &str, resolve: bool) -> Vec<Assist> {
+        let (mut db, file_id, range_or_offset) = RootDatabase::with_range_or_offset(ra_fixture);
+        let mut local_roots = FxHashSet::default();
+        local_roots.insert(ide_db::base_db::fixture::WORKSPACE);
+        db.set_local_roots_with_durability(Arc::new(local_roots), Durability::HIGH);
+
+        let mut assists = vec![];
+
+        add_ssr_assist(
+            &db,
+            &mut assists,
+            resolve,
+            FileRange { file_id, range: range_or_offset.into() },
+        );
+
+        assists
+    }
+
+    #[test]
+    fn not_applicable_comment_not_ssr() {
+        let ra_fixture = r#"
+            //- /lib.rs
+
+            // This is foo $0
+            fn foo() {}
+            "#;
+        let resolve = true;
+
+        let assists = get_assists(ra_fixture, resolve);
+
+        assert_eq!(0, assists.len());
+    }
+
+    #[test]
+    fn resolve_edits_true() {
+        let resolve = true;
+        let assists = get_assists(
+            r#"
+            //- /lib.rs
+            mod bar;
+
+            // 2 ==>> 3$0
+            fn foo() { 2 }
+
+            //- /bar.rs
+            fn bar() { 2 }
+            "#,
+            resolve,
+        );
+
+        assert_eq!(2, assists.len());
+        let mut assists = assists.into_iter();
+
+        let apply_in_file_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in file",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: Some(
+                    SourceChange {
+                        source_file_edits: {
+                            FileId(
+                                0,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 33..34,
+                                    },
+                                ],
+                            },
+                        },
+                        file_system_edits: [],
+                        is_snippet: false,
+                    },
+                ),
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_file_assist);
+
+        let apply_in_workspace_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in workspace",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: Some(
+                    SourceChange {
+                        source_file_edits: {
+                            FileId(
+                                0,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 33..34,
+                                    },
+                                ],
+                            },
+                            FileId(
+                                1,
+                            ): TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "3",
+                                        delete: 11..12,
+                                    },
+                                ],
+                            },
+                        },
+                        file_system_edits: [],
+                        is_snippet: false,
+                    },
+                ),
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_workspace_assist);
+    }
+
+    #[test]
+    fn resolve_edits_false() {
+        let resolve = false;
+        let assists = get_assists(
+            r#"
+            //- /lib.rs
+            mod bar;
+
+            // 2 ==>> 3$0
+            fn foo() { 2 }
+
+            //- /bar.rs
+            fn bar() { 2 }
+            "#,
+            resolve,
+        );
+
+        assert_eq!(2, assists.len());
+        let mut assists = assists.into_iter();
+
+        let apply_in_file_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in file",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: None,
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_file_assist);
+
+        let apply_in_workspace_assist = assists.next().unwrap();
+        expect![[r#"
+            Assist {
+                id: AssistId(
+                    "ssr",
+                    RefactorRewrite,
+                ),
+                label: "Apply SSR in workspace",
+                group: Some(
+                    GroupLabel(
+                        "Apply SSR",
+                    ),
+                ),
+                target: 10..21,
+                source_change: None,
+            }
+        "#]]
+        .assert_debug_eq(&apply_in_workspace_assist);
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 24fcbb584..b0cfdd8b7 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -330,10 +330,11 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                 HlTag::Symbol(SymbolKind::Local)
             };
             let mut h = Highlight::new(tag);
-            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
+            let ty = local.ty(db);
+            if local.is_mut(db) || ty.is_mutable_reference() {
                 h |= HlMod::Mutable;
             }
-            if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
+            if ty.as_callable(db).is_some() || ty.impls_fnonce(db) {
                 h |= HlMod::Callable;
             }
             return h;
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index 63cd51b69..978c479de 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -9,7 +9,7 @@ use syntax::{
     SyntaxKind::*,
     SyntaxToken, TextRange, TextSize, TokenAtOffset,
 };
-use test_utils::mark;
+
 use text_edit::TextEdit;
 
 // Feature: On Enter
@@ -55,7 +55,7 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Text
     // Continuing single-line non-doc comments (like this one :) ) is annoying
     if prefix == "//" && comment_range.end() == position.offset {
         if comment.text().ends_with(' ') {
-            mark::hit!(continues_end_of_line_comment_with_space);
+            cov_mark::hit!(continues_end_of_line_comment_with_space);
             remove_trailing_whitespace = true;
         } else if !followed_by_comment(&comment) {
             return None;
@@ -109,7 +109,7 @@ fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
 #[cfg(test)]
 mod tests {
     use stdx::trim_indent;
-    use test_utils::{assert_eq_text, mark};
+    use test_utils::assert_eq_text;
 
     use crate::fixture;
 
@@ -238,7 +238,7 @@ fn main() {
 
     #[test]
     fn continues_end_of_line_comment_with_space() {
-        mark::check!(continues_end_of_line_comment_with_space);
+        cov_mark::check!(continues_end_of_line_comment_with_space);
         do_check(
             r#"
 fn main() {