From 61e8403ee20a3ab7a3b6eec3362b70dabf4911e4 Mon Sep 17 00:00:00 2001 From: Tarek Date: Mon, 28 Oct 2024 20:09:52 +0300 Subject: [PATCH 01/12] feat: migrate introduce_named_generic assist to use SyntaxFactory Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 25 +++++++++++++++---- .../src/ast/syntax_factory/constructors.rs | 21 ++++++++++++++++ 2 files changed, 41 insertions(+), 5 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index bf6ac1719f31..8edcd6db3d16 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -1,8 +1,11 @@ use ide_db::syntax_helpers::suggest_name; use itertools::Itertools; use syntax::{ - ast::{self, edit_in_place::GenericParamsOwnerEdit, make, AstNode, HasGenericParams, HasName}, - ted, + ast::{ + self, edit_in_place::GenericParamsOwnerEdit, syntax_factory::SyntaxFactory, AstNode, + HasGenericParams, HasName, + }, + SyntaxElement, }; use crate::{AssistContext, AssistId, AssistKind, Assists}; @@ -25,12 +28,20 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let type_bound_list = impl_trait_type.type_bound_list()?; + // FIXME: Is this node appropriate to use for SyntaxEditor in this case? + let parent_node = match ctx.covering_element() { + SyntaxElement::Node(n) => n, + SyntaxElement::Token(t) => t.parent()?, + }; + let make = SyntaxFactory::new(); + let target = fn_.syntax().text_range(); acc.add( AssistId("introduce_named_generic", AssistKind::RefactorRewrite), "Replace impl trait with generic", target, |edit| { + let mut editor = edit.make_editor(&parent_node); let impl_trait_type = edit.make_mut(impl_trait_type); let fn_ = edit.make_mut(fn_); let fn_generic_param_list = fn_.get_or_create_generic_param_list(); @@ -47,11 +58,12 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> ) .for_impl_trait_as_generic(&impl_trait_type); - let type_param = make::type_param(make::name(&type_param_name), Some(type_bound_list)) + let type_param = make + .type_param(make.name(&type_param_name), Some(type_bound_list)) .clone_for_update(); - let new_ty = make::ty(&type_param_name).clone_for_update(); + let new_ty = make.ty(&type_param_name).clone_for_update(); - ted::replace(impl_trait_type.syntax(), new_ty.syntax()); + editor.replace(impl_trait_type.syntax(), new_ty.syntax()); fn_generic_param_list.add_generic_param(type_param.into()); if let Some(cap) = ctx.config.snippet_cap { @@ -61,6 +73,9 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> edit.add_tabstop_before(cap, generic_param); } } + + editor.add_mappings(make.finish_with_mappings()); + edit.add_file_edits(ctx.file_id(), editor); }, ) } diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs index 9f88add0f787..680ba9381dd6 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs @@ -14,6 +14,27 @@ impl SyntaxFactory { make::name(name).clone_for_update() } + pub fn ty(&self, text: &str) -> ast::Type { + // FIXME: Is there anything to map here? + make::ty(text).clone_for_update() + } + + pub fn type_param( + &self, + name: ast::Name, + bounds: Option, + ) -> ast::TypeParam { + let ast = make::type_param(name.clone(), bounds.clone()).clone_for_update(); + + if let Some(mut mapping) = self.mappings() { + let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone()); + builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone()); + builder.finish(&mut mapping); + } + + ast + } + pub fn ident_pat(&self, ref_: bool, mut_: bool, name: ast::Name) -> ast::IdentPat { let ast = make::ident_pat(ref_, mut_, name.clone()).clone_for_update(); From 7fa84a3f4b74b7ab68553b5e441dc951ce9050a5 Mon Sep 17 00:00:00 2001 From: Tarek Date: Mon, 28 Oct 2024 20:45:09 +0300 Subject: [PATCH 02/12] fix: remove make_mut from introduce_named_generic assist Signed-off-by: Tarek --- .../crates/ide-assists/src/handlers/introduce_named_generic.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index 8edcd6db3d16..cf9d58ca0d24 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -42,8 +42,6 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> target, |edit| { let mut editor = edit.make_editor(&parent_node); - let impl_trait_type = edit.make_mut(impl_trait_type); - let fn_ = edit.make_mut(fn_); let fn_generic_param_list = fn_.get_or_create_generic_param_list(); let existing_names = fn_generic_param_list From 797eb3ebe8b2fcd41f4b03ae7f8aa72f7a47e1a8 Mon Sep 17 00:00:00 2001 From: Tarek Date: Wed, 30 Oct 2024 17:56:02 +0300 Subject: [PATCH 03/12] define syntax_editor_add_generic_param Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 8 +++---- .../crates/syntax/src/ast/edit_in_place.rs | 24 +++++++++++++++++++ .../src/ast/syntax_factory/constructors.rs | 9 +++++-- 3 files changed, 34 insertions(+), 7 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index cf9d58ca0d24..ae30dacfd01f 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -56,13 +56,11 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> ) .for_impl_trait_as_generic(&impl_trait_type); - let type_param = make - .type_param(make.name(&type_param_name), Some(type_bound_list)) - .clone_for_update(); - let new_ty = make.ty(&type_param_name).clone_for_update(); + let type_param = make.type_param(make.name(&type_param_name), Some(type_bound_list)); + let new_ty = make.ty(&type_param_name); editor.replace(impl_trait_type.syntax(), new_ty.syntax()); - fn_generic_param_list.add_generic_param(type_param.into()); + fn_generic_param_list.syntax_editor_add_generic_param(&mut editor, type_param.into()); if let Some(cap) = ctx.config.snippet_cap { if let Some(generic_param) = diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index f1286e7aa213..2b152a45c9a3 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -7,6 +7,7 @@ use parser::{SyntaxKind, T}; use crate::{ algo::{self, neighbor}, ast::{self, edit::IndentLevel, make, HasGenericArgs, HasGenericParams}, + syntax_editor::SyntaxEditor, ted::{self, Position}, AstNode, AstToken, Direction, SyntaxElement, SyntaxKind::{ATTR, COMMENT, WHITESPACE}, @@ -257,6 +258,29 @@ impl ast::GenericParamList { } } + pub fn syntax_editor_add_generic_param( + &self, + editor: &mut SyntaxEditor, + generic_param: ast::GenericParam, + ) { + match self.generic_params().last() { + Some(last_param) => { + let position = crate::syntax_editor::Position::after(last_param.syntax()); + let elements = vec![ + make::token(T![,]).into(), + make::tokens::single_space().into(), + generic_param.syntax().clone().into(), + ]; + editor.insert_all(position, elements); + } + None => { + let after_l_angle = + crate::syntax_editor::Position::after(self.l_angle_token().unwrap()); + editor.insert(after_l_angle, generic_param.syntax()); + } + } + } + /// Removes the existing generic param pub fn remove_generic_param(&self, generic_param: ast::GenericParam) { if let Some(previous) = generic_param.syntax().prev_sibling() { diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs index 680ba9381dd6..35c467a1e8c8 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/syntax_factory/constructors.rs @@ -2,7 +2,7 @@ use itertools::Itertools; use crate::{ - ast::{self, make, HasName}, + ast::{self, make, HasName, HasTypeBounds}, syntax_editor::SyntaxMappingBuilder, AstNode, }; @@ -15,7 +15,6 @@ impl SyntaxFactory { } pub fn ty(&self, text: &str) -> ast::Type { - // FIXME: Is there anything to map here? make::ty(text).clone_for_update() } @@ -29,6 +28,12 @@ impl SyntaxFactory { if let Some(mut mapping) = self.mappings() { let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone()); builder.map_node(name.syntax().clone(), ast.name().unwrap().syntax().clone()); + if let Some(input) = bounds { + builder.map_node( + input.syntax().clone(), + ast.type_bound_list().unwrap().syntax().clone(), + ); + } builder.finish(&mut mapping); } From 54b597ccf24a67f8f2e82be50b7f47ae737aaa00 Mon Sep 17 00:00:00 2001 From: Tarek Date: Tue, 12 Nov 2024 19:18:26 +0200 Subject: [PATCH 04/12] fix: implement `syntax_editor_create_generic_param_list` Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 8 ++--- .../crates/syntax/src/ast/edit_in_place.rs | 32 +++++++++++++++++++ 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index ae30dacfd01f..c6945d6245e3 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -1,10 +1,7 @@ use ide_db::syntax_helpers::suggest_name; use itertools::Itertools; use syntax::{ - ast::{ - self, edit_in_place::GenericParamsOwnerEdit, syntax_factory::SyntaxFactory, AstNode, - HasGenericParams, HasName, - }, + ast::{self, syntax_factory::SyntaxFactory, AstNode, HasGenericParams, HasName}, SyntaxElement, }; @@ -42,7 +39,8 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> target, |edit| { let mut editor = edit.make_editor(&parent_node); - let fn_generic_param_list = fn_.get_or_create_generic_param_list(); + let fn_generic_param_list = + fn_.syntax_editor_get_or_create_generic_param_list(&mut editor); let existing_names = fn_generic_param_list .generic_params() diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 2b152a45c9a3..61580a5cae66 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -55,6 +55,29 @@ impl GenericParamsOwnerEdit for ast::Fn { } } +impl ast::Fn { + pub fn syntax_editor_get_or_create_generic_param_list( + &self, + editor: &mut SyntaxEditor, + ) -> ast::GenericParamList { + match self.generic_param_list() { + Some(it) => it, + None => { + let position = if let Some(name) = self.name() { + crate::syntax_editor::Position::after(name.syntax) + } else if let Some(fn_token) = self.fn_token() { + crate::syntax_editor::Position::after(fn_token) + } else if let Some(param_list) = self.param_list() { + crate::syntax_editor::Position::before(param_list.syntax) + } else { + crate::syntax_editor::Position::last_child_of(self.syntax()) + }; + syntax_editor_create_generic_param_list(editor, position) + } + } + } +} + impl GenericParamsOwnerEdit for ast::Impl { fn get_or_create_generic_param_list(&self) -> ast::GenericParamList { match self.generic_param_list() { @@ -191,6 +214,15 @@ fn create_generic_param_list(position: Position) -> ast::GenericParamList { gpl } +fn syntax_editor_create_generic_param_list( + editor: &mut SyntaxEditor, + position: crate::syntax_editor::Position, +) -> ast::GenericParamList { + let gpl = make::generic_param_list(empty()).clone_for_update(); + editor.insert(position, gpl.syntax()); + gpl +} + pub trait AttrsOwnerEdit: ast::HasAttrs { fn remove_attrs_and_docs(&self) { remove_attrs_and_docs(self.syntax()); From e275203e808353279d50d62ce8f4556acc0fd7ac Mon Sep 17 00:00:00 2001 From: Tarek Date: Fri, 22 Nov 2024 16:26:14 +0200 Subject: [PATCH 05/12] fix: refactor syntax_editor_add_generic_param to handle new generic parameters Signed-off-by: Tarek --- .../crates/syntax/src/ast/edit_in_place.rs | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 61580a5cae66..9a5c122e27c4 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -293,22 +293,21 @@ impl ast::GenericParamList { pub fn syntax_editor_add_generic_param( &self, editor: &mut SyntaxEditor, - generic_param: ast::GenericParam, + new_param: ast::GenericParam, ) { match self.generic_params().last() { - Some(last_param) => { - let position = crate::syntax_editor::Position::after(last_param.syntax()); - let elements = vec![ - make::token(T![,]).into(), - make::tokens::single_space().into(), - generic_param.syntax().clone().into(), - ]; - editor.insert_all(position, elements); + Some(_) => { + let mut params = + self.generic_params().map(|param| param.clone()).collect::>(); + params.push(new_param.into()); + let new_param_list = make::generic_param_list(params); + + editor.replace(self.syntax(), new_param_list.syntax()); } None => { - let after_l_angle = - crate::syntax_editor::Position::after(self.l_angle_token().unwrap()); - editor.insert(after_l_angle, generic_param.syntax()); + let position = crate::syntax_editor::Position::after(self.l_angle_token().unwrap()); + let new_param_list = make::generic_param_list(once(new_param.clone())); + editor.insert(position, new_param_list.syntax()); } } } From cfd5f7a40c4eb8b821feca1fd0c8f87c9982c47f Mon Sep 17 00:00:00 2001 From: Tarek Date: Wed, 27 Nov 2024 14:56:56 +0200 Subject: [PATCH 06/12] fix: refactor `syntax_editor_add_generic_param` to handle adding new generic parameters Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 23 +++---- .../crates/syntax/src/ast/edit_in_place.rs | 65 +++++++++---------- 2 files changed, 42 insertions(+), 46 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index c6945d6245e3..25628c1656a6 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -39,16 +39,17 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> target, |edit| { let mut editor = edit.make_editor(&parent_node); - let fn_generic_param_list = - fn_.syntax_editor_get_or_create_generic_param_list(&mut editor); - let existing_names = fn_generic_param_list - .generic_params() - .flat_map(|param| match param { - ast::GenericParam::TypeParam(t) => t.name().map(|name| name.to_string()), - p => Some(p.to_string()), - }) - .collect_vec(); + let existing_names = match fn_.generic_param_list() { + Some(generic_param_list) => generic_param_list + .generic_params() + .flat_map(|param| match param { + ast::GenericParam::TypeParam(t) => t.name().map(|name| name.to_string()), + p => Some(p.to_string()), + }) + .collect_vec(), + None => Vec::new(), + }; let type_param_name = suggest_name::NameGenerator::new_with_names( existing_names.iter().map(|s| s.as_str()), ) @@ -58,13 +59,13 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let new_ty = make.ty(&type_param_name); editor.replace(impl_trait_type.syntax(), new_ty.syntax()); - fn_generic_param_list.syntax_editor_add_generic_param(&mut editor, type_param.into()); + fn_.syntax_editor_add_generic_param(&mut editor, type_param.into()); if let Some(cap) = ctx.config.snippet_cap { if let Some(generic_param) = fn_.generic_param_list().and_then(|it| it.generic_params().last()) { - edit.add_tabstop_before(cap, generic_param); + editor.add_annotation(generic_param.syntax(), edit.make_tabstop_before(cap)); } } diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 9a5c122e27c4..360ee14fa289 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -56,13 +56,37 @@ impl GenericParamsOwnerEdit for ast::Fn { } impl ast::Fn { - pub fn syntax_editor_get_or_create_generic_param_list( + pub fn syntax_editor_add_generic_param( &self, editor: &mut SyntaxEditor, - ) -> ast::GenericParamList { + new_param: GenericParam, + ) { match self.generic_param_list() { - Some(it) => it, + Some(generic_param_list) => match generic_param_list.generic_params().last() { + Some(_last_param) => { + // There exists a generic param list and it's not empty + let mut params = generic_param_list + .generic_params() + .map(|param| param.clone()) + .collect::>(); + params.push(new_param.into()); + let new_param_list = make::generic_param_list(params); + editor.replace( + generic_param_list.syntax(), + new_param_list.syntax().clone_for_update(), + ); + } + None => { + // There exists a generic param list but it's empty + let position = crate::syntax_editor::Position::after( + generic_param_list.l_angle_token().unwrap(), + ); + + editor.insert(position, new_param.syntax()); + } + }, None => { + // There was no generic param list let position = if let Some(name) = self.name() { crate::syntax_editor::Position::after(name.syntax) } else if let Some(fn_token) = self.fn_token() { @@ -72,7 +96,9 @@ impl ast::Fn { } else { crate::syntax_editor::Position::last_child_of(self.syntax()) }; - syntax_editor_create_generic_param_list(editor, position) + + let new_param_list = make::generic_param_list(once(new_param.clone())); + editor.insert(position, new_param_list.syntax().clone_for_update()); } } } @@ -214,15 +240,6 @@ fn create_generic_param_list(position: Position) -> ast::GenericParamList { gpl } -fn syntax_editor_create_generic_param_list( - editor: &mut SyntaxEditor, - position: crate::syntax_editor::Position, -) -> ast::GenericParamList { - let gpl = make::generic_param_list(empty()).clone_for_update(); - editor.insert(position, gpl.syntax()); - gpl -} - pub trait AttrsOwnerEdit: ast::HasAttrs { fn remove_attrs_and_docs(&self) { remove_attrs_and_docs(self.syntax()); @@ -290,28 +307,6 @@ impl ast::GenericParamList { } } - pub fn syntax_editor_add_generic_param( - &self, - editor: &mut SyntaxEditor, - new_param: ast::GenericParam, - ) { - match self.generic_params().last() { - Some(_) => { - let mut params = - self.generic_params().map(|param| param.clone()).collect::>(); - params.push(new_param.into()); - let new_param_list = make::generic_param_list(params); - - editor.replace(self.syntax(), new_param_list.syntax()); - } - None => { - let position = crate::syntax_editor::Position::after(self.l_angle_token().unwrap()); - let new_param_list = make::generic_param_list(once(new_param.clone())); - editor.insert(position, new_param_list.syntax()); - } - } - } - /// Removes the existing generic param pub fn remove_generic_param(&self, generic_param: ast::GenericParam) { if let Some(previous) = generic_param.syntax().prev_sibling() { From e7fd49cfb42a75da9be5d4a8f4e674a884d7076c Mon Sep 17 00:00:00 2001 From: Tarek Date: Tue, 3 Dec 2024 23:47:52 +0200 Subject: [PATCH 07/12] fix: refactor `syntax_editor_add_generic_param` Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 9 ++-- .../crates/syntax/src/ast/edit_in_place.rs | 51 ++++++++++++++----- 2 files changed, 41 insertions(+), 19 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index 25628c1656a6..4b4433419a0e 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -59,14 +59,11 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let new_ty = make.ty(&type_param_name); editor.replace(impl_trait_type.syntax(), new_ty.syntax()); - fn_.syntax_editor_add_generic_param(&mut editor, type_param.into()); + let generic_param = syntax::ast::GenericParam::from(type_param); + fn_.syntax_editor_add_generic_param(&mut editor, generic_param.clone()); if let Some(cap) = ctx.config.snippet_cap { - if let Some(generic_param) = - fn_.generic_param_list().and_then(|it| it.generic_params().last()) - { - editor.add_annotation(generic_param.syntax(), edit.make_tabstop_before(cap)); - } + editor.add_annotation(generic_param.syntax(), edit.make_tabstop_before(cap)); } editor.add_mappings(make.finish_with_mappings()); diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 360ee14fa289..22afb8297b18 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -56,6 +56,7 @@ impl GenericParamsOwnerEdit for ast::Fn { } impl ast::Fn { + /// Adds a new generic param to the function using `SyntaxEditor` pub fn syntax_editor_add_generic_param( &self, editor: &mut SyntaxEditor, @@ -65,23 +66,44 @@ impl ast::Fn { Some(generic_param_list) => match generic_param_list.generic_params().last() { Some(_last_param) => { // There exists a generic param list and it's not empty - let mut params = generic_param_list - .generic_params() - .map(|param| param.clone()) - .collect::>(); - params.push(new_param.into()); - let new_param_list = make::generic_param_list(params); - editor.replace( - generic_param_list.syntax(), - new_param_list.syntax().clone_for_update(), + let position = generic_param_list.r_angle_token().map_or_else( + || crate::syntax_editor::Position::last_child_of(self.syntax()), + crate::syntax_editor::Position::before, ); + + if let Some(last_param) = generic_param_list.generic_params().last() { + if last_param + .syntax() + .next_sibling_or_token() + .map_or(false, |it| it.kind() == SyntaxKind::COMMA) + { + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + new_param.syntax().clone(), + ); + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + make::token(SyntaxKind::WHITESPACE), + ); + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + make::token(SyntaxKind::COMMA), + ); + } else { + let elements = vec![ + make::token(SyntaxKind::COMMA).into(), + make::token(SyntaxKind::WHITESPACE).into(), + new_param.syntax().clone().into(), + ]; + editor.insert_all(position, elements); + } + }; } None => { // There exists a generic param list but it's empty let position = crate::syntax_editor::Position::after( generic_param_list.l_angle_token().unwrap(), ); - editor.insert(position, new_param.syntax()); } }, @@ -96,9 +118,12 @@ impl ast::Fn { } else { crate::syntax_editor::Position::last_child_of(self.syntax()) }; - - let new_param_list = make::generic_param_list(once(new_param.clone())); - editor.insert(position, new_param_list.syntax().clone_for_update()); + let elements = vec![ + make::token(SyntaxKind::L_ANGLE).into(), + new_param.syntax().clone().into(), + make::token(T![>]).into(), + ]; + editor.insert_all(position, elements); } } } From d453198999ad34232b0d3c9adf4769ae7a417ea2 Mon Sep 17 00:00:00 2001 From: Tarek Date: Tue, 3 Dec 2024 23:57:11 +0200 Subject: [PATCH 08/12] fix: correct token type for closing angle bracket Signed-off-by: Tarek --- src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 22afb8297b18..dcaeed40073c 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -121,7 +121,7 @@ impl ast::Fn { let elements = vec![ make::token(SyntaxKind::L_ANGLE).into(), new_param.syntax().clone().into(), - make::token(T![>]).into(), + make::token(SyntaxKind::R_ANGLE).into(), ]; editor.insert_all(position, elements); } From b1e0d3122173fff7635e144add3b363578b5c147 Mon Sep 17 00:00:00 2001 From: Tarek Date: Wed, 4 Dec 2024 14:32:48 +0200 Subject: [PATCH 09/12] fix: refactor `introduce_named_generic` assist Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 19 ++----- .../crates/syntax/src/ast/edit_in_place.rs | 54 +++++++++---------- 2 files changed, 31 insertions(+), 42 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index 4b4433419a0e..1edbd01b0200 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -1,9 +1,6 @@ use ide_db::syntax_helpers::suggest_name; use itertools::Itertools; -use syntax::{ - ast::{self, syntax_factory::SyntaxFactory, AstNode, HasGenericParams, HasName}, - SyntaxElement, -}; +use syntax::ast::{self, syntax_factory::SyntaxFactory, AstNode, HasGenericParams, HasName}; use crate::{AssistContext, AssistId, AssistKind, Assists}; @@ -25,20 +22,14 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let type_bound_list = impl_trait_type.type_bound_list()?; - // FIXME: Is this node appropriate to use for SyntaxEditor in this case? - let parent_node = match ctx.covering_element() { - SyntaxElement::Node(n) => n, - SyntaxElement::Token(t) => t.parent()?, - }; let make = SyntaxFactory::new(); - let target = fn_.syntax().text_range(); acc.add( AssistId("introduce_named_generic", AssistKind::RefactorRewrite), "Replace impl trait with generic", target, - |edit| { - let mut editor = edit.make_editor(&parent_node); + |builder| { + let mut editor = builder.make_editor(fn_.syntax()); let existing_names = match fn_.generic_param_list() { Some(generic_param_list) => generic_param_list @@ -63,11 +54,11 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> fn_.syntax_editor_add_generic_param(&mut editor, generic_param.clone()); if let Some(cap) = ctx.config.snippet_cap { - editor.add_annotation(generic_param.syntax(), edit.make_tabstop_before(cap)); + editor.add_annotation(generic_param.syntax(), builder.make_tabstop_before(cap)); } editor.add_mappings(make.finish_with_mappings()); - edit.add_file_edits(ctx.file_id(), editor); + builder.add_file_edits(ctx.file_id(), editor); }, ) } diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index dcaeed40073c..68447a6a2715 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -64,40 +64,38 @@ impl ast::Fn { ) { match self.generic_param_list() { Some(generic_param_list) => match generic_param_list.generic_params().last() { - Some(_last_param) => { + Some(last_param) => { // There exists a generic param list and it's not empty let position = generic_param_list.r_angle_token().map_or_else( || crate::syntax_editor::Position::last_child_of(self.syntax()), crate::syntax_editor::Position::before, ); - if let Some(last_param) = generic_param_list.generic_params().last() { - if last_param - .syntax() - .next_sibling_or_token() - .map_or(false, |it| it.kind() == SyntaxKind::COMMA) - { - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - new_param.syntax().clone(), - ); - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - make::token(SyntaxKind::WHITESPACE), - ); - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - make::token(SyntaxKind::COMMA), - ); - } else { - let elements = vec![ - make::token(SyntaxKind::COMMA).into(), - make::token(SyntaxKind::WHITESPACE).into(), - new_param.syntax().clone().into(), - ]; - editor.insert_all(position, elements); - } - }; + if last_param + .syntax() + .next_sibling_or_token() + .map_or(false, |it| it.kind() == SyntaxKind::COMMA) + { + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + new_param.syntax().clone(), + ); + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + make::token(SyntaxKind::WHITESPACE), + ); + editor.insert( + crate::syntax_editor::Position::after(last_param.syntax()), + make::token(SyntaxKind::COMMA), + ); + } else { + let elements = vec![ + make::token(SyntaxKind::COMMA).into(), + make::token(SyntaxKind::WHITESPACE).into(), + new_param.syntax().clone().into(), + ]; + editor.insert_all(position, elements); + } } None => { // There exists a generic param list but it's empty From 60e0e02a21b0a018d4cab937772f657e49afad4e Mon Sep 17 00:00:00 2001 From: Tarek Date: Wed, 4 Dec 2024 14:51:48 +0200 Subject: [PATCH 10/12] refactor: move editing for ast using `SyntaxEditor` to a separate file Signed-off-by: Tarek --- .../src/handlers/introduce_named_generic.rs | 2 +- .../crates/syntax/src/ast/edit_in_place.rs | 73 ------------------- .../crates/syntax/src/syntax_editor.rs | 1 + .../crates/syntax/src/syntax_editor/edits.rs | 72 ++++++++++++++++++ 4 files changed, 74 insertions(+), 74 deletions(-) create mode 100644 src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index 1edbd01b0200..ecc96f791d4a 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -51,7 +51,7 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> editor.replace(impl_trait_type.syntax(), new_ty.syntax()); let generic_param = syntax::ast::GenericParam::from(type_param); - fn_.syntax_editor_add_generic_param(&mut editor, generic_param.clone()); + editor.syntax_editor_add_generic_param(fn_, generic_param.clone()); if let Some(cap) = ctx.config.snippet_cap { editor.add_annotation(generic_param.syntax(), builder.make_tabstop_before(cap)); diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 68447a6a2715..f1286e7aa213 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -7,7 +7,6 @@ use parser::{SyntaxKind, T}; use crate::{ algo::{self, neighbor}, ast::{self, edit::IndentLevel, make, HasGenericArgs, HasGenericParams}, - syntax_editor::SyntaxEditor, ted::{self, Position}, AstNode, AstToken, Direction, SyntaxElement, SyntaxKind::{ATTR, COMMENT, WHITESPACE}, @@ -55,78 +54,6 @@ impl GenericParamsOwnerEdit for ast::Fn { } } -impl ast::Fn { - /// Adds a new generic param to the function using `SyntaxEditor` - pub fn syntax_editor_add_generic_param( - &self, - editor: &mut SyntaxEditor, - new_param: GenericParam, - ) { - match self.generic_param_list() { - Some(generic_param_list) => match generic_param_list.generic_params().last() { - Some(last_param) => { - // There exists a generic param list and it's not empty - let position = generic_param_list.r_angle_token().map_or_else( - || crate::syntax_editor::Position::last_child_of(self.syntax()), - crate::syntax_editor::Position::before, - ); - - if last_param - .syntax() - .next_sibling_or_token() - .map_or(false, |it| it.kind() == SyntaxKind::COMMA) - { - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - new_param.syntax().clone(), - ); - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - make::token(SyntaxKind::WHITESPACE), - ); - editor.insert( - crate::syntax_editor::Position::after(last_param.syntax()), - make::token(SyntaxKind::COMMA), - ); - } else { - let elements = vec![ - make::token(SyntaxKind::COMMA).into(), - make::token(SyntaxKind::WHITESPACE).into(), - new_param.syntax().clone().into(), - ]; - editor.insert_all(position, elements); - } - } - None => { - // There exists a generic param list but it's empty - let position = crate::syntax_editor::Position::after( - generic_param_list.l_angle_token().unwrap(), - ); - editor.insert(position, new_param.syntax()); - } - }, - None => { - // There was no generic param list - let position = if let Some(name) = self.name() { - crate::syntax_editor::Position::after(name.syntax) - } else if let Some(fn_token) = self.fn_token() { - crate::syntax_editor::Position::after(fn_token) - } else if let Some(param_list) = self.param_list() { - crate::syntax_editor::Position::before(param_list.syntax) - } else { - crate::syntax_editor::Position::last_child_of(self.syntax()) - }; - let elements = vec![ - make::token(SyntaxKind::L_ANGLE).into(), - new_param.syntax().clone().into(), - make::token(SyntaxKind::R_ANGLE).into(), - ]; - editor.insert_all(position, elements); - } - } - } -} - impl GenericParamsOwnerEdit for ast::Impl { fn get_or_create_generic_param_list(&self) -> ast::GenericParamList { match self.generic_param_list() { diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs index 714f5a991114..7e5d0f27e0a0 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor.rs @@ -16,6 +16,7 @@ use rustc_hash::FxHashMap; use crate::{SyntaxElement, SyntaxNode, SyntaxToken}; mod edit_algo; +mod edits; mod mapping; pub use mapping::{SyntaxMapping, SyntaxMappingBuilder}; diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs new file mode 100644 index 000000000000..759b46c9c795 --- /dev/null +++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs @@ -0,0 +1,72 @@ +//! Structural editing for ast using `SyntaxEditor` + +use crate::{ + ast::make, ast::AstNode, ast::Fn, ast::GenericParam, ast::HasGenericParams, ast::HasName, + syntax_editor::Position, syntax_editor::SyntaxEditor, SyntaxKind, +}; + +impl SyntaxEditor { + /// Adds a new generic param to the function using `SyntaxEditor` + pub fn syntax_editor_add_generic_param(&mut self, function: Fn, new_param: GenericParam) { + match function.generic_param_list() { + Some(generic_param_list) => match generic_param_list.generic_params().last() { + Some(last_param) => { + // There exists a generic param list and it's not empty + let position = generic_param_list.r_angle_token().map_or_else( + || Position::last_child_of(function.syntax()), + Position::before, + ); + + if last_param + .syntax() + .next_sibling_or_token() + .map_or(false, |it| it.kind() == SyntaxKind::COMMA) + { + self.insert( + Position::after(last_param.syntax()), + new_param.syntax().clone(), + ); + self.insert( + Position::after(last_param.syntax()), + make::token(SyntaxKind::WHITESPACE), + ); + self.insert( + Position::after(last_param.syntax()), + make::token(SyntaxKind::COMMA), + ); + } else { + let elements = vec![ + make::token(SyntaxKind::COMMA).into(), + make::token(SyntaxKind::WHITESPACE).into(), + new_param.syntax().clone().into(), + ]; + self.insert_all(position, elements); + } + } + None => { + // There exists a generic param list but it's empty + let position = Position::after(generic_param_list.l_angle_token().unwrap()); + self.insert(position, new_param.syntax()); + } + }, + None => { + // There was no generic param list + let position = if let Some(name) = function.name() { + Position::after(name.syntax) + } else if let Some(fn_token) = function.fn_token() { + Position::after(fn_token) + } else if let Some(param_list) = function.param_list() { + Position::before(param_list.syntax) + } else { + Position::last_child_of(function.syntax()) + }; + let elements = vec![ + make::token(SyntaxKind::L_ANGLE).into(), + new_param.syntax().clone().into(), + make::token(SyntaxKind::R_ANGLE).into(), + ]; + self.insert_all(position, elements); + } + } + } +} From 6120a8ad0bc93b756fab12e1ae2a9c25700d1d85 Mon Sep 17 00:00:00 2001 From: Tarek Date: Wed, 4 Dec 2024 16:02:03 +0200 Subject: [PATCH 11/12] fix: update `introduce_named_generic` to use `type_param` directly Signed-off-by: Tarek --- .../ide-assists/src/handlers/introduce_named_generic.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index ecc96f791d4a..28023ce5edbf 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -50,11 +50,10 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let new_ty = make.ty(&type_param_name); editor.replace(impl_trait_type.syntax(), new_ty.syntax()); - let generic_param = syntax::ast::GenericParam::from(type_param); - editor.syntax_editor_add_generic_param(fn_, generic_param.clone()); + editor.syntax_editor_add_generic_param(fn_, type_param.clone().into()); if let Some(cap) = ctx.config.snippet_cap { - editor.add_annotation(generic_param.syntax(), builder.make_tabstop_before(cap)); + editor.add_annotation(type_param.syntax(), builder.make_tabstop_before(cap)); } editor.add_mappings(make.finish_with_mappings()); From 0a99a9f05f3c13fbb4fc972b6d7e6d868af14beb Mon Sep 17 00:00:00 2001 From: Tarek Date: Thu, 5 Dec 2024 13:50:43 +0200 Subject: [PATCH 12/12] fix: rename `syntax_editor_add_generic_param` to `add_generic_param` Signed-off-by: Tarek --- .../crates/ide-assists/src/handlers/introduce_named_generic.rs | 2 +- .../rust-analyzer/crates/syntax/src/syntax_editor/edits.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs index 28023ce5edbf..8c276415bb1f 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/introduce_named_generic.rs @@ -50,7 +50,7 @@ pub(crate) fn introduce_named_generic(acc: &mut Assists, ctx: &AssistContext<'_> let new_ty = make.ty(&type_param_name); editor.replace(impl_trait_type.syntax(), new_ty.syntax()); - editor.syntax_editor_add_generic_param(fn_, type_param.clone().into()); + editor.add_generic_param(&fn_, type_param.clone().into()); if let Some(cap) = ctx.config.snippet_cap { editor.add_annotation(type_param.syntax(), builder.make_tabstop_before(cap)); diff --git a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs index 759b46c9c795..73196f5cb1be 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/syntax_editor/edits.rs @@ -7,7 +7,7 @@ use crate::{ impl SyntaxEditor { /// Adds a new generic param to the function using `SyntaxEditor` - pub fn syntax_editor_add_generic_param(&mut self, function: Fn, new_param: GenericParam) { + pub fn add_generic_param(&mut self, function: &Fn, new_param: GenericParam) { match function.generic_param_list() { Some(generic_param_list) => match generic_param_list.generic_params().last() { Some(last_param) => {