feat: migrate sort_items assist to use SyntaxFactory

Signed-off-by: Tarek <tareknaser360@gmail.com>

Author: tareknaser

crates/ide-assists/src/handlers/sort_items.rs

@@ -4,7 +4,7 @@ use itertools::Itertools;
 
 use syntax::{
     ast::{self, HasName},
-    ted, AstNode, TextRange,
+    AstNode, TextRange,
 };
 
 use crate::{utils::get_methods, AssistContext, AssistId, AssistKind, Assists};
@@ -88,17 +88,17 @@ pub(crate) fn sort_items(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
     }
 
     if let Some(struct_ast) = ctx.find_node_at_offset::<ast::Struct>() {
-        add_sort_field_list_assist(acc, struct_ast.field_list())
+        add_sort_field_list_assist(acc, ctx, struct_ast.field_list())
     } else if let Some(union_ast) = ctx.find_node_at_offset::<ast::Union>() {
-        add_sort_fields_assist(acc, union_ast.record_field_list()?)
+        add_sort_fields_assist(acc, ctx, union_ast.record_field_list()?)
     } else if let Some(variant_ast) = ctx.find_node_at_offset::<ast::Variant>() {
-        add_sort_field_list_assist(acc, variant_ast.field_list())
+        add_sort_field_list_assist(acc, ctx, variant_ast.field_list())
     } else if let Some(enum_struct_variant_ast) = ctx.find_node_at_offset::<ast::RecordFieldList>()
     {
         // should be above enum and below struct
-        add_sort_fields_assist(acc, enum_struct_variant_ast)
+        add_sort_fields_assist(acc, ctx, enum_struct_variant_ast)
     } else if let Some(enum_ast) = ctx.find_node_at_offset::<ast::Enum>() {
-        add_sort_variants_assist(acc, enum_ast.variant_list()?)
+        add_sort_variants_assist(acc, ctx, enum_ast.variant_list()?)
     } else if let Some(trait_ast) = ctx.find_node_at_offset::<ast::Trait>() {
         add_sort_methods_assist(acc, ctx, trait_ast.assoc_item_list()?)
     } else if let Some(impl_ast) = ctx.find_node_at_offset::<ast::Impl>() {
@@ -111,6 +111,7 @@ pub(crate) fn sort_items(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
 trait AddRewrite {
     fn add_rewrite<T: AstNode>(
         &mut self,
+        ctx: &AssistContext<'_>,
         label: &str,
         old: Vec<T>,
         new: Vec<T>,
@@ -121,24 +122,33 @@ trait AddRewrite {
 impl AddRewrite for Assists {
     fn add_rewrite<T: AstNode>(
         &mut self,
+        ctx: &AssistContext<'_>,
         label: &str,
         old: Vec<T>,
         new: Vec<T>,
         target: TextRange,
     ) -> Option<()> {
+        let node = old.first().unwrap().syntax().parent().unwrap();
         self.add(AssistId("sort_items", AssistKind::RefactorRewrite), label, target, |builder| {
-            let mutable: Vec<T> = old.into_iter().map(|it| builder.make_mut(it)).collect();
-            mutable
-                .into_iter()
-                .zip(new)
-                .for_each(|(old, new)| ted::replace(old.syntax(), new.clone_for_update().syntax()));
+            let mut editor = builder.make_editor(&node);
+
+            old.into_iter().zip(new).for_each(|(old, new)| {
+                // FIXME: remove `clone_for_update` when `SyntaxEditor` handles it for us
+                editor.replace(old.syntax(), new.clone_for_update().syntax())
+            });
+
+            builder.add_file_edits(ctx.file_id(), editor)
         })
     }
 }
 
-fn add_sort_field_list_assist(acc: &mut Assists, field_list: Option<ast::FieldList>) -> Option<()> {
+fn add_sort_field_list_assist(
+    acc: &mut Assists,
+    ctx: &AssistContext<'_>,
+    field_list: Option<ast::FieldList>,
+) -> Option<()> {
     match field_list {
-        Some(ast::FieldList::RecordFieldList(it)) => add_sort_fields_assist(acc, it),
+        Some(ast::FieldList::RecordFieldList(it)) => add_sort_fields_assist(acc, ctx, it),
         _ => {
             cov_mark::hit!(not_applicable_if_sorted_or_empty_or_single);
             None
@@ -167,11 +177,18 @@ fn add_sort_methods_assist(
         return None;
     }
 
-    acc.add_rewrite("Sort methods alphabetically", methods, sorted, item_list.syntax().text_range())
+    acc.add_rewrite(
+        ctx,
+        "Sort methods alphabetically",
+        methods,
+        sorted,
+        item_list.syntax().text_range(),
+    )
 }
 
 fn add_sort_fields_assist(
     acc: &mut Assists,
+    ctx: &AssistContext<'_>,
     record_field_list: ast::RecordFieldList,
 ) -> Option<()> {
     let fields: Vec<_> = record_field_list.fields().collect();
@@ -183,14 +200,19 @@ fn add_sort_fields_assist(
     }
 
     acc.add_rewrite(
+        ctx,
         "Sort fields alphabetically",
         fields,
         sorted,
         record_field_list.syntax().text_range(),
     )
 }
 
-fn add_sort_variants_assist(acc: &mut Assists, variant_list: ast::VariantList) -> Option<()> {
+fn add_sort_variants_assist(
+    acc: &mut Assists,
+    ctx: &AssistContext<'_>,
+    variant_list: ast::VariantList,
+) -> Option<()> {
     let variants: Vec<_> = variant_list.variants().collect();
     let sorted = sort_by_name(&variants);
 
@@ -200,6 +222,7 @@ fn add_sort_variants_assist(acc: &mut Assists, variant_list: ast::VariantList) -
     }
 
     acc.add_rewrite(
+        ctx,
         "Sort variants alphabetically",
         variants,
         sorted,