language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-27 04:19:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Emit more concise text edits in ide_db::rename

Browse source
This commit is contained in:
Lukas Wirth 2021-08-17 15:24:01 +02:00
parent 995c8f50a2
commit daf3094958
2 changed files with 46 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

1
crates/ide/src/rename.rs
View file

@ -274,6 +274,7 @@ mod tests {
use super::{RangeInfo, RenameError}; use super::{RangeInfo, RenameError};
#[track_caller]
fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) { fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
let ra_fixture_after = &trim_indent(ra_fixture_after); let ra_fixture_after = &trim_indent(ra_fixture_after);
let (analysis, position) = fixture::position(ra_fixture_before); let (analysis, position) = fixture::position(ra_fixture_before);

89
crates/ide_db/src/rename.rs
View file

@ -30,7 +30,7 @@ use syntax::{
ast::{self, NameOwner}, ast::{self, NameOwner},
lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T, lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T,
}; };
use text_edit::TextEdit; use text_edit::{TextEdit, TextEditBuilder};
use crate::{ use crate::{
defs::Definition, defs::Definition,
@ -303,28 +303,29 @@ pub fn source_edit_from_references(
) -> TextEdit { ) -> TextEdit {
let mut edit = TextEdit::builder(); let mut edit = TextEdit::builder();
for reference in references { for reference in references {
let (range, replacement) = match &reference.name { let has_emitted_edit = match &reference.name {
// if the ranges differ then the node is inside a macro call, we can't really attempt // if the ranges differ then the node is inside a macro call, we can't really attempt
// to make special rewrites like shorthand syntax and such, so just rename the node in // to make special rewrites like shorthand syntax and such, so just rename the node in
// the macro input // the macro input
ast::NameLike::NameRef(name_ref) ast::NameLike::NameRef(name_ref)
if name_ref.syntax().text_range() == reference.range => if name_ref.syntax().text_range() == reference.range =>
{ {
source_edit_from_name_ref(name_ref, new_name, def) source_edit_from_name_ref(&mut edit, name_ref, new_name, def)
} }
ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => { ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
source_edit_from_name(name, new_name) source_edit_from_name(&mut edit, name, new_name)
} }
_ => None, _ => false,
};
if !has_emitted_edit {
edit.replace(reference.range, new_name.to_string());
} }
.unwrap_or_else(|| (reference.range, new_name.to_string()));
edit.replace(range, replacement);
} }
edit.finish() edit.finish()
} }
fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> { fn source_edit_from_name(edit: &mut TextEditBuilder, name: &ast::Name, new_name: &str) -> bool {
if let Some(_) = ast::RecordPatField::for_field_name(name) { if let Some(_) = ast::RecordPatField::for_field_name(name) {
if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) { if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
cov_mark::hit!(rename_record_pat_field_name_split); cov_mark::hit!(rename_record_pat_field_name_split);
@ -333,21 +334,20 @@ fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange,
// FIXME: instead of splitting the shorthand, recursively trigger a rename of the // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
// other name https://github.com/rust-analyzer/rust-analyzer/issues/6547 // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
return Some(( edit.insert(ident_pat.syntax().text_range().start(), format!("{}: ", new_name));
TextRange::empty(ident_pat.syntax().text_range().start()), return true;
format!("{}: ", new_name),
));
} }
} }
None false
} }
fn source_edit_from_name_ref( fn source_edit_from_name_ref(
edit: &mut TextEditBuilder,
name_ref: &ast::NameRef, name_ref: &ast::NameRef,
new_name: &str, new_name: &str,
def: Definition, def: Definition,
) -> Option<(TextRange, String)> { ) -> bool {
if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) { if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref(); let rcf_name_ref = record_field.name_ref();
let rcf_expr = record_field.expr(); let rcf_expr = record_field.expr();
@ -358,47 +358,48 @@ fn source_edit_from_name_ref(
if init.text() == new_name { if init.text() == new_name {
cov_mark::hit!(test_rename_field_put_init_shorthand); cov_mark::hit!(test_rename_field_put_init_shorthand);
// Foo { field: local } -> Foo { local } // Foo { field: local } -> Foo { local }
// ^^^^^^^^ delete this // ^^^^^^^ delete this
// FIXME: Actually delete this instead of replacing the entire thing
// same names, we can use a shorthand here instead. // same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start // we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start(); let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end(); let e = init.syntax().text_range().start();
return Some((TextRange::new(s, e), new_name.to_owned())); edit.delete(TextRange::new(s, e));
return true;
} }
} else if init == name_ref { } else if init == name_ref {
if field_name.text() == new_name { if field_name.text() == new_name {
cov_mark::hit!(test_rename_local_put_init_shorthand); cov_mark::hit!(test_rename_local_put_init_shorthand);
// Foo { field: local } -> Foo { field } // Foo { field: local } -> Foo { field }
// ^^^^^^^ delete this // ^^^^^^^ delete this
// FIXME: Actually delete this instead of replacing the entire thing
// same names, we can use a shorthand here instead. // same names, we can use a shorthand here instead.
// we do not want to erase attributes hence this range start // we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start(); let s = field_name.syntax().text_range().end();
let e = record_field.syntax().text_range().end(); let e = init.syntax().text_range().end();
return Some((TextRange::new(s, e), new_name.to_owned())); edit.delete(TextRange::new(s, e));
return true;
} }
} }
None
} }
// init shorthand // init shorthand
(None, Some(_)) if matches!(def, Definition::Field(_)) => { (None, Some(_)) if matches!(def, Definition::Field(_)) => {
cov_mark::hit!(test_rename_field_in_field_shorthand); cov_mark::hit!(test_rename_field_in_field_shorthand);
// Foo { field } -> Foo { new_name: field } // Foo { field } -> Foo { new_name: field }
// ^ insert `new_name: ` // ^ insert `new_name: `
let s = name_ref.syntax().text_range().start(); let offset = name_ref.syntax().text_range().start();
Some((TextRange::empty(s), format!("{}: ", new_name))) edit.insert(offset, format!("{}: ", new_name));
return true;
} }
(None, Some(_)) if matches!(def, Definition::Local(_)) => { (None, Some(_)) if matches!(def, Definition::Local(_)) => {
cov_mark::hit!(test_rename_local_in_field_shorthand); cov_mark::hit!(test_rename_local_in_field_shorthand);
// Foo { field } -> Foo { field: new_name } // Foo { field } -> Foo { field: new_name }
// ^ insert `: new_name` // ^ insert `: new_name`
let s = name_ref.syntax().text_range().end(); let offset = name_ref.syntax().text_range().end();
Some((TextRange::empty(s), format!(": {}", new_name))) edit.insert(offset, format!(": {}", new_name));
return true;
} }
_ => None, _ => (),
} }
} else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) { } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
let rcf_name_ref = record_field.name_ref(); let rcf_name_ref = record_field.name_ref();
@ -409,27 +410,27 @@ fn source_edit_from_name_ref(
if field_name == *name_ref && pat.at_token().is_none() => if field_name == *name_ref && pat.at_token().is_none() =>
{ {
// field name is being renamed // field name is being renamed
if pat.name().map_or(false, |it| it.text() == new_name) { if let Some(name) = pat.name() {
cov_mark::hit!(test_rename_field_put_init_shorthand_pat); if name.text() == new_name {
// Foo { field: ref mut local } -> Foo { ref mut field } cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
// ^^^^^^^ delete this // Foo { field: ref mut local } -> Foo { ref mut field }
// ^^^^^ replace this with `field` // ^^^^^^^ delete this
// FIXME: do this the way its written here // ^^^^^ replace this with `field`
// same names, we can use a shorthand here instead/ // same names, we can use a shorthand here instead/
// we do not want to erase attributes hence this range start // we do not want to erase attributes hence this range start
let s = field_name.syntax().text_range().start(); let s = field_name.syntax().text_range().start();
let e = record_field.syntax().text_range().end(); let e = pat.syntax().text_range().start();
Some((TextRange::new(s, e), pat.to_string())) edit.delete(TextRange::new(s, e));
} else { edit.replace(name.syntax().text_range(), new_name.to_string());
None return true;
}
} }
} }
_ => None, _ => (),
} }
} else {
None
} }
false
} }
fn source_edit_from_def( fn source_edit_from_def(