1 files changed, 299 insertions, 33 deletions

diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index fd17bc9f2..fd2163dad 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -4,17 +4,18 @@ use hir::{ModuleSource, Semantics};
 use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
+    algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
+    AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 use ra_text_edit::TextEdit;
+use std::convert::TryInto;
+use test_utils::mark;
 
 use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind, SourceChange,
-    SourceFileEdit, TextRange,
+    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
+    SourceChange, SourceFileEdit, TextRange, TextSize,
 };
 
-use super::find_all_refs;
-
 pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
@@ -22,17 +23,21 @@ pub(crate) fn rename(
 ) -> Option<RangeInfo<SourceChange>> {
     match lex_single_valid_syntax_kind(new_name)? {
         SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
+        SyntaxKind::SELF_KW => return rename_to_self(db, position),
         _ => return None,
     }
 
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
-    if let Some((ast_name, ast_module)) =
-        find_name_and_module_at_offset(source_file.syntax(), position)
-    {
+    let syntax = source_file.syntax();
+    if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
         let range = ast_name.syntax().text_range();
         rename_mod(&sema, &ast_name, &ast_module, position, new_name)
             .map(|info| RangeInfo::new(range, info))
+    } else if let Some(self_token) =
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+    {
+        rename_self_to_param(db, position, self_token, new_name)
     } else {
         rename_reference(sema.db, position, new_name)
     }
@@ -52,11 +57,13 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
     let file_id = reference.file_range.file_id;
     let range = match reference.kind {
         ReferenceKind::FieldShorthandForField => {
+            mark::hit!(test_rename_struct_field_for_shorthand);
             replacement_text.push_str(new_name);
             replacement_text.push_str(": ");
             TextRange::new(reference.file_range.range.start(), reference.file_range.range.start())
         }
         ReferenceKind::FieldShorthandForLocal => {
+            mark::hit!(test_rename_local_for_field_shorthand);
             replacement_text.push_str(": ");
             replacement_text.push_str(new_name);
             TextRange::new(reference.file_range.range.end(), reference.file_range.range.end())
@@ -121,7 +128,113 @@ fn rename_mod(
         source_file_edits.extend(ref_edits);
     }
 
-    Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
+    Some(SourceChange::from_edits("Rename", source_file_edits, file_system_edits))
+}
+
+fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+    let syn = source_file.syntax();
+
+    let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
+    let params = fn_def.param_list()?;
+    if params.self_param().is_some() {
+        return None; // method already has self param
+    }
+    let first_param = params.params().next()?;
+    let mutable = match first_param.ascribed_type() {
+        Some(ast::TypeRef::ReferenceType(rt)) => rt.mut_token().is_some(),
+        _ => return None, // not renaming other types
+    };
+
+    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+
+    let param_range = first_param.syntax().text_range();
+    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
+        .into_iter()
+        .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
+
+    if param_ref.is_empty() {
+        return None;
+    }
+
+    let mut edits = usages
+        .into_iter()
+        .map(|reference| source_edit_from_reference(reference, "self"))
+        .collect::<Vec<_>>();
+
+    edits.push(SourceFileEdit {
+        file_id: position.file_id,
+        edit: TextEdit::replace(
+            param_range,
+            String::from(if mutable { "&mut self" } else { "&self" }),
+        ),
+    });
+
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edits)))
+}
+
+fn text_edit_from_self_param(
+    syn: &SyntaxNode,
+    self_param: &ast::SelfParam,
+    new_name: &str,
+) -> Option<TextEdit> {
+    fn target_type_name(impl_def: &ast::ImplDef) -> Option<String> {
+        if let Some(ast::TypeRef::PathType(p)) = impl_def.target_type() {
+            return Some(p.path()?.segment()?.name_ref()?.text().to_string());
+        }
+        None
+    }
+
+    let impl_def =
+        find_node_at_offset::<ast::ImplDef>(syn, self_param.syntax().text_range().start())?;
+    let type_name = target_type_name(&impl_def)?;
+
+    let mut replacement_text = String::from(new_name);
+    replacement_text.push_str(": ");
+    replacement_text.push_str(self_param.mut_token().map_or("&", |_| "&mut "));
+    replacement_text.push_str(type_name.as_str());
+
+    Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
+}
+
+fn rename_self_to_param(
+    db: &RootDatabase,
+    position: FilePosition,
+    self_token: SyntaxToken,
+    new_name: &str,
+) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
+    let source_file = sema.parse(position.file_id);
+    let syn = source_file.syntax();
+
+    let text = db.file_text(position.file_id);
+    let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
+    let search_range = fn_def.syntax().text_range();
+
+    let mut edits: Vec<SourceFileEdit> = vec![];
+
+    for (idx, _) in text.match_indices("self") {
+        let offset: TextSize = idx.try_into().unwrap();
+        if !search_range.contains_inclusive(offset) {
+            continue;
+        }
+        if let Some(ref usage) =
+            syn.token_at_offset(offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        {
+            let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
+                text_edit_from_self_param(syn, self_param, new_name)?
+            } else {
+                TextEdit::replace(usage.text_range(), String::from(new_name))
+            };
+            edits.push(SourceFileEdit { file_id: position.file_id, edit });
+        }
+    }
+
+    let range = ast::SelfParam::cast(self_token.parent())
+        .map_or(self_token.text_range(), |p| p.syntax().text_range());
+
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edits)))
 }
 
 fn rename_reference(
@@ -140,14 +253,14 @@ fn rename_reference(
         return None;
     }
 
-    Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("Rename", edit)))
 }
 
 #[cfg(test)]
 mod tests {
     use insta::assert_debug_snapshot;
     use ra_text_edit::TextEditBuilder;
-    use test_utils::assert_eq_text;
+    use test_utils::{assert_eq_text, mark};
 
     use crate::{
         mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
@@ -379,6 +492,7 @@ mod tests {
 
     #[test]
     fn test_rename_struct_field_for_shorthand() {
+        mark::check!(test_rename_struct_field_for_shorthand);
         test_rename(
             r#"
     struct Foo {
@@ -408,6 +522,7 @@ mod tests {
 
     #[test]
     fn test_rename_local_for_field_shorthand() {
+        mark::check!(test_rename_local_for_field_shorthand);
         test_rename(
             r#"
     struct Foo {
@@ -527,17 +642,17 @@ mod tests {
             RangeInfo {
                 range: 4..7,
                 info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                     source_file_edits: [
                         SourceFileEdit {
                             file_id: FileId(
                                 2,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 4..7,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 4..7,
                                     },
                                 ],
                             },
@@ -554,7 +669,7 @@ mod tests {
                             dst_path: "bar/foo2.rs",
                         },
                     ],
-                    cursor_position: None,
+                    is_snippet: false,
                 },
             },
         )
@@ -579,17 +694,17 @@ mod tests {
             RangeInfo {
                 range: 4..7,
                 info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                     source_file_edits: [
                         SourceFileEdit {
                             file_id: FileId(
                                 1,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 4..7,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 4..7,
                                     },
                                 ],
                             },
@@ -606,7 +721,7 @@ mod tests {
                             dst_path: "foo2/mod.rs",
                         },
                     ],
-                    cursor_position: None,
+                    is_snippet: false,
                 },
             },
         )
@@ -662,17 +777,17 @@ mod tests {
             RangeInfo {
                 range: 8..11,
                 info: SourceChange {
-                    label: "rename",
+                    label: "Rename",
                     source_file_edits: [
                         SourceFileEdit {
                             file_id: FileId(
                                 2,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 8..11,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 8..11,
                                     },
                                 ],
                             },
@@ -682,10 +797,10 @@ mod tests {
                                 1,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 27..30,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 27..30,
                                     },
                                 ],
                             },
@@ -702,13 +817,164 @@ mod tests {
                             dst_path: "bar/foo2.rs",
                         },
                     ],
-                    cursor_position: None,
+                    is_snippet: false,
                 },
             },
         )
         "###);
     }
 
+    #[test]
+    fn test_enum_variant_from_module_1() {
+        test_rename(
+            r#"
+    mod foo {
+        pub enum Foo {
+            Bar<|>,
+        }
+    }
+
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Bar => {}
+        }
+    }
+    "#,
+            "Baz",
+            r#"
+    mod foo {
+        pub enum Foo {
+            Baz,
+        }
+    }
+
+    fn func(f: foo::Foo) {
+        match f {
+            foo::Foo::Baz => {}
+        }
+    }
+    "#,
+        );
+    }
+
+    #[test]
+    fn test_enum_variant_from_module_2() {
+        test_rename(
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub bar<|>: uint,
+        }
+    }
+
+    fn foo(f: foo::Foo) {
+        let _ = f.bar;
+    }
+    "#,
+            "baz",
+            r#"
+    mod foo {
+        pub struct Foo {
+            pub baz: uint,
+        }
+    }
+
+    fn foo(f: foo::Foo) {
+        let _ = f.baz;
+    }
+    "#,
+        );
+    }
+
+    #[test]
+    fn test_parameter_to_self() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(foo<|>: &mut Foo) -> i32 {
+            foo.i
+        }
+    }
+    "#,
+            "self",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(&mut self) -> i32 {
+            self.i
+        }
+    }
+    "#,
+        );
+    }
+
+    #[test]
+    fn test_self_to_parameter() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(&mut <|>self) -> i32 {
+            self.i
+        }
+    }
+    "#,
+            "foo",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(foo: &mut Foo) -> i32 {
+            foo.i
+        }
+    }
+    "#,
+        );
+    }
+
+    #[test]
+    fn test_self_in_path_to_parameter() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(&self) -> i32 {
+            let self_var = 1;
+            self<|>.i
+        }
+    }
+    "#,
+            "foo",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+
+    impl Foo {
+        fn f(foo: &Foo) -> i32 {
+            let self_var = 1;
+            foo.i
+        }
+    }
+    "#,
+        );
+    }
+
     fn test_rename(text: &str, new_name: &str, expected: &str) {
         let (analysis, position) = single_file_with_position(text);
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -717,13 +983,13 @@ mod tests {
         if let Some(change) = source_change {
             for edit in change.info.source_file_edits {
                 file_id = Some(edit.file_id);
-                for atom in edit.edit.as_atoms() {
-                    text_edit_builder.replace(atom.delete, atom.insert.clone());
+                for indel in edit.edit.into_iter() {
+                    text_edit_builder.replace(indel.delete, indel.insert);
                 }
             }
         }
-        let result =
-            text_edit_builder.finish().apply(&*analysis.file_text(file_id.unwrap()).unwrap());
+        let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
+        text_edit_builder.finish().apply(&mut result);
         assert_eq_text!(expected, &*result);
     }
 }