Merge pull request #21734 from Shourya742/2026-03-02-migrate-already-migrated-assist-to-syntaxFactory

Replace make to syntax factory from already migrated syntax factory assist

Author: A4-Tacks

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

@@ -2,7 +2,7 @@ use either::Either;
 use ide_db::defs::{Definition, NameRefClass};
 use syntax::{
     AstNode,
-    ast::{self, HasArgList, HasGenericArgs, make, syntax_factory::SyntaxFactory},
+    ast::{self, HasArgList, HasGenericArgs, syntax_factory::SyntaxFactory},
     syntax_editor::Position,
 };
 
@@ -94,20 +94,21 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 ident.text_range(),
                 |builder| {
                     let mut editor = builder.make_editor(let_stmt.syntax());
+                    let make = SyntaxFactory::without_mappings();
 
                     if let_stmt.semicolon_token().is_none() {
                         editor.insert(
                             Position::last_child_of(let_stmt.syntax()),
-                            make::tokens::semicolon(),
+                            make.token(syntax::SyntaxKind::SEMICOLON),
                         );
                     }
 
-                    let placeholder_ty = make::ty_placeholder().clone_for_update();
+                    let placeholder_ty = make.ty_placeholder();
 
                     if let Some(pat) = let_stmt.pat() {
                         let elements = vec![
-                            make::token(syntax::SyntaxKind::COLON).into(),
-                            make::token(syntax::SyntaxKind::WHITESPACE).into(),
+                            make.token(syntax::SyntaxKind::COLON).into(),
+                            make.whitespace(" ").into(),
                             placeholder_ty.syntax().clone().into(),
                         ];
                         editor.insert_all(Position::after(pat.syntax()), elements);
@@ -188,7 +189,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
 
 /// This will create a turbofish generic arg list corresponding to the number of arguments
 fn get_fish_head(make: &SyntaxFactory, number_of_arguments: usize) -> ast::GenericArgList {
-    let args = (0..number_of_arguments).map(|_| make::type_arg(make::ty_placeholder()).into());
+    let args = (0..number_of_arguments).map(|_| make.type_arg(make.ty_placeholder()).into());
     make.generic_arg_list(args, true)
 }
 

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

@@ -12,9 +12,10 @@ use ide_db::{
 };
 use itertools::Itertools;
 use syntax::ast::edit::AstNodeEdit;
+use syntax::ast::syntax_factory::SyntaxFactory;
 use syntax::{
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T,
-    ast::{self, HasName, edit::IndentLevel, make},
+    ast::{self, HasName, edit::IndentLevel},
 };
 
 use crate::{
@@ -62,19 +63,28 @@ pub(crate) fn convert_bool_to_enum(acc: &mut Assists, ctx: &AssistContext<'_>) -
         "Convert boolean to enum",
         target,
         |edit| {
+            let make = SyntaxFactory::without_mappings();
             if let Some(ty) = &ty_annotation {
                 cov_mark::hit!(replaces_ty_annotation);
                 edit.replace(ty.syntax().text_range(), "Bool");
             }
 
             if let Some(initializer) = initializer {
-                replace_bool_expr(edit, initializer);
+                replace_bool_expr(edit, initializer, &make);
             }
 
             let usages = definition.usages(&ctx.sema).all();
-            add_enum_def(edit, ctx, &usages, target_node, &target_module);
+            add_enum_def(edit, ctx, &usages, target_node, &target_module, &make);
             let mut delayed_mutations = Vec::new();
-            replace_usages(edit, ctx, usages, definition, &target_module, &mut delayed_mutations);
+            replace_usages(
+                edit,
+                ctx,
+                usages,
+                definition,
+                &target_module,
+                &mut delayed_mutations,
+                &make,
+            );
             for (scope, path) in delayed_mutations {
                 insert_use(&scope, path, &ctx.config.insert_use);
             }
@@ -168,16 +178,16 @@ fn find_bool_node(ctx: &AssistContext<'_>) -> Option<BoolNodeData> {
     }
 }
 
-fn replace_bool_expr(edit: &mut SourceChangeBuilder, expr: ast::Expr) {
+fn replace_bool_expr(edit: &mut SourceChangeBuilder, expr: ast::Expr, make: &SyntaxFactory) {
     let expr_range = expr.syntax().text_range();
-    let enum_expr = bool_expr_to_enum_expr(expr);
+    let enum_expr = bool_expr_to_enum_expr(expr, make);
     edit.replace(expr_range, enum_expr.syntax().text())
 }
 
 /// Converts an expression of type `bool` to one of the new enum type.
-fn bool_expr_to_enum_expr(expr: ast::Expr) -> ast::Expr {
-    let true_expr = make::expr_path(make::path_from_text("Bool::True"));
-    let false_expr = make::expr_path(make::path_from_text("Bool::False"));
+fn bool_expr_to_enum_expr(expr: ast::Expr, make: &SyntaxFactory) -> ast::Expr {
+    let true_expr = make.expr_path(make.path_from_text("Bool::True"));
+    let false_expr = make.expr_path(make.path_from_text("Bool::False"));
 
     if let ast::Expr::Literal(literal) = &expr {
         match literal.kind() {
@@ -186,10 +196,10 @@ fn bool_expr_to_enum_expr(expr: ast::Expr) -> ast::Expr {
             _ => expr,
         }
     } else {
-        make::expr_if(
+        make.expr_if(
             expr,
-            make::tail_only_block_expr(true_expr),
-            Some(ast::ElseBranch::Block(make::tail_only_block_expr(false_expr))),
+            make.tail_only_block_expr(true_expr),
+            Some(ast::ElseBranch::Block(make.tail_only_block_expr(false_expr))),
         )
         .into()
     }
@@ -203,11 +213,13 @@ fn replace_usages(
     target_definition: Definition,
     target_module: &hir::Module,
     delayed_mutations: &mut Vec<(ImportScope, ast::Path)>,
+    make: &SyntaxFactory,
 ) {
     for (file_id, references) in usages {
         edit.edit_file(file_id.file_id(ctx.db()));
 
-        let refs_with_imports = augment_references_with_imports(ctx, references, target_module);
+        let refs_with_imports =
+            augment_references_with_imports(ctx, references, target_module, make);
 
         refs_with_imports.into_iter().rev().for_each(
             |FileReferenceWithImport { range, name, import_data }| {
@@ -224,12 +236,13 @@ fn replace_usages(
                             target_definition,
                             target_module,
                             delayed_mutations,
+                            make,
                         )
                     }
                 } else if let Some(initializer) = find_assignment_usage(&name) {
                     cov_mark::hit!(replaces_assignment);
 
-                    replace_bool_expr(edit, initializer);
+                    replace_bool_expr(edit, initializer, make);
                 } else if let Some((prefix_expr, inner_expr)) = find_negated_usage(&name) {
                     cov_mark::hit!(replaces_negation);
 
@@ -247,7 +260,7 @@ fn replace_usages(
                 {
                     cov_mark::hit!(replaces_record_expr);
 
-                    let enum_expr = bool_expr_to_enum_expr(initializer);
+                    let enum_expr = bool_expr_to_enum_expr(initializer, make);
                     utils::replace_record_field_expr(ctx, edit, record_field, enum_expr);
                 } else if let Some(pat) = find_record_pat_field_usage(&name) {
                     match pat {
@@ -263,6 +276,7 @@ fn replace_usages(
                                     target_definition,
                                     target_module,
                                     delayed_mutations,
+                                    make,
                                 )
                             }
                         }
@@ -272,14 +286,14 @@ fn replace_usages(
                             if let Some(expr) = literal_pat.literal().and_then(|literal| {
                                 literal.syntax().ancestors().find_map(ast::Expr::cast)
                             }) {
-                                replace_bool_expr(edit, expr);
+                                replace_bool_expr(edit, expr, make);
                             }
                         }
                         _ => (),
                     }
                 } else if let Some((ty_annotation, initializer)) = find_assoc_const_usage(&name) {
                     edit.replace(ty_annotation.syntax().text_range(), "Bool");
-                    replace_bool_expr(edit, initializer);
+                    replace_bool_expr(edit, initializer, make);
                 } else if let Some(receiver) = find_method_call_expr_usage(&name) {
                     edit.replace(
                         receiver.syntax().text_range(),
@@ -296,10 +310,10 @@ fn replace_usages(
                             ctx,
                             edit,
                             record_field,
-                            make::expr_bin_op(
+                            make.expr_bin_op(
                                 expr,
                                 ast::BinaryOp::CmpOp(ast::CmpOp::Eq { negated: false }),
-                                make::expr_path(make::path_from_text("Bool::True")),
+                                make.expr_path(make.path_from_text("Bool::True")),
                             ),
                         );
                     } else {
@@ -327,6 +341,7 @@ fn augment_references_with_imports(
     ctx: &AssistContext<'_>,
     references: Vec<FileReference>,
     target_module: &hir::Module,
+    make: &SyntaxFactory,
 ) -> Vec<FileReferenceWithImport> {
     let mut visited_modules = FxHashSet::default();
 
@@ -357,9 +372,9 @@ fn augment_references_with_imports(
                                 cfg,
                             )
                             .map(|mod_path| {
-                                make::path_concat(
+                                make.path_concat(
                                     mod_path_to_ast(&mod_path, edition),
-                                    make::path_from_text("Bool"),
+                                    make.path_from_text("Bool"),
                                 )
                             })?;
 
@@ -458,6 +473,7 @@ fn add_enum_def(
     usages: &UsageSearchResult,
     target_node: SyntaxNode,
     target_module: &hir::Module,
+    make: &SyntaxFactory,
 ) -> Option<()> {
     let insert_before = node_to_insert_before(target_node);
 
@@ -482,7 +498,7 @@ fn add_enum_def(
         .any(|module| module.nearest_non_block_module(ctx.db()) != *target_module);
 
     let indent = IndentLevel::from_node(&insert_before);
-    let enum_def = make_bool_enum(make_enum_pub).reset_indent().indent(indent);
+    let enum_def = make_bool_enum(make_enum_pub, make).reset_indent().indent(indent);
 
     edit.insert(
         insert_before.text_range().start(),
@@ -504,31 +520,30 @@ fn node_to_insert_before(target_node: SyntaxNode) -> SyntaxNode {
         .unwrap_or(target_node)
 }
 
-fn make_bool_enum(make_pub: bool) -> ast::Enum {
-    let derive_eq = make::attr_outer(make::meta_token_tree(
-        make::ext::ident_path("derive"),
-        make::token_tree(
+fn make_bool_enum(make_pub: bool, make: &SyntaxFactory) -> ast::Enum {
+    let derive_eq = make.attr_outer(make.meta_token_tree(
+        make.ident_path("derive"),
+        make.token_tree(
             T!['('],
             vec![
-                NodeOrToken::Token(make::tokens::ident("PartialEq")),
-                NodeOrToken::Token(make::token(T![,])),
-                NodeOrToken::Token(make::tokens::single_space()),
-                NodeOrToken::Token(make::tokens::ident("Eq")),
+                NodeOrToken::Token(make.ident("PartialEq")),
+                NodeOrToken::Token(make.token(T![,])),
+                NodeOrToken::Token(make.whitespace(" ")),
+                NodeOrToken::Token(make.ident("Eq")),
             ],
         ),
     ));
-    make::enum_(
+    make.enum_(
         [derive_eq],
-        if make_pub { Some(make::visibility_pub()) } else { None },
-        make::name("Bool"),
+        if make_pub { Some(make.visibility_pub()) } else { None },
+        make.name("Bool"),
         None,
         None,
-        make::variant_list(vec![
-            make::variant(None, make::name("True"), None, None),
-            make::variant(None, make::name("False"), None, None),
+        make.variant_list(vec![
+            make.variant(None, make.name("True"), None, None),
+            make.variant(None, make.name("False"), None, None),
         ]),
     )
-    .clone_for_update()
 }
 
 #[cfg(test)]

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

@@ -2,7 +2,10 @@ use either::Either;
 use hir::HirDisplay;
 use ide_db::syntax_helpers::node_ext::walk_ty;
 use syntax::{
-    ast::{self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel, make},
+    ast::{
+        self, AstNode, HasGenericArgs, HasGenericParams, HasName, edit::IndentLevel,
+        syntax_factory::SyntaxFactory,
+    },
     syntax_editor,
 };
 
@@ -43,10 +46,9 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let resolved_ty = ctx.sema.resolve_type(&ty)?;
     let resolved_ty = if !resolved_ty.contains_unknown() {
         let module = ctx.sema.scope(ty.syntax())?.module();
-        let resolved_ty = resolved_ty.display_source_code(ctx.db(), module.into(), false).ok()?;
-        make::ty(&resolved_ty)
+        resolved_ty.display_source_code(ctx.db(), module.into(), false).ok()?
     } else {
-        ty.clone()
+        ty.to_string()
     };
 
     acc.add(
@@ -55,6 +57,9 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         target,
         |builder| {
             let mut edit = builder.make_editor(node);
+            let make = SyntaxFactory::without_mappings();
+
+            let resolved_ty = make.ty(&resolved_ty);
 
             let mut known_generics = match item.generic_param_list() {
                 Some(it) => it.generic_params().collect(),
@@ -68,22 +73,20 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             }
             let generics = collect_used_generics(&ty, &known_generics);
             let generic_params =
-                generics.map(|it| make::generic_param_list(it.into_iter().cloned()));
+                generics.map(|it| make.generic_param_list(it.into_iter().cloned()));
 
             // Replace original type with the alias
             let ty_args = generic_params.as_ref().map(|it| it.to_generic_args().generic_args());
             let new_ty = if let Some(ty_args) = ty_args {
-                make::generic_ty_path_segment(make::name_ref("Type"), ty_args)
+                make.generic_ty_path_segment(make.name_ref("Type"), ty_args)
             } else {
-                make::path_segment(make::name_ref("Type"))
-            }
-            .clone_for_update();
+                make.path_segment(make.name_ref("Type"))
+            };
             edit.replace(ty.syntax(), new_ty.syntax());
 
             // Insert new alias
             let ty_alias =
-                make::ty_alias(None, "Type", generic_params, None, None, Some((resolved_ty, None)))
-                    .clone_for_update();
+                make.ty_alias(None, "Type", generic_params, None, None, Some((resolved_ty, None)));
 
             if let Some(cap) = ctx.config.snippet_cap
                 && let Some(name) = ty_alias.name()
@@ -96,7 +99,7 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_>) ->
                 syntax_editor::Position::before(node),
                 vec![
                     ty_alias.syntax().clone().into(),
-                    make::tokens::whitespace(&format!("\n\n{indent}")).into(),
+                    make.whitespace(&format!("\n\n{indent}")).into(),
                 ],
             );