9 files changed, 404 insertions, 383 deletions

diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index e4335119b..579d5a308 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -140,7 +140,7 @@ impl DiagnosticWithFix for IncorrectCase {
             rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
 
         let label = format!("Rename to {}", self.suggested_text);
-        Some(Fix::new(&label, rename_changes.info, rename_changes.range))
+        Some(Fix::new(&label, rename_changes, frange.range))
     }
 }
 
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 685052e7f..00e601244 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -400,15 +400,13 @@ impl TryToNav for hir::GenericParam {
 impl ToNav for hir::Local {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let (node, focus_range) = match &src.value {
-            Either::Left(bind_pat) => (
-                bind_pat.syntax().clone(),
-                bind_pat
-                    .name()
-                    .map(|it| src.with_value(&it.syntax().clone()).original_file_range(db).range),
-            ),
-            Either::Right(it) => (it.syntax().clone(), it.self_token().map(|it| it.text_range())),
+        let (node, name) = match &src.value {
+            Either::Left(bind_pat) => (bind_pat.syntax().clone(), bind_pat.name()),
+            Either::Right(it) => (it.syntax().clone(), it.name()),
         };
+        let focus_range =
+            name.map(|it| src.with_value(&it.syntax().clone()).original_file_range(db).range);
+
         let full_range = src.with_value(&node).original_file_range(db);
         let name = match self.name(db) {
             Some(it) => it.to_string().into(),
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 988a5668f..a1d2bce1d 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -55,11 +55,6 @@ pub(crate) fn goto_definition(
             } else {
                 reference_definition(&sema, Either::Left(&lt)).to_vec()
             },
-            ast::SelfParam(self_param) => {
-                let def = NameClass::classify_self_param(&sema, &self_param)?.referenced_or_defined(sema.db);
-                let nav = def.try_to_nav(sema.db)?;
-                vec![nav]
-            },
             _ => return None,
         }
     };
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 6022bd275..2024acd94 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -98,7 +98,6 @@ pub(crate) fn hover(
             ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
             ast::Lifetime(lifetime) => NameClass::classify_lifetime(&sema, &lifetime)
                 .map_or_else(|| NameRefClass::classify_lifetime(&sema, &lifetime).map(|d| d.referenced(sema.db)), |d| d.defined(sema.db)),
-            ast::SelfParam(self_param) => NameClass::classify_self_param(&sema, &self_param).and_then(|d| d.defined(sema.db)),
             _ => None,
         }
     };
@@ -3223,7 +3222,7 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                *&self*
+                *self*
 
                 ```rust
                 &Foo
@@ -3243,7 +3242,7 @@ impl Foo {
 }
 "#,
             expect![[r#"
-                *self: Arc<Foo>*
+                *self*
 
                 ```rust
                 Arc<Foo>
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 07f52613f..3abbb14c6 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -86,18 +86,15 @@ pub use completion::{
     InsertTextFormat,
 };
 pub use hir::{Documentation, Semantics};
-pub use ide_db::base_db::{
-    Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
-    SourceRootId,
-};
 pub use ide_db::{
+    base_db::{
+        Canceled, Change, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange,
+        SourceRoot, SourceRootId,
+    },
     call_info::CallInfo,
-    search::{FileReference, ReferenceAccess, ReferenceKind},
-};
-pub use ide_db::{
     label::Label,
     line_index::{LineCol, LineIndex},
-    search::SearchScope,
+    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope},
     source_change::{FileSystemEdit, SourceChange},
     symbol_index::Query,
     RootDatabase,
@@ -525,7 +522,7 @@ impl Analysis {
         &self,
         position: FilePosition,
         new_name: &str,
-    ) -> Cancelable<Result<RangeInfo<SourceChange>, RenameError>> {
+    ) -> Cancelable<Result<SourceChange, RenameError>> {
         self.with_db(|db| references::rename::rename(db, position, new_name))
     }
 
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 51a2f4327..df9c31aef 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -930,6 +930,26 @@ impl Foo {
         );
     }
 
+    #[test]
+    fn test_find_self_refs_decl() {
+        check(
+            r#"
+struct Foo { bar: i32 }
+
+impl Foo {
+    fn foo(self$0) {
+        self;
+    }
+}
+"#,
+            expect![[r#"
+                self SelfParam FileId(0) 47..51 47..51 SelfParam
+
+                FileId(0) 63..67 Other Read
+            "#]],
+        );
+    }
+
     fn check(ra_fixture: &str, expect: Expect) {
         check_with_scope(ra_fixture, None, expect)
     }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 9ac4af026..c25bcce50 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,27 +1,25 @@
 //! FIXME: write short doc here
-use std::{
-    convert::TryInto,
-    fmt::{self, Display},
-};
+use std::fmt::{self, Display};
 
-use hir::{Module, ModuleDef, ModuleSource, Semantics};
+use either::Either;
+use hir::{HasSource, InFile, Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::{
-    base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt},
+    base_db::{AnchoredPathBuf, FileId, FileRange},
     defs::{Definition, NameClass, NameRefClass},
     search::FileReference,
     RootDatabase,
 };
+use stdx::assert_never;
 use syntax::{
-    algo::find_node_at_offset,
     ast::{self, NameOwner},
-    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken, T,
+    lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
 
 use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
-    TextRange, TextSize,
+    display::TryToNav, FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, SourceChange,
+    TextRange,
 };
 
 type RenameResult<T> = Result<T, RenameError>;
@@ -50,24 +48,22 @@ pub(crate) fn prepare_rename(
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_mod(&sema, position, module, "dummy")
-    } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
+    let range = match &find_name_like(&sema, &syntax, position)
+        .ok_or_else(|| format_err!("No references found at position"))?
     {
-        rename_self_to_param(&sema, position, self_token, "dummy")
-    } else {
-        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
-        Ok(RangeInfo::new(range, SourceChange::default()))
+        NameLike::Name(it) => it.syntax(),
+        NameLike::NameRef(it) => it.syntax(),
+        NameLike::Lifetime(it) => it.syntax(),
     }
-    .map(|info| RangeInfo::new(info.range, ()))
+    .text_range();
+    Ok(RangeInfo::new(range, ()))
 }
 
 pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     let sema = Semantics::new(db);
     rename_with_semantics(&sema, position, new_name)
 }
@@ -76,18 +72,15 @@ pub(crate) fn rename_with_semantics(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
 
-    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_mod(&sema, position, module, new_name)
-    } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
-    {
-        rename_self_to_param(&sema, position, self_token, new_name)
-    } else {
-        rename_reference(&sema, position, new_name)
+    let def = find_definition(sema, syntax, position)
+        .ok_or_else(|| format_err!("No references found at position"))?;
+    match def {
+        Definition::ModuleDef(ModuleDef::Module(module)) => rename_mod(&sema, module, new_name),
+        def => rename_reference(sema, def, new_name),
     }
 }
 
@@ -98,17 +91,12 @@ pub(crate) fn will_rename_file(
 ) -> Option<SourceChange> {
     let sema = Semantics::new(db);
     let module = sema.to_module_def(file_id)?;
-
-    let decl = module.declaration_source(db)?;
-    let range = decl.value.name()?.syntax().text_range();
-
-    let position = FilePosition { file_id: decl.file_id.original_file(db), offset: range.start() };
-    let mut change = rename_mod(&sema, position, module, new_name_stem).ok()?.info;
+    let mut change = rename_mod(&sema, module, new_name_stem).ok()?;
     change.file_system_edits.clear();
     Some(change)
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum IdentifierKind {
     Ident,
     Lifetime,
@@ -135,40 +123,51 @@ fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
     }
 }
 
-fn find_module_at_offset(
+enum NameLike {
+    Name(ast::Name),
+    NameRef(ast::NameRef),
+    Lifetime(ast::Lifetime),
+}
+
+fn find_name_like(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
     syntax: &SyntaxNode,
-) -> Option<Module> {
-    let ident = syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::IDENT)?;
-
-    let module = match_ast! {
-        match (ident.parent()) {
-            ast::NameRef(name_ref) => {
-                match NameRefClass::classify(sema, &name_ref)? {
-                    NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
-                    _ => return None,
-                }
-            },
-            ast::Name(name) => {
-                match NameClass::classify(&sema, &name)? {
-                    NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
-                    _ => return None,
-                }
-            },
-            _ => return None,
-        }
+    position: FilePosition,
+) -> Option<NameLike> {
+    let namelike = if let Some(name_ref) =
+        sema.find_node_at_offset_with_descend::<ast::NameRef>(syntax, position.offset)
+    {
+        NameLike::NameRef(name_ref)
+    } else if let Some(name) =
+        sema.find_node_at_offset_with_descend::<ast::Name>(syntax, position.offset)
+    {
+        NameLike::Name(name)
+    } else if let Some(lifetime) =
+        sema.find_node_at_offset_with_descend::<ast::Lifetime>(syntax, position.offset)
+    {
+        NameLike::Lifetime(lifetime)
+    } else {
+        return None;
     };
-
-    Some(module)
+    Some(namelike)
 }
 
-fn find_all_refs(
+fn find_definition(
     sema: &Semantics<RootDatabase>,
+    syntax: &SyntaxNode,
     position: FilePosition,
-) -> RenameResult<RangeInfo<ReferenceSearchResult>> {
-    crate::references::find_all_refs(sema, position, None)
-        .ok_or_else(|| format_err!("No references found at position"))
+) -> Option<Definition> {
+    let def = match find_name_like(sema, syntax, position)? {
+        NameLike::Name(name) => NameClass::classify(sema, &name)?.referenced_or_defined(sema.db),
+        NameLike::NameRef(name_ref) => NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
+        NameLike::Lifetime(lifetime) => NameRefClass::classify_lifetime(sema, &lifetime)
+            .map(|class| NameRefClass::referenced(class, sema.db))
+            .or_else(|| {
+                NameClass::classify_lifetime(sema, &lifetime)
+                    .map(|it| it.referenced_or_defined(sema.db))
+            })?,
+    };
+    Some(def)
 }
 
 fn source_edit_from_references(
@@ -242,72 +241,84 @@ fn edit_text_range_for_record_field_expr_or_pat(
 
 fn rename_mod(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
     module: Module,
     new_name: &str,
-) -> RenameResult<RangeInfo<SourceChange>> {
+) -> RenameResult<SourceChange> {
     if IdentifierKind::Ident != check_identifier(new_name)? {
         bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
     }
 
     let mut source_change = SourceChange::default();
 
-    let src = module.definition_source(sema.db);
-    let file_id = src.file_id.original_file(sema.db);
-    match src.value {
-        ModuleSource::SourceFile(..) => {
-            // mod is defined in path/to/dir/mod.rs
-            let path = if module.is_mod_rs(sema.db) {
-                format!("../{}/mod.rs", new_name)
-            } else {
-                format!("{}.rs", new_name)
-            };
-            let dst = AnchoredPathBuf { anchor: file_id, path };
-            let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
-            source_change.push_file_system_edit(move_file);
-        }
-        ModuleSource::Module(..) => {}
-    }
-
-    if let Some(src) = module.declaration_source(sema.db) {
-        let file_id = src.file_id.original_file(sema.db);
-        let name = src.value.name().unwrap();
-        source_change.insert_source_edit(
-            file_id,
-            TextEdit::replace(name.syntax().text_range(), new_name.into()),
-        );
+    let InFile { file_id, value: def_source } = module.definition_source(sema.db);
+    let file_id = file_id.original_file(sema.db);
+    if let ModuleSource::SourceFile(..) = def_source {
+        // mod is defined in path/to/dir/mod.rs
+        let path = if module.is_mod_rs(sema.db) {
+            format!("../{}/mod.rs", new_name)
+        } else {
+            format!("{}.rs", new_name)
+        };
+        let dst = AnchoredPathBuf { anchor: file_id, path };
+        let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
+        source_change.push_file_system_edit(move_file);
+    }
+
+    if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
+        let file_id = file_id.original_file(sema.db);
+        match decl_source.name() {
+            Some(name) => source_change.insert_source_edit(
+                file_id,
+                TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
+            ),
+            _ => unreachable!(),
+        };
     }
-
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
+    let def = Definition::ModuleDef(ModuleDef::Module(module));
+    let usages = def.usages(sema).all();
+    let ref_edits = usages.iter().map(|(&file_id, references)| {
         source_edit_from_references(sema, file_id, references, new_name)
     });
     source_change.extend(ref_edits);
 
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
 
-fn rename_to_self(
-    sema: &Semantics<RootDatabase>,
-    position: FilePosition,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
+fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
+    if assert_never!(local.is_self(sema.db)) {
+        bail!("rename_to_self invoked on self");
+    }
+
+    let fn_def = match local.parent(sema.db) {
+        hir::DefWithBody::Function(func) => func,
+        _ => bail!("Cannot rename non-param local to self"),
+    };
+
+    // FIXME: reimplement this on the hir instead
+    // as of the time of this writing params in hir don't keep their names
+    let fn_ast =
+        fn_def.source(sema.db).ok_or(format_err!("Cannot rename non-param local to self"))?.value;
 
-    let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-    let param_range = fn_ast
+    let first_param_range = fn_ast
         .param_list()
         .and_then(|p| p.params().next())
         .ok_or_else(|| format_err!("Method has no parameters"))?
         .syntax()
         .text_range();
-    if !param_range.contains(position.offset) {
-        bail!("Only the first parameter can be self");
+    let InFile { file_id, value: local_source } = local.source(sema.db);
+    match local_source {
+        either::Either::Left(pat)
+            if !first_param_range.contains_range(pat.syntax().text_range()) =>
+        {
+            bail!("Only the first parameter can be self");
+        }
+        _ => (),
     }
 
-    let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
+    let impl_block = fn_ast
+        .syntax()
+        .ancestors()
+        .find_map(|node| ast::Impl::cast(node))
         .and_then(|def| sema.to_def(&def))
         .ok_or_else(|| format_err!("No impl block found for function"))?;
     if fn_def.self_param(sema.db).is_some() {
@@ -331,25 +342,21 @@ fn rename_to_self(
         bail!("Parameter type differs from impl block type");
     }
 
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
     let mut source_change = SourceChange::default();
-    source_change.extend(refs.references().iter().map(|(&file_id, references)| {
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
         source_edit_from_references(sema, file_id, references, "self")
     }));
     source_change.insert_source_edit(
-        position.file_id,
-        TextEdit::replace(param_range, String::from(self_param)),
+        file_id.original_file(sema.db),
+        TextEdit::replace(first_param_range, String::from(self_param)),
     );
 
-    Ok(RangeInfo::new(range, source_change))
+    Ok(source_change)
 }
 
-fn text_edit_from_self_param(
-    syn: &SyntaxNode,
-    self_param: &ast::SelfParam,
-    new_name: &str,
-) -> Option<TextEdit> {
+fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
     fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
         if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
             return Some(p.path()?.segment()?.name_ref()?.text().to_string());
@@ -357,7 +364,7 @@ fn text_edit_from_self_param(
         None
     }
 
-    let impl_def = find_node_at_offset::<ast::Impl>(syn, self_param.syntax().text_range().start())?;
+    let impl_def = self_param.syntax().ancestors().find_map(|it| ast::Impl::cast(it))?;
     let type_name = target_type_name(&impl_def)?;
 
     let mut replacement_text = String::from(new_name);
@@ -374,96 +381,119 @@ fn text_edit_from_self_param(
 
 fn rename_self_to_param(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
-    self_token: SyntaxToken,
+    local: hir::Local,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
-    let ident_kind = check_identifier(new_name)?;
-    match ident_kind {
-        IdentifierKind::Lifetime => bail!("Invalid name `{}`: not an identifier", new_name),
-        IdentifierKind::ToSelf => {
-            // no-op
-            mark::hit!(rename_self_to_self);
-            return Ok(RangeInfo::new(self_token.text_range(), SourceChange::default()));
-        }
-        _ => (),
-    }
-    let source_file = sema.parse(position.file_id);
-    let syn = source_file.syntax();
-
-    let text = sema.db.file_text(position.file_id);
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
-        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
-    let search_range = fn_def.syntax().text_range();
-
-    let mut source_change = SourceChange::default();
-
-    for (idx, _) in text.match_indices("self") {
-        let offset: TextSize = idx.try_into().unwrap();
-        if !search_range.contains_inclusive(offset) {
-            continue;
+    identifier_kind: IdentifierKind,
+) -> RenameResult<SourceChange> {
+    let (file_id, self_param) = match local.source(sema.db) {
+        InFile { file_id, value: Either::Right(self_param) } => (file_id, self_param),
+        _ => {
+            assert_never!(true, "rename_self_to_param invoked on a non-self local");
+            bail!("rename_self_to_param invoked on a non-self local");
         }
-        if let Some(ref usage) = syn.token_at_offset(offset).find(|t| t.kind() == T![self]) {
-            let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
-                text_edit_from_self_param(syn, self_param, new_name)
-                    .ok_or_else(|| format_err!("No target type found"))?
-            } else {
-                TextEdit::replace(usage.text_range(), String::from(new_name))
-            };
-            source_change.insert_source_edit(position.file_id, edit);
-        }
-    }
+    };
 
-    if source_change.source_file_edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
+    let def = Definition::Local(local);
+    let usages = def.usages(sema).all();
+    let edit = text_edit_from_self_param(&self_param, new_name)
+        .ok_or_else(|| format_err!("No target type found"))?;
+    if usages.len() > 1 && identifier_kind == IdentifierKind::Underscore {
         bail!("Cannot rename reference to `_` as it is being referenced multiple times");
     }
-
-    let range = ast::SelfParam::cast(self_token.parent())
-        .map_or(self_token.text_range(), |p| p.syntax().text_range());
-
-    Ok(RangeInfo::new(range, source_change))
+    let mut source_change = SourceChange::default();
+    source_change.insert_source_edit(file_id.original_file(sema.db), edit);
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, &references, new_name)
+    }));
+    Ok(source_change)
 }
 
 fn rename_reference(
     sema: &Semantics<RootDatabase>,
-    position: FilePosition,
+    def: Definition,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<SourceChange> {
     let ident_kind = check_identifier(new_name)?;
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
 
-    match (ident_kind, &refs.declaration.kind) {
-        (IdentifierKind::ToSelf, ReferenceKind::Lifetime)
-        | (IdentifierKind::Underscore, ReferenceKind::Lifetime)
-        | (IdentifierKind::Ident, ReferenceKind::Lifetime) => {
+    let def_is_lbl_or_lt = matches!(def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_))
+        | Definition::Label(_)
+    );
+    match (ident_kind, def) {
+        (IdentifierKind::ToSelf, _)
+        | (IdentifierKind::Underscore, _)
+        | (IdentifierKind::Ident, _)
+            if def_is_lbl_or_lt =>
+        {
             mark::hit!(rename_not_a_lifetime_ident_ref);
             bail!("Invalid name `{}`: not a lifetime identifier", new_name)
         }
-        (IdentifierKind::Lifetime, ReferenceKind::Lifetime) => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) if def_is_lbl_or_lt => mark::hit!(rename_lifetime),
         (IdentifierKind::Lifetime, _) => {
             mark::hit!(rename_not_an_ident_ref);
             bail!("Invalid name `{}`: not an identifier", new_name)
         }
-        (IdentifierKind::ToSelf, ReferenceKind::SelfParam) => {
-            unreachable!("rename_self_to_param should've been called instead")
+        (IdentifierKind::ToSelf, Definition::Local(local)) if local.is_self(sema.db) => {
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(SourceChange::default());
         }
-        (IdentifierKind::ToSelf, _) => {
-            mark::hit!(rename_to_self);
-            return rename_to_self(sema, position);
+        (ident_kind, Definition::Local(local)) if local.is_self(sema.db) => {
+            mark::hit!(rename_self_to_param);
+            return rename_self_to_param(sema, local, new_name, ident_kind);
         }
-        (IdentifierKind::Underscore, _) if !refs.references.is_empty() => {
-            mark::hit!(rename_underscore_multiple);
-            bail!("Cannot rename reference to `_` as it is being referenced multiple times")
+        (IdentifierKind::ToSelf, Definition::Local(local)) => {
+            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),
     }
 
+    let usages = def.usages(sema).all();
+    if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
+        mark::hit!(rename_underscore_multiple);
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
     let mut source_change = SourceChange::default();
-    source_change.extend(refs.into_iter().map(|(file_id, references)| {
+    source_change.extend(usages.iter().map(|(&file_id, references)| {
         source_edit_from_references(sema, file_id, &references, new_name)
     }));
 
-    Ok(RangeInfo::new(range, source_change))
+    let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
+    source_change.insert_source_edit(file_id, edit);
+    Ok(source_change)
+}
+
+fn source_edit_from_def(
+    sema: &Semantics<RootDatabase>,
+    def: Definition,
+    new_name: &str,
+) -> RenameResult<(FileId, TextEdit)> {
+    let nav = def.try_to_nav(sema.db).unwrap();
+
+    let mut replacement_text = String::new();
+    let mut repl_range = nav.focus_or_full_range();
+    if let Definition::Local(local) = def {
+        if let Either::Left(pat) = local.source(sema.db).value {
+            if matches!(
+                pat.syntax().parent().and_then(ast::RecordPatField::cast),
+                Some(pat_field) if pat_field.name_ref().is_none()
+            ) {
+                replacement_text.push_str(": ");
+                replacement_text.push_str(new_name);
+                repl_range = TextRange::new(
+                    pat.syntax().text_range().end(),
+                    pat.syntax().text_range().end(),
+                );
+            }
+        }
+    }
+    if replacement_text.is_empty() {
+        replacement_text.push_str(new_name);
+    }
+    let edit = TextEdit::replace(repl_range, replacement_text);
+    Ok((nav.file_id, edit))
 }
 
 #[cfg(test)]
@@ -485,7 +515,7 @@ mod tests {
             Ok(source_change) => {
                 let mut text_edit_builder = TextEdit::builder();
                 let mut file_id: Option<FileId> = None;
-                for edit in source_change.info.source_file_edits {
+                for edit in source_change.source_file_edits {
                     file_id = Some(edit.0);
                     for indel in edit.1.into_iter() {
                         text_edit_builder.replace(indel.delete, indel.insert);
@@ -884,36 +914,33 @@ mod foo$0;
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 4..7,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                1,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            1,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 4..7,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     2,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
+                                path: "foo2.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -936,46 +963,43 @@ pub struct FooContent;
 use crate::foo$0::FooContent;
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 11..14,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "quux",
-                                        delete: 8..11,
-                                    },
-                                ],
-                            },
-                            FileId(
-                                2,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "quux",
-                                        delete: 11..14,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "quux",
+                                    delete: 8..11,
+                                },
+                            ],
+                        },
+                        FileId(
+                            2,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "quux",
+                                    delete: 11..14,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "quux.rs",
-                                },
+                                path: "quux.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -992,36 +1016,33 @@ mod fo$0o;
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 4..7,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 4..7,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 4..7,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "../foo2/mod.rs",
-                                },
+                                path: "../foo2/mod.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1039,36 +1060,33 @@ mod outer { mod fo$0o; }
 // empty
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 16..19,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "bar",
-                                        delete: 16..19,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "bar",
+                                    delete: 16..19,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                1,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     1,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        1,
-                                    ),
-                                    path: "bar.rs",
-                                },
+                                path: "bar.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1109,46 +1127,43 @@ pub mod foo$0;
 // pub fn fun() {}
 "#,
             expect![[r#"
-                RangeInfo {
-                    range: 8..11,
-                    info: SourceChange {
-                        source_file_edits: {
-                            FileId(
-                                0,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 27..30,
-                                    },
-                                ],
-                            },
-                            FileId(
-                                1,
-                            ): TextEdit {
-                                indels: [
-                                    Indel {
-                                        insert: "foo2",
-                                        delete: 8..11,
-                                    },
-                                ],
-                            },
+                SourceChange {
+                    source_file_edits: {
+                        FileId(
+                            0,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 27..30,
+                                },
+                            ],
                         },
-                        file_system_edits: [
-                            MoveFile {
-                                src: FileId(
+                        FileId(
+                            1,
+                        ): TextEdit {
+                            indels: [
+                                Indel {
+                                    insert: "foo2",
+                                    delete: 8..11,
+                                },
+                            ],
+                        },
+                    },
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst: AnchoredPathBuf {
+                                anchor: FileId(
                                     2,
                                 ),
-                                dst: AnchoredPathBuf {
-                                    anchor: FileId(
-                                        2,
-                                    ),
-                                    path: "foo2.rs",
-                                },
+                                path: "foo2.rs",
                             },
-                        ],
-                        is_snippet: false,
-                    },
+                        },
+                    ],
+                    is_snippet: false,
                 }
             "#]],
         );
@@ -1350,6 +1365,7 @@ impl Foo {
 
     #[test]
     fn test_owned_self_to_parameter() {
+        mark::check!(rename_self_to_param);
         check(
             "foo",
             r#"
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 87578e70a..8625ef5df 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -68,7 +68,8 @@ pub(super) fn element(
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
             highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
-                match NameRefClass::classify(sema, &name_ref) {
+                let is_self = name_ref.self_token().is_some();
+                let h = match NameRefClass::classify(sema, &name_ref) {
                     Some(name_kind) => match name_kind {
                         NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
                         NameRefClass::Definition(def) => {
@@ -108,6 +109,11 @@ pub(super) fn element(
                         highlight_name_ref_by_syntax(name_ref, sema)
                     }
                     None => HlTag::UnresolvedReference.into(),
+                };
+                if h.tag == HlTag::Symbol(SymbolKind::Module) && is_self {
+                    HlTag::Symbol(SymbolKind::SelfParam).into()
+                } else {
+                    h
                 }
             })
         }
@@ -225,18 +231,8 @@ pub(super) fn element(
                 T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
                 T![unsafe] => h | HlMod::Unsafe,
                 T![true] | T![false] => HlTag::BoolLiteral.into(),
-                T![self] => {
-                    let self_param = element.parent().and_then(ast::SelfParam::cast);
-                    if let Some(NameClass::Definition(def)) = self_param
-                        .and_then(|self_param| NameClass::classify_self_param(sema, &self_param))
-                    {
-                        highlight_def(db, def) | HlMod::Definition
-                    } else if element.ancestors().any(|it| it.kind() == USE_TREE) {
-                        HlTag::Symbol(SymbolKind::SelfParam).into()
-                    } else {
-                        return None;
-                    }
-                }
+                // self is handled as either a Name or NameRef already
+                T![self] => return None,
                 T![ref] => element
                     .parent()
                     .and_then(ast::IdentPat::cast)
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index 1d4bac7ad..4c63d3023 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -111,7 +111,6 @@ mod tests {
         let syn = analysis.syntax_tree(file_id, None).unwrap();
 
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -127,7 +126,8 @@ [email protected]
       [email protected] "{"
       [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
 
         let (analysis, file_id) = fixture::file(
@@ -143,7 +143,6 @@ fn test() {
         let syn = analysis.syntax_tree(file_id, None).unwrap();
 
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -176,7 +175,8 @@ [email protected]
       [email protected] "\n"
       [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
     }
 
@@ -186,7 +186,6 @@ [email protected]
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
 
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected] "fn"
@@ -201,7 +200,8 @@ [email protected]
     [email protected] "{"
     [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
 
         let (analysis, range) = fixture::range(
@@ -216,7 +216,6 @@ [email protected]
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
 
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -234,7 +233,8 @@ [email protected]
       [email protected] ")"
   [email protected] ";"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
     }
 
@@ -253,7 +253,6 @@ fn bar() {
         );
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -270,7 +269,8 @@ [email protected]
       [email protected] "\n"
       [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
 
         // With a raw string
@@ -287,7 +287,6 @@ fn bar() {
         );
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -304,7 +303,8 @@ [email protected]
       [email protected] "\n"
       [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
 
         // With a raw string
@@ -320,7 +320,6 @@ fn bar() {
         );
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
         assert_eq_text!(
-            syn.trim(),
             r#"
 [email protected]
   [email protected]
@@ -351,7 +350,8 @@ [email protected]
       [email protected] "\n"
       [email protected] "}"
 "#
-            .trim()
+            .trim(),
+            syn.trim()
         );
     }
 }