X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fide_db%2Fsrc%2Frename.rs;h=589975406a4ffa2354ad726c3eed365760bf1b22;hb=3dd581b97d051e091037abca62564630d51bfea8;hp=d7760245351951c6eaf67156b2b216cf8c287661;hpb=9fb67e7477a43fc91946f17c00205b7e31db00d8;p=rust.git diff --git a/crates/ide_db/src/rename.rs b/crates/ide_db/src/rename.rs index d7760245351..589975406a4 100644 --- a/crates/ide_db/src/rename.rs +++ b/crates/ide_db/src/rename.rs @@ -10,7 +10,7 @@ //! //! Another can of worms are macros: //! -//! ``` +//! ```ignore //! macro_rules! m { () => { fn f() {} } } //! m!(); //! fn main() { @@ -27,15 +27,16 @@ use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics}; use stdx::never; use syntax::{ - ast::{self, NameOwner}, - lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T, + ast::{self, HasName}, + AstNode, SyntaxKind, TextRange, T, }; -use text_edit::TextEdit; +use text_edit::{TextEdit, TextEditBuilder}; use crate::{ defs::Definition, search::FileReference, source_change::{FileSystemEdit, SourceChange}, + syntax_helpers::node_ext::expr_as_name_ref, RootDatabase, }; @@ -66,10 +67,8 @@ macro_rules! _bail { impl Definition { pub fn rename(&self, sema: &Semantics, new_name: &str) -> Result { match *self { - Definition::ModuleDef(hir::ModuleDef::Module(module)) => { - rename_mod(sema, module, new_name) - } - Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => { + Definition::Module(module) => rename_mod(sema, module, new_name), + Definition::BuiltinType(_) => { bail!("Cannot rename builtin type") } Definition::SelfType(_) => bail!("Cannot rename `Self`"), @@ -80,15 +79,7 @@ pub fn rename(&self, sema: &Semantics, new_name: &str) -> Result) -> Option { - // FIXME: the `original_file_range` calls here are wrong -- they never fail, - // and _fall back_ to the entirety of the macro call. Such fall back is - // incorrect for renames. The safe behavior would be to return an error for - // such cases. The correct behavior would be to return an auxiliary list of - // "can't rename these occurrences in macros" items, and then show some kind - // of a dialog to the user. See: - cov_mark::hit!(macros_are_broken_lol); - + pub fn range_for_rename(self, sema: &Semantics) -> Option { let res = match self { Definition::Macro(mac) => { let src = mac.source(sema.db)?; @@ -96,82 +87,81 @@ pub fn rename_range(self, sema: &Semantics) -> Option { Either::Left(it) => it.name()?, Either::Right(it) => it.name()?, }; - src.with_value(name.syntax()).original_file_range(sema.db) + src.with_value(name.syntax()).original_file_range_opt(sema.db) } Definition::Field(field) => { let src = field.source(sema.db)?; - match &src.value { FieldSource::Named(record_field) => { let name = record_field.name()?; - src.with_value(name.syntax()).original_file_range(sema.db) - } - FieldSource::Pos(_) => { - return None; + src.with_value(name.syntax()).original_file_range_opt(sema.db) } + FieldSource::Pos(_) => None, } } - Definition::ModuleDef(module_def) => match module_def { - hir::ModuleDef::Module(module) => { - let src = module.declaration_source(sema.db)?; - let name = src.value.name()?; - src.with_value(name.syntax()).original_file_range(sema.db) - } - hir::ModuleDef::Function(it) => name_range(it, sema)?, - hir::ModuleDef::Adt(adt) => match adt { - hir::Adt::Struct(it) => name_range(it, sema)?, - hir::Adt::Union(it) => name_range(it, sema)?, - hir::Adt::Enum(it) => name_range(it, sema)?, - }, - hir::ModuleDef::Variant(it) => name_range(it, sema)?, - hir::ModuleDef::Const(it) => name_range(it, sema)?, - hir::ModuleDef::Static(it) => name_range(it, sema)?, - hir::ModuleDef::Trait(it) => name_range(it, sema)?, - hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?, - hir::ModuleDef::BuiltinType(_) => return None, + Definition::Module(module) => { + let src = module.declaration_source(sema.db)?; + let name = src.value.name()?; + src.with_value(name.syntax()).original_file_range_opt(sema.db) + } + Definition::Function(it) => name_range(it, sema), + Definition::Adt(adt) => match adt { + hir::Adt::Struct(it) => name_range(it, sema), + hir::Adt::Union(it) => name_range(it, sema), + hir::Adt::Enum(it) => name_range(it, sema), }, - Definition::SelfType(_) => return None, + Definition::Variant(it) => name_range(it, sema), + Definition::Const(it) => name_range(it, sema), + Definition::Static(it) => name_range(it, sema), + Definition::Trait(it) => name_range(it, sema), + Definition::TypeAlias(it) => name_range(it, sema), Definition::Local(local) => { let src = local.source(sema.db); let name = match &src.value { Either::Left(bind_pat) => bind_pat.name()?, Either::Right(_) => return None, }; - src.with_value(name.syntax()).original_file_range(sema.db) + src.with_value(name.syntax()).original_file_range_opt(sema.db) } Definition::GenericParam(generic_param) => match generic_param { - hir::GenericParam::TypeParam(type_param) => { - let src = type_param.source(sema.db)?; - let name = match &src.value { - Either::Left(_) => return None, - Either::Right(type_param) => type_param.name()?, - }; - src.with_value(name.syntax()).original_file_range(sema.db) - } hir::GenericParam::LifetimeParam(lifetime_param) => { let src = lifetime_param.source(sema.db)?; - let lifetime = src.value.lifetime()?; - src.with_value(lifetime.syntax()).original_file_range(sema.db) + src.with_value(src.value.lifetime()?.syntax()).original_file_range_opt(sema.db) + } + _ => { + let x = match generic_param { + hir::GenericParam::TypeParam(it) => it.merge(), + hir::GenericParam::ConstParam(it) => it.merge(), + hir::GenericParam::LifetimeParam(_) => return None, + }; + let src = x.source(sema.db)?; + let name = match &src.value { + Either::Left(x) => x.name()?, + Either::Right(_) => return None, + }; + src.with_value(name.syntax()).original_file_range_opt(sema.db) } - hir::GenericParam::ConstParam(it) => name_range(it, sema)?, }, Definition::Label(label) => { let src = label.source(sema.db); let lifetime = src.value.lifetime()?; - src.with_value(lifetime.syntax()).original_file_range(sema.db) + src.with_value(lifetime.syntax()).original_file_range_opt(sema.db) } + Definition::BuiltinType(_) => return None, + Definition::SelfType(_) => return None, + Definition::BuiltinAttr(_) => return None, + Definition::ToolModule(_) => return None, }; - return Some(res); + return res; fn name_range(def: D, sema: &Semantics) -> Option where D: HasSource, - D::Ast: ast::NameOwner, + D::Ast: ast::HasName, { let src = def.source(sema.db)?; let name = src.value.name()?; - let res = src.with_value(name.syntax()).original_file_range(sema.db); - Some(res) + src.with_value(name.syntax()).original_file_range_opt(sema.db) } } } @@ -188,30 +178,43 @@ fn rename_mod( let mut source_change = SourceChange::default(); let InFile { file_id, value: def_source } = module.definition_source(sema.db); - let file_id = file_id.original_file(sema.db); if let ModuleSource::SourceFile(..) = def_source { - // mod is defined in path/to/dir/mod.rs - let path = if module.is_mod_rs(sema.db) { - format!("../{}/mod.rs", new_name) - } else { - format!("{}.rs", new_name) - }; - let dst = AnchoredPathBuf { anchor: file_id, path }; - let move_file = FileSystemEdit::MoveFile { src: file_id, dst }; - source_change.push_file_system_edit(move_file); + let anchor = file_id.original_file(sema.db); + // not mod.rs and doesn't has children, rename file only + if !module.is_mod_rs(sema.db) && module.children(sema.db).next().is_none() { + let path = format!("{}.rs", new_name); + let dst = AnchoredPathBuf { anchor, path }; + source_change.push_file_system_edit(FileSystemEdit::MoveFile { src: anchor, dst }) + } else if let Some(mod_name) = module.name(sema.db) { + // is mod.rs or has children, rename dir + let src = AnchoredPathBuf { anchor, path: mod_name.to_string() }; + let dst = AnchoredPathBuf { anchor, path: new_name.to_string() }; + source_change.push_file_system_edit(FileSystemEdit::MoveDir { + src, + src_id: anchor, + dst, + }) + } } - if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) { - let file_id = file_id.original_file(sema.db); - match decl_source.name() { - Some(name) => source_change.insert_source_edit( - file_id, - TextEdit::replace(name.syntax().text_range(), new_name.to_string()), - ), + if let Some(src) = module.declaration_source(sema.db) { + let file_id = src.file_id.original_file(sema.db); + match src.value.name() { + Some(name) => { + if let Some(file_range) = + src.with_value(name.syntax()).original_file_range_opt(sema.db) + { + source_change.insert_source_edit( + file_id, + TextEdit::replace(file_range.range, new_name.to_string()), + ) + }; + } _ => never!("Module source node is missing a name"), } } - let def = Definition::ModuleDef(hir::ModuleDef::Module(module)); + + let def = Definition::Module(module); let usages = def.usages(sema).all(); let ref_edits = usages.iter().map(|(&file_id, references)| { (file_id, source_edit_from_references(references, def, new_name)) @@ -229,7 +232,7 @@ fn rename_reference( let ident_kind = IdentifierKind::classify(new_name)?; if matches!( - def, // is target a lifetime? + def, Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_) ) { match ident_kind { @@ -240,45 +243,50 @@ fn rename_reference( IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime), } } else { - match (ident_kind, def) { - (IdentifierKind::Lifetime, _) => { + match ident_kind { + IdentifierKind::Lifetime => { cov_mark::hit!(rename_not_an_ident_ref); bail!("Invalid name `{}`: not an identifier", new_name); } - (IdentifierKind::Ident, _) => cov_mark::hit!(rename_non_local), - (IdentifierKind::Underscore, _) => (), + IdentifierKind::Ident => cov_mark::hit!(rename_non_local), + IdentifierKind::Underscore => (), } } - def = match def { + let assoc_item = match def { // HACK: resolve trait impl items to the item def of the trait definition // so that we properly resolve all trait item references - Definition::ModuleDef(mod_def) => mod_def - .as_assoc_item(sema.db) - .and_then(|it| it.containing_trait_impl(sema.db)) - .and_then(|it| { - it.items(sema.db).into_iter().find_map(|it| match (it, mod_def) { - (hir::AssocItem::Function(trait_func), hir::ModuleDef::Function(func)) + Definition::Function(it) => it.as_assoc_item(sema.db), + Definition::TypeAlias(it) => it.as_assoc_item(sema.db), + Definition::Const(it) => it.as_assoc_item(sema.db), + _ => None, + }; + def = match assoc_item { + Some(assoc) => assoc + .containing_trait_impl(sema.db) + .and_then(|trait_| { + trait_.items(sema.db).into_iter().find_map(|it| match (it, assoc) { + (hir::AssocItem::Function(trait_func), hir::AssocItem::Function(func)) if trait_func.name(sema.db) == func.name(sema.db) => { - Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func))) + Some(Definition::Function(trait_func)) } - (hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst)) + (hir::AssocItem::Const(trait_konst), hir::AssocItem::Const(konst)) if trait_konst.name(sema.db) == konst.name(sema.db) => { - Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst))) + Some(Definition::Const(trait_konst)) } ( hir::AssocItem::TypeAlias(trait_type_alias), - hir::ModuleDef::TypeAlias(type_alias), + hir::AssocItem::TypeAlias(type_alias), ) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => { - Some(Definition::ModuleDef(hir::ModuleDef::TypeAlias(trait_type_alias))) + Some(Definition::TypeAlias(trait_type_alias)) } _ => None, }) }) .unwrap_or(def), - _ => def, + None => def, }; let usages = def.usages(sema).all(); @@ -291,8 +299,18 @@ fn rename_reference( (file_id, source_edit_from_references(references, def, new_name)) })); - let (file_id, edit) = source_edit_from_def(sema, def, new_name)?; - source_change.insert_source_edit(file_id, edit); + let mut insert_def_edit = |def| { + let (file_id, edit) = source_edit_from_def(sema, def, new_name)?; + source_change.insert_source_edit(file_id, edit); + Ok(()) + }; + match def { + Definition::Local(l) => l + .associated_locals(sema.db) + .iter() + .try_for_each(|&local| insert_def_edit(Definition::Local(local))), + def => insert_def_edit(def), + }?; Ok(source_change) } @@ -302,109 +320,142 @@ pub fn source_edit_from_references( new_name: &str, ) -> TextEdit { let mut edit = TextEdit::builder(); - for reference in references { - let (range, replacement) = match &reference.name { + // macros can cause multiple refs to occur for the same text range, so keep track of what we have edited so far + let mut edited_ranges = Vec::new(); + for &FileReference { range, ref name, .. } in references { + let has_emitted_edit = match name { // 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 // the macro input - ast::NameLike::NameRef(name_ref) - if name_ref.syntax().text_range() == reference.range => - { - source_edit_from_name_ref(name_ref, new_name, def) + ast::NameLike::NameRef(name_ref) if name_ref.syntax().text_range() == range => { + source_edit_from_name_ref(&mut edit, name_ref, new_name, def) } - ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => { - source_edit_from_name(name, new_name) + ast::NameLike::Name(name) if name.syntax().text_range() == range => { + source_edit_from_name(&mut edit, name, new_name) + } + _ => false, + }; + if !has_emitted_edit { + if !edited_ranges.contains(&range.start()) { + edit.replace(range, new_name.to_string()); + edited_ranges.push(range.start()); } - _ => None, } - .unwrap_or_else(|| (reference.range, new_name.to_string())); - edit.replace(range, replacement); } + edit.finish() } -fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> { - if let Some(_) = ast::RecordPatField::for_field_name(name) { +fn source_edit_from_name(edit: &mut TextEditBuilder, name: &ast::Name, new_name: &str) -> bool { + if ast::RecordPatField::for_field_name(name).is_some() { if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) { - return Some(( - TextRange::empty(ident_pat.syntax().text_range().start()), - [new_name, ": "].concat(), - )); + cov_mark::hit!(rename_record_pat_field_name_split); + // Foo { ref mut field } -> Foo { new_name: ref mut field } + // ^ insert `new_name: ` + + // FIXME: instead of splitting the shorthand, recursively trigger a rename of the + // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547 + edit.insert(ident_pat.syntax().text_range().start(), format!("{}: ", new_name)); + return true; } } - None + + false } fn source_edit_from_name_ref( + edit: &mut TextEditBuilder, name_ref: &ast::NameRef, new_name: &str, def: Definition, -) -> Option<(TextRange, String)> { +) -> bool { + if name_ref.super_token().is_some() { + return true; + } + if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) { let rcf_name_ref = record_field.name_ref(); let rcf_expr = record_field.expr(); - match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) { + match &(rcf_name_ref, rcf_expr.and_then(|it| expr_as_name_ref(&it))) { // field: init-expr, check if we can use a field init shorthand (Some(field_name), Some(init)) => { - if field_name == *name_ref { + if field_name == name_ref { if init.text() == new_name { cov_mark::hit!(test_rename_field_put_init_shorthand); + // Foo { field: local } -> Foo { local } + // ^^^^^^^ delete this + // same names, we can use a shorthand here instead. // we do not want to erase attributes hence this range start let s = field_name.syntax().text_range().start(); - let e = record_field.syntax().text_range().end(); - return Some((TextRange::new(s, e), new_name.to_owned())); + let e = init.syntax().text_range().start(); + edit.delete(TextRange::new(s, e)); + return true; } - } else if init == *name_ref { + } else if init == name_ref { if field_name.text() == new_name { cov_mark::hit!(test_rename_local_put_init_shorthand); + // Foo { field: local } -> Foo { field } + // ^^^^^^^ delete this + // same names, we can use a shorthand here instead. // we do not want to erase attributes hence this range start - let s = field_name.syntax().text_range().start(); - let e = record_field.syntax().text_range().end(); - return Some((TextRange::new(s, e), new_name.to_owned())); + let s = field_name.syntax().text_range().end(); + let e = init.syntax().text_range().end(); + edit.delete(TextRange::new(s, e)); + return true; } } - None } // init shorthand - // FIXME: instead of splitting the shorthand, recursively trigger a rename of the - // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547 (None, Some(_)) if matches!(def, Definition::Field(_)) => { cov_mark::hit!(test_rename_field_in_field_shorthand); - let s = name_ref.syntax().text_range().start(); - Some((TextRange::empty(s), format!("{}: ", new_name))) + // Foo { field } -> Foo { new_name: field } + // ^ insert `new_name: ` + let offset = name_ref.syntax().text_range().start(); + edit.insert(offset, format!("{}: ", new_name)); + return true; } (None, Some(_)) if matches!(def, Definition::Local(_)) => { cov_mark::hit!(test_rename_local_in_field_shorthand); - let s = name_ref.syntax().text_range().end(); - Some((TextRange::empty(s), format!(": {}", new_name))) + // Foo { field } -> Foo { field: new_name } + // ^ insert `: new_name` + let offset = name_ref.syntax().text_range().end(); + edit.insert(offset, format!(": {}", new_name)); + return true; } - _ => None, + _ => (), } } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) { let rcf_name_ref = record_field.name_ref(); let rcf_pat = record_field.pat(); match (rcf_name_ref, rcf_pat) { // field: rename - (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => { + (Some(field_name), Some(ast::Pat::IdentPat(pat))) + if field_name == *name_ref && pat.at_token().is_none() => + { // field name is being renamed - if pat.name().map_or(false, |it| it.text() == new_name) { - cov_mark::hit!(test_rename_field_put_init_shorthand_pat); - // same names, we can use a shorthand here instead/ - // we do not want to erase attributes hence this range start - let s = field_name.syntax().text_range().start(); - let e = record_field.syntax().text_range().end(); - Some((TextRange::new(s, e), pat.to_string())) - } else { - None + if let Some(name) = pat.name() { + if name.text() == new_name { + cov_mark::hit!(test_rename_field_put_init_shorthand_pat); + // Foo { field: ref mut local } -> Foo { ref mut field } + // ^^^^^^^ delete this + // ^^^^^ replace this with `field` + + // same names, we can use a shorthand here instead/ + // we do not want to erase attributes hence this range start + let s = field_name.syntax().text_range().start(); + let e = pat.syntax().text_range().start(); + edit.delete(TextRange::new(s, e)); + edit.replace(name.syntax().text_range(), new_name.to_string()); + return true; + } } } - _ => None, + _ => (), } - } else { - None } + false } fn source_edit_from_def( @@ -412,31 +463,52 @@ fn source_edit_from_def( def: Definition, new_name: &str, ) -> Result<(FileId, TextEdit)> { - let frange = - def.rename_range(sema).ok_or_else(|| format_err!("No identifier available to rename"))?; + let FileRange { file_id, range } = def + .range_for_rename(sema) + .ok_or_else(|| format_err!("No identifier available to rename"))?; - let mut replacement_text = String::new(); - let mut repl_range = frange.range; + let mut edit = TextEdit::builder(); if let Definition::Local(local) = def { if let Either::Left(pat) = local.source(sema.db).value { - if matches!( - pat.syntax().parent().and_then(ast::RecordPatField::cast), - Some(pat_field) if pat_field.name_ref().is_none() - ) { - replacement_text.push_str(": "); - replacement_text.push_str(new_name); - repl_range = TextRange::new( - pat.syntax().text_range().end(), - pat.syntax().text_range().end(), - ); + // special cases required for renaming fields/locals in Record patterns + if let Some(pat_field) = pat.syntax().parent().and_then(ast::RecordPatField::cast) { + let name_range = pat.name().unwrap().syntax().text_range(); + if let Some(name_ref) = pat_field.name_ref() { + if new_name == name_ref.text() && pat.at_token().is_none() { + // Foo { field: ref mut local } -> Foo { ref mut field } + // ^^^^^^ delete this + // ^^^^^ replace this with `field` + cov_mark::hit!(test_rename_local_put_init_shorthand_pat); + edit.delete( + name_ref + .syntax() + .text_range() + .cover_offset(pat.syntax().text_range().start()), + ); + edit.replace(name_range, name_ref.text().to_string()); + } else { + // Foo { field: ref mut local @ local 2} -> Foo { field: ref mut new_name @ local2 } + // Foo { field: ref mut local } -> Foo { field: ref mut new_name } + // ^^^^^ replace this with `new_name` + edit.replace(name_range, new_name.to_string()); + } + } else { + // Foo { ref mut field } -> Foo { field: ref mut new_name } + // ^ insert `field: ` + // ^^^^^ replace this with `new_name` + edit.insert( + pat.syntax().text_range().start(), + format!("{}: ", pat_field.field_name().unwrap()), + ); + edit.replace(name_range, new_name.to_string()); + } } } } - if replacement_text.is_empty() { - replacement_text.push_str(new_name); + if edit.is_empty() { + edit.replace(range, new_name.to_string()); } - let edit = TextEdit::replace(repl_range, replacement_text); - Ok((frange.file_id, edit)) + Ok((file_id, edit.finish())) } #[derive(Copy, Clone, Debug, PartialEq)] @@ -448,7 +520,7 @@ pub enum IdentifierKind { impl IdentifierKind { pub fn classify(new_name: &str) -> Result { - match lex_single_syntax_kind(new_name) { + match parser::LexedStr::single_token(new_name) { Some(res) => match res { (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident), (T![_], _) => Ok(IdentifierKind::Underscore),