Merge #4332

4332: Refactor TextEdit r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Author: bors[bot]

crates/ra_assists/src/assist_ctx.rs

@@ -4,14 +4,13 @@ use ra_db::FileRange;
 use ra_fmt::{leading_indent, reindent};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
-    algo::{self, find_covering_element, find_node_at_offset},
+    algo::{self, find_covering_element, find_node_at_offset, SyntaxRewriter},
     AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize,
     TokenAtOffset,
 };
 use ra_text_edit::TextEditBuilder;
 
 use crate::{AssistAction, AssistFile, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
-use algo::SyntaxRewriter;
 
 #[derive(Clone, Debug)]
 pub(crate) struct Assist(pub(crate) Vec<AssistInfo>);
@@ -42,8 +41,6 @@ impl AssistInfo {
     }
 }
 
-pub(crate) type AssistHandler = fn(AssistCtx) -> Option<Assist>;
-
 /// `AssistCtx` allows to apply an assist or check if it could be applied.
 ///
 /// Assists use a somewhat over-engineered approach, given the current needs. The

crates/ra_assists/src/doc_tests.rs

@@ -30,6 +30,10 @@ fn check(assist_id: &str, before: &str, after: &str) {
             )
         });
 
-    let actual = assist.action.edit.apply(&before);
+    let actual = {
+        let mut actual = before.clone();
+        assist.action.edit.apply(&mut actual);
+        actual
+    };
     assert_eq_text!(after, &actual);
 }

crates/ra_assists/src/lib.rs

@@ -23,7 +23,7 @@ use ra_ide_db::RootDatabase;
 use ra_syntax::{TextRange, TextSize};
 use ra_text_edit::TextEdit;
 
-pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
+pub(crate) use crate::assist_ctx::{Assist, AssistCtx};
 
 /// Unique identifier of the assist, should not be shown to the user
 /// directly.
@@ -109,7 +109,9 @@ pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssi
 }
 
 mod handlers {
-    use crate::AssistHandler;
+    use crate::{Assist, AssistCtx};
+
+    pub(crate) type Handler = fn(AssistCtx) -> Option<Assist>;
 
     mod add_custom_impl;
     mod add_derive;
@@ -145,12 +147,13 @@ mod handlers {
     mod reorder_fields;
     mod unwrap_block;
 
-    pub(crate) fn all() -> &'static [AssistHandler] {
+    pub(crate) fn all() -> &'static [Handler] {
         &[
             // These are alphabetic for the foolish consistency
             add_custom_impl::add_custom_impl,
             add_derive::add_derive,
             add_explicit_type::add_explicit_type,
+            add_from_impl_for_enum::add_from_impl_for_enum,
             add_function::add_function,
             add_impl::add_impl,
             add_new::add_new,
@@ -176,17 +179,18 @@ mod handlers {
             raw_string::remove_hash,
             remove_dbg::remove_dbg,
             remove_mut::remove_mut,
+            reorder_fields::reorder_fields,
             replace_if_let_with_match::replace_if_let_with_match,
             replace_let_with_if_let::replace_let_with_if_let,
             replace_qualified_name_with_use::replace_qualified_name_with_use,
             replace_unwrap_with_match::replace_unwrap_with_match,
             split_import::split_import,
-            add_from_impl_for_enum::add_from_impl_for_enum,
             unwrap_block::unwrap_block,
             // These are manually sorted for better priorities
             add_missing_impl_members::add_missing_impl_members,
             add_missing_impl_members::add_missing_default_members,
-            reorder_fields::reorder_fields,
+            // Are you sure you want to add new assist here, and not to the
+            // sorted list above?
         ]
     }
 }
@@ -195,12 +199,12 @@ mod handlers {
 mod helpers {
     use std::sync::Arc;
 
+    use hir::Semantics;
     use ra_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
     use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
     use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
 
-    use crate::{AssistCtx, AssistFile, AssistHandler};
-    use hir::Semantics;
+    use crate::{handlers::Handler, AssistCtx, AssistFile};
 
     pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
         let (mut db, file_id) = RootDatabase::with_single_file(text);
@@ -210,22 +214,18 @@ mod helpers {
         (db, file_id)
     }
 
-    pub(crate) fn check_assist(
-        assist: AssistHandler,
-        ra_fixture_before: &str,
-        ra_fixture_after: &str,
-    ) {
+    pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
         check(assist, ra_fixture_before, ExpectedResult::After(ra_fixture_after));
     }
 
     // FIXME: instead of having a separate function here, maybe use
     // `extract_ranges` and mark the target as `<target> </target>` in the
     // fixuture?
-    pub(crate) fn check_assist_target(assist: AssistHandler, ra_fixture: &str, target: &str) {
+    pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
         check(assist, ra_fixture, ExpectedResult::Target(target));
     }
 
-    pub(crate) fn check_assist_not_applicable(assist: AssistHandler, ra_fixture: &str) {
+    pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
         check(assist, ra_fixture, ExpectedResult::NotApplicable);
     }
 
@@ -235,7 +235,7 @@ mod helpers {
         Target(&'a str),
     }
 
-    fn check(assist: AssistHandler, before: &str, expected: ExpectedResult) {
+    fn check(assist: Handler, before: &str, expected: ExpectedResult) {
         let (text_without_caret, file_with_caret_id, range_or_offset, db) =
             if before.contains("//-") {
                 let (mut db, position) = RootDatabase::with_position(before);
@@ -261,13 +261,13 @@ mod helpers {
             (Some(assist), ExpectedResult::After(after)) => {
                 let action = assist.0[0].action.clone().unwrap();
 
-                let assisted_file_text = if let AssistFile::TargetFile(file_id) = action.file {
+                let mut actual = if let AssistFile::TargetFile(file_id) = action.file {
                     db.file_text(file_id).as_ref().to_owned()
                 } else {
                     text_without_caret
                 };
+                action.edit.apply(&mut actual);
 
-                let mut actual = action.edit.apply(&assisted_file_text);
                 match action.cursor_position {
                     None => {
                         if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {

crates/ra_ide/src/completion/completion_context.rs

@@ -9,7 +9,7 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
-use ra_text_edit::AtomTextEdit;
+use ra_text_edit::Indel;
 
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
 
@@ -76,7 +76,7 @@ impl<'a> CompletionContext<'a> {
         // actual completion.
         let file_with_fake_ident = {
             let parse = db.parse(position.file_id);
-            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
+            let edit = Indel::insert(position.offset, "intellijRulezz".to_string());
             parse.reparse(&edit).tree()
         };
         let fake_ident_token =

crates/ra_ide/src/completion/completion_item.rs

@@ -62,8 +62,8 @@ impl fmt::Debug for CompletionItem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut s = f.debug_struct("CompletionItem");
         s.field("label", &self.label()).field("source_range", &self.source_range());
-        if self.text_edit().as_atoms().len() == 1 {
-            let atom = &self.text_edit().as_atoms()[0];
+        if self.text_edit().as_indels().len() == 1 {
+            let atom = &self.text_edit().as_indels()[0];
             s.field("delete", &atom.delete);
             s.field("insert", &atom.insert);
         } else {

crates/ra_ide/src/diagnostics.rs

@@ -241,7 +241,11 @@ mod tests {
             diagnostics.pop().unwrap_or_else(|| panic!("no diagnostics for:\n{}\n", before));
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
         assert_eq_text!(after, &actual);
     }
 
@@ -256,7 +260,11 @@ mod tests {
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_file_edits.pop().unwrap().edit;
         let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
-        let actual = edit.apply(&target_file_contents);
+        let actual = {
+            let mut actual = target_file_contents.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
 
         // Strip indent and empty lines from `after`, to match the behaviour of
         // `parse_fixture` called from `analysis_and_position`.
@@ -288,7 +296,11 @@ mod tests {
         let diagnostic = analysis.diagnostics(file_id).unwrap().pop().unwrap();
         let mut fix = diagnostic.fix.unwrap();
         let edit = fix.source_file_edits.pop().unwrap().edit;
-        let actual = edit.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            edit.apply(&mut actual);
+            actual
+        };
         assert_eq_text!(after, &actual);
     }
 
@@ -662,10 +674,10 @@ mod tests {
                                     1,
                                 ),
                                 edit: TextEdit {
-                                    atoms: [
-                                        AtomTextEdit {
-                                            delete: 3..9,
+                                    indels: [
+                                        Indel {
                                             insert: "{a:42, b: ()}",
+                                            delete: 3..9,
                                         },
                                     ],
                                 },

crates/ra_ide/src/join_lines.rs

@@ -569,7 +569,11 @@ fn foo() {
         let (sel, before) = extract_range(before);
         let parse = SourceFile::parse(&before);
         let result = join_lines(&parse.tree(), sel);
-        let actual = result.apply(&before);
+        let actual = {
+            let mut actual = before.to_string();
+            result.apply(&mut actual);
+            actual
+        };
         assert_eq_text!(after, &actual);
     }
 

crates/ra_ide/src/references/rename.rs

@@ -537,10 +537,10 @@ mod tests {
                                 2,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 4..7,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 4..7,
                                     },
                                 ],
                             },
@@ -589,10 +589,10 @@ mod tests {
                                 1,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 4..7,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 4..7,
                                     },
                                 ],
                             },
@@ -672,10 +672,10 @@ mod tests {
                                 2,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 8..11,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 8..11,
                                     },
                                 ],
                             },
@@ -685,10 +685,10 @@ mod tests {
                                 1,
                             ),
                             edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: 27..30,
+                                indels: [
+                                    Indel {
                                         insert: "foo2",
+                                        delete: 27..30,
                                     },
                                 ],
                             },
@@ -720,13 +720,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.as_indels() {
+                    text_edit_builder.replace(indel.delete, indel.insert.clone());
                 }
             }
         }
-        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);
     }
 }

crates/ra_ide/src/ssr.rs

@@ -401,16 +401,22 @@ fn render_replace(
     ignored_comments: &Vec<Comment>,
     template: &SsrTemplate,
 ) -> String {
-    let mut builder = TextEditBuilder::default();
-    for element in template.template.descendants() {
-        if let Some(var) = template.placeholders.get(&element) {
-            builder.replace(element.text_range(), binding[var].to_string())
+    let edit = {
+        let mut builder = TextEditBuilder::default();
+        for element in template.template.descendants() {
+            if let Some(var) = template.placeholders.get(&element) {
+                builder.replace(element.text_range(), binding[var].to_string())
+            }
         }
-    }
-    for comment in ignored_comments {
-        builder.insert(template.template.text_range().end(), comment.syntax().to_string())
-    }
-    builder.finish().apply(&template.template.text().to_string())
+        for comment in ignored_comments {
+            builder.insert(template.template.text_range().end(), comment.syntax().to_string())
+        }
+        builder.finish()
+    };
+
+    let mut text = template.template.text().to_string();
+    edit.apply(&mut text);
+    text
 }
 
 #[cfg(test)]
@@ -505,15 +511,19 @@ mod tests {
         );
 
         let edit = replace(&matches, &query.template);
-        assert_eq!(edit.apply(input), "fn main() { bar(1+2); }");
+        let mut after = input.to_string();
+        edit.apply(&mut after);
+        assert_eq!(after, "fn main() { bar(1+2); }");
     }
 
     fn assert_ssr_transform(query: &str, input: &str, result: &str) {
         let query: SsrQuery = query.parse().unwrap();
         let code = SourceFile::parse(input).tree();
         let matches = find(&query.pattern, code.syntax());
         let edit = replace(&matches, &query.template);
-        assert_eq!(edit.apply(input), result);
+        let mut after = input.to_string();
+        edit.apply(&mut after);
+        assert_eq!(after, result);
     }
 
     #[test]

crates/ra_ide/src/test_utils.rs

@@ -13,7 +13,11 @@ pub fn check_action<F: Fn(&SourceFile, TextSize) -> Option<TextEdit>>(
     let (before_cursor_pos, before) = extract_offset(before);
     let file = SourceFile::parse(&before).ok().unwrap();
     let result = f(&file, before_cursor_pos).expect("code action is not applicable");
-    let actual = result.apply(&before);
+    let actual = {
+        let mut actual = before.to_string();
+        result.apply(&mut actual);
+        actual
+    };
     let actual_cursor_pos =
         result.apply_to_offset(before_cursor_pos).expect("cursor position is affected by the edit");
     let actual = add_cursor(&actual, actual_cursor_pos);