rust-analyzer

diff --git a/crates/ide-assists/src/handlers/extract_type_alias.rs b/crates/ide-assists/src/handlers/extract_type_alias.rs
index a654b681d1..ecb031e42d 100644
--- a/crates/ide-assists/src/handlers/extract_type_alias.rs
+++ b/crates/ide-assists/src/handlers/extract_type_alias.rs

@@ -75,7 +75,7 @@ pub(crate) fn extract_type_alias(acc: &mut Assists, ctx: &AssistContext<'_, '_>)

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 ty_args = generic_params.as_ref().map(|it| it.to_generic_args(make).generic_args());

let new_ty = if let Some(ty_args) = ty_args {

make.generic_ty_path_segment(make.name_ref(name), ty_args)

} else {

diff --git a/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs b/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs
index 3902ee170e..4454e47013 100644
--- a/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs
+++ b/crates/ide-assists/src/handlers/generate_blanket_trait_impl.rs

@@ -89,7 +89,7 @@ pub(crate) fn generate_blanket_trait_impl(

))]);

let trait_gen_args =

- traitd.generic_param_list().map(|param_list| param_list.to_generic_args());

+ traitd.generic_param_list().map(|param_list| param_list.to_generic_args(make));

let body = traitd.assoc_item_list().and_then(|trait_assoc_list| {

let items = trait_assoc_list

diff --git a/crates/ide-assists/src/handlers/generate_delegate_methods.rs b/crates/ide-assists/src/handlers/generate_delegate_methods.rs
index a209e5fc29..b5c6aec0bb 100644
--- a/crates/ide-assists/src/handlers/generate_delegate_methods.rs
+++ b/crates/ide-assists/src/handlers/generate_delegate_methods.rs

@@ -195,7 +195,7 @@ pub(crate) fn generate_delegate_methods(

None => {

let name = &strukt_name.to_string();

let ty_params = strukt.generic_param_list();

- let ty_args = ty_params.as_ref().map(|it| it.to_generic_args());

+ let ty_args = ty_params.as_ref().map(|it| it.to_generic_args(make));

let where_clause = strukt.where_clause();

let assoc_item_list = make.assoc_item_list(vec![item]);

diff --git a/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
index ed15998219..e21f1ab359 100644
--- a/crates/ide-assists/src/handlers/generate_delegate_trait.rs
+++ b/crates/ide-assists/src/handlers/generate_delegate_trait.rs

@@ -274,9 +274,9 @@ fn generate_impl(

None,

delegee.is_unsafe(db),

bound_params.clone(),

- bound_params.map(|params| params.to_generic_args()),

+ bound_params.map(|params| params.to_generic_args(&make)),

strukt_params.clone(),

- strukt_params.map(|params| params.to_generic_args()),

+ strukt_params.map(|params| params.to_generic_args(&make)),

delegee.is_auto(db),

make.ty(&delegee.name(db).display_no_db(edition).to_smolstr()),

strukt_ty,

@@ -318,7 +318,7 @@ fn generate_impl(

let strukt_params = resolve_name_conflicts(strukt_params, &old_impl_params);

let (field_ty, ty_where_clause) = match &strukt_params {

Some(strukt_params) => {

- let args = strukt_params.to_generic_args();

+ let args = strukt_params.to_generic_args(&make);

let field_ty = rename_strukt_args(ctx, ast_strukt, field_ty, &args)?;

let where_clause = ast_strukt

.where_clause()

@@ -349,6 +349,7 @@ fn generate_impl(

// 2.2) Generate generic args applied on impl.

let (transform_args, trait_gen_params) = generate_args_for_impl(

+ &make,

old_impl_params,

&old_impl.self_ty()?,

&field_ty,

@@ -375,7 +376,7 @@ fn generate_impl(

}

});

- let type_gen_args = strukt_params.clone().map(|params| params.to_generic_args());

+ let type_gen_args = strukt_params.clone().map(|params| params.to_generic_args(&make));

let path_type = make.ty(&trait_.name(db).display_no_db(edition).to_smolstr());

let path_type = transform_impl(ctx, ast_strukt, &old_impl, &transform_args, path_type)?;

// 3) Generate delegate trait impl

@@ -593,13 +594,15 @@ fn finalize_delegate(

// While the last two generic args `B` and `C` doesn't change, it remains

// `<B, C>`. So we apply `<T, B, C>` as generic arguments to impl.

fn generate_args_for_impl(

+ make: &SyntaxFactory,

old_impl_gpl: Option<GenericParamList>,

self_ty: &ast::Type,

field_ty: &ast::Type,

trait_params: Option<GenericParamList>,

old_trait_args: &FxHashSet<String>,

) -> (Option<ast::GenericArgList>, Option<GenericParamList>) {

- let Some(old_impl_args) = old_impl_gpl.map(|gpl| gpl.to_generic_args().generic_args()) else {

+ let Some(old_impl_args) = old_impl_gpl.map(|gpl| gpl.to_generic_args(make).generic_args())

+ else {

return (None, trait_params);

};

diff --git a/crates/ide-assists/src/handlers/generate_getter_or_setter.rs b/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
index c8ab54474c..7e5d5cec71 100644
--- a/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
+++ b/crates/ide-assists/src/handlers/generate_getter_or_setter.rs

@@ -458,7 +458,7 @@ fn build_source_change(

let make = editor.make();

let items = items(ctx, info_of_record_fields, &assist_info, make);

let ty_params = assist_info.strukt.generic_param_list();

- let ty_args = ty_params.as_ref().map(|it| it.to_generic_args());

+ let ty_args = ty_params.as_ref().map(|it| it.to_generic_args(make));

let impl_def = make.impl_(

None,

ty_params,

diff --git a/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
index 23c7b2b7c8..4348dfa212 100644
--- a/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
+++ b/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs

@@ -87,7 +87,7 @@ pub(crate) fn generate_single_field_struct_from(

let indent = strukt.indent_level();

let ty_where_clause = strukt.where_clause();

let type_gen_params = strukt.generic_param_list();

- let type_gen_args = type_gen_params.as_ref().map(|params| params.to_generic_args());

+ let type_gen_args = type_gen_params.as_ref().map(|params| params.to_generic_args(make));

let trait_gen_args = Some(make.generic_arg_list(

[ast::GenericArg::TypeArg(make.type_arg(main_field_ty.clone()))],

false,

diff --git a/crates/ide-assists/src/handlers/generate_trait_from_impl.rs b/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
index d5f0eb234c..2493ba6632 100644
--- a/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
+++ b/crates/ide-assists/src/handlers/generate_trait_from_impl.rs

@@ -134,7 +134,7 @@ pub(crate) fn generate_trait_from_impl(

];

if let Some(params) = impl_ast.generic_param_list() {

- let gen_args = &params.to_generic_args();

+ let gen_args = &params.to_generic_args(make);

elements.insert(1, gen_args.syntax().clone().into());

}

diff --git a/crates/ide-assists/src/utils.rs b/crates/ide-assists/src/utils.rs
index 9d3af35ee5..7251b0e1ff 100644
--- a/crates/ide-assists/src/utils.rs
+++ b/crates/ide-assists/src/utils.rs

@@ -630,8 +630,7 @@ fn generate_impl_inner(

make.generic_param_list(itertools::chain(lifetime_params, ty_or_const_params))

});

- let generic_args =

- generic_params.as_ref().map(|params| params.to_generic_args().clone_for_update());

+ let generic_args = generic_params.as_ref().map(|params| params.to_generic_args(make));

let adt_assoc_bounds = trait_

.as_ref()

.zip(generic_params.as_ref())

diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index a893f65dc3..7d7c875508 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs

@@ -9,7 +9,7 @@ use crate::{

SyntaxKind::{ATTR, COMMENT, WHITESPACE},

SyntaxNode, SyntaxToken,

algo::{self, neighbor},

- ast::{self, edit::IndentLevel, make},

+ ast::{self, edit::IndentLevel, make, syntax_factory::SyntaxFactory},

syntax_editor::{self, SyntaxEditor},

ted,

};

@@ -43,33 +43,18 @@ pub trait AttrsOwnerEdit: ast::HasAttrs {

impl<T: ast::HasAttrs> AttrsOwnerEdit for T {}

impl ast::GenericParamList {

- /// Removes the existing generic param

- pub fn remove_generic_param(&self, generic_param: ast::GenericParam) {

- if let Some(previous) = generic_param.syntax().prev_sibling() {

- if let Some(next_token) = previous.next_sibling_or_token() {

- ted::remove_all(next_token..=generic_param.syntax().clone().into());

- }

- } else if let Some(next) = generic_param.syntax().next_sibling() {

- if let Some(next_token) = next.prev_sibling_or_token() {

- ted::remove_all(generic_param.syntax().clone().into()..=next_token);

- }

- } else {

- ted::remove(generic_param.syntax());

- }

/// Constructs a matching [`ast::GenericArgList`]

- pub fn to_generic_args(&self) -> ast::GenericArgList {

+ pub fn to_generic_args(&self, make: &SyntaxFactory) -> ast::GenericArgList {

let args = self.generic_params().filter_map(|param| match param {

ast::GenericParam::LifetimeParam(it) => {

- Some(ast::GenericArg::LifetimeArg(make::lifetime_arg(it.lifetime()?)))

+ Some(ast::GenericArg::LifetimeArg(make.lifetime_arg(it.lifetime()?)))

}

ast::GenericParam::TypeParam(it) => {

- Some(ast::GenericArg::TypeArg(make::type_arg(make::ext::ty_name(it.name()?))))

+ Some(ast::GenericArg::TypeArg(make.type_arg(make.ty_name(it.name()?))))

}

ast::GenericParam::ConstParam(it) => {

// Name-only const params get parsed as `TypeArg`s

- Some(ast::GenericArg::TypeArg(make::type_arg(make::ext::ty_name(it.name()?))))

+ Some(ast::GenericArg::TypeArg(make.type_arg(make.ty_name(it.name()?))))

}

});

diff --git a/crates/syntax/src/ast/syntax_factory/constructors.rs b/crates/syntax/src/ast/syntax_factory/constructors.rs
index bebf595f00..f5a88e40ea 100644
--- a/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/crates/syntax/src/ast/syntax_factory/constructors.rs

@@ -2229,6 +2229,21 @@ impl SyntaxFactory {

make::ext::field_from_idents(parts)

}

+ pub fn ty_name(&self, name: ast::Name) -> ast::Type {

+ let ast = make::ext::ty_name(name.clone()).clone_for_update();

+ if let Some(mut mapping) = self.mappings()

+ && let ast::Type::PathType(path_ty) = &ast

+ && let Some(name_ref) = path_ty.path().and_then(|path| path.segment()?.name_ref())

+ {

+ let mut builder = SyntaxMappingBuilder::new(name_ref.syntax().parent().unwrap());

+ builder.map_node(name.syntax().clone(), name_ref.syntax().clone());

+ builder.finish(&mut mapping);

+ }

+ ast

+ }

pub fn expr_await(&self, expr: ast::Expr) -> ast::AwaitExpr {

let ast::Expr::AwaitExpr(ast) = make::expr_await(expr.clone()).clone_for_update() else {

unreachable!()