Merge pull request #21886 from Shourya742/2026-03-26-migrate-gen-trait-fn-body

Replace make constructor with syntaxFactory in utils/gen trait fn body

Author: A4-Tacks

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

@@ -1,16 +1,16 @@
 use hir::HasSource;
 use syntax::{
     Edition,
-    ast::{self, AstNode, make},
+    ast::{self, AstNode, syntax_factory::SyntaxFactory},
     syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
     utils::{
-        DefaultMethods, IgnoreAssocItems, add_trait_assoc_items_to_impl, filter_assoc_items,
-        gen_trait_fn_body,
+        DefaultMethods, IgnoreAssocItems, add_trait_assoc_items_to_impl_with_factory,
+        filter_assoc_items, gen_trait_fn_body,
     },
 };
 
@@ -148,7 +148,9 @@ fn add_missing_impl_members_inner(
 
     let target = impl_def.syntax().text_range();
     acc.add(AssistId::quick_fix(assist_id), label, target, |edit| {
-        let new_item = add_trait_assoc_items_to_impl(
+        let make = SyntaxFactory::with_mappings();
+        let new_item = add_trait_assoc_items_to_impl_with_factory(
+            &make,
             &ctx.sema,
             ctx.config,
             &missing_items,
@@ -164,6 +166,7 @@ fn add_missing_impl_members_inner(
         let mut first_new_item = if let DefaultMethods::No = mode
             && let ast::AssocItem::Fn(func) = &first_new_item
             && let Some(body) = try_gen_trait_body(
+                &make,
                 ctx,
                 func,
                 trait_ref,
@@ -189,10 +192,10 @@ fn add_missing_impl_members_inner(
         if let Some(assoc_item_list) = impl_def.assoc_item_list() {
             assoc_item_list.add_items(&mut editor, new_assoc_items);
         } else {
-            let assoc_item_list = make::assoc_item_list(Some(new_assoc_items)).clone_for_update();
+            let assoc_item_list = make.assoc_item_list(new_assoc_items);
             editor.insert_all(
                 Position::after(impl_def.syntax()),
-                vec![make::tokens::whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
+                vec![make.whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
             );
             first_new_item = assoc_item_list.assoc_items().next();
         }
@@ -215,23 +218,24 @@ fn add_missing_impl_members_inner(
                 editor.add_annotation(first_new_item.syntax(), tabstop);
             };
         };
+        editor.add_mappings(make.finish_with_mappings());
         edit.add_file_edits(ctx.vfs_file_id(), editor);
     })
 }
 
 fn try_gen_trait_body(
+    make: &SyntaxFactory,
     ctx: &AssistContext<'_>,
     func: &ast::Fn,
     trait_ref: hir::TraitRef<'_>,
     impl_def: &ast::Impl,
     edition: Edition,
 ) -> Option<ast::BlockExpr> {
-    let trait_path = make::ext::ident_path(
-        &trait_ref.trait_().name(ctx.db()).display(ctx.db(), edition).to_string(),
-    );
+    let trait_path =
+        make.ident_path(&trait_ref.trait_().name(ctx.db()).display(ctx.db(), edition).to_string());
     let hir_ty = ctx.sema.resolve_type(&impl_def.self_ty()?)?;
     let adt = hir_ty.as_adt()?.source(ctx.db())?;
-    gen_trait_fn_body(func, &trait_path, &adt.value, Some(trait_ref))
+    gen_trait_fn_body(make, func, &trait_path, &adt.value, Some(trait_ref))
 }
 
 #[cfg(test)]

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

@@ -13,7 +13,7 @@ use crate::{
     assist_context::{AssistContext, Assists},
     utils::{
         DefaultMethods, IgnoreAssocItems, add_trait_assoc_items_to_impl_with_factory,
-        filter_assoc_items, gen_trait_fn_body, generate_trait_impl,
+        filter_assoc_items, gen_trait_fn_body, generate_trait_impl, generate_trait_impl_with_item,
     },
 };
 
@@ -127,7 +127,7 @@ fn add_assist(
     let label = format!("Convert to manual `impl {replace_trait_path} for {annotated_name}`");
 
     acc.add(AssistId::refactor("replace_derive_with_manual_impl"), label, target, |builder| {
-        let make = SyntaxFactory::without_mappings();
+        let make = SyntaxFactory::with_mappings();
         let insert_after = Position::after(adt.syntax());
         let impl_is_unsafe = trait_.map(|s| s.is_unsafe(ctx.db())).unwrap_or(false);
         let impl_def = impl_def_from_trait(
@@ -141,7 +141,7 @@ fn add_assist(
         );
 
         let mut editor = builder.make_editor(attr.syntax());
-        update_attribute(&mut editor, old_derives, old_tree, old_trait_path, attr);
+        update_attribute(&make, &mut editor, old_derives, old_tree, old_trait_path, attr);
 
         let trait_path = make.ty_path(replace_trait_path.clone()).into();
 
@@ -177,6 +177,7 @@ fn add_assist(
             insert_after,
             vec![make.whitespace("\n\n").into(), impl_def.syntax().clone().into()],
         );
+        editor.add_mappings(make.finish_with_mappings());
         builder.add_file_edits(ctx.vfs_file_id(), editor);
     })
 }
@@ -207,8 +208,8 @@ fn impl_def_from_trait(
         return None;
     }
     let make = SyntaxFactory::without_mappings();
-    let trait_ty = make.ty_path(trait_path.clone()).into();
-    let impl_def = generate_trait_impl(&make, impl_is_unsafe, adt, trait_ty);
+    let trait_ty: ast::Type = make.ty_path(trait_path.clone()).into();
+    let impl_def = generate_trait_impl(&make, impl_is_unsafe, adt, trait_ty.clone());
 
     let assoc_items = add_trait_assoc_items_to_impl_with_factory(
         &make,
@@ -223,7 +224,7 @@ fn impl_def_from_trait(
         assoc_items.split_first().map(|(first, other)| (first.clone_subtree(), other))
     {
         let first_item = if let ast::AssocItem::Fn(ref func) = first
-            && let Some(body) = gen_trait_fn_body(func, trait_path, adt, None)
+            && let Some(body) = gen_trait_fn_body(&make, func, trait_path, adt, None)
             && let Some(func_body) = func.body()
         {
             let mut editor = SyntaxEditor::new(first.syntax().clone());
@@ -239,21 +240,17 @@ fn impl_def_from_trait(
         make.assoc_item_list_empty()
     };
 
-    let impl_def = impl_def.clone_subtree();
-    let mut editor = SyntaxEditor::new(impl_def.syntax().clone());
-    editor.replace(impl_def.assoc_item_list()?.syntax(), assoc_item_list.syntax());
-    let impl_def = ast::Impl::cast(editor.finish().new_root().clone())?;
-    Some(impl_def)
+    Some(generate_trait_impl_with_item(&make, impl_is_unsafe, adt, trait_ty, assoc_item_list))
 }
 
 fn update_attribute(
+    make: &SyntaxFactory,
     editor: &mut SyntaxEditor,
     old_derives: &[ast::Path],
     old_tree: &ast::TokenTree,
     old_trait_path: &ast::Path,
     attr: &ast::Attr,
 ) {
-    let make = SyntaxFactory::without_mappings();
     let new_derives = old_derives
         .iter()
         .filter(|t| t.to_string() != old_trait_path.to_string())

crates/ide-assists/src/utils.rs

@@ -758,6 +758,16 @@ pub(crate) fn generate_trait_impl_intransitive_with_item(
     generate_impl_inner_with_factory(make, false, adt, Some(trait_), false, Some(body))
 }
 
+pub(crate) fn generate_trait_impl_with_item(
+    make: &SyntaxFactory,
+    is_unsafe: bool,
+    adt: &ast::Adt,
+    trait_: ast::Type,
+    body: ast::AssocItemList,
+) -> ast::Impl {
+    generate_impl_inner_with_factory(make, is_unsafe, adt, Some(trait_), true, Some(body))
+}
+
 fn generate_impl_inner(
     is_unsafe: bool,
     adt: &ast::Adt,