X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fide_db%2Fsrc%2Frename.rs;h=589975406a4ffa2354ad726c3eed365760bf1b22;hb=3dd581b97d051e091037abca62564630d51bfea8;hp=a6f7c09af8be172123e42e2b5f50665fc64fdf77;hpb=6287d388c0d9a1d89f333cad23b8fbb87607d0f6;p=rust.git diff --git a/crates/ide_db/src/rename.rs b/crates/ide_db/src/rename.rs index a6f7c09af8b..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,8 +27,8 @@ 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, TextEditBuilder}; @@ -36,6 +36,7 @@ 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`"), @@ -100,26 +99,22 @@ pub fn range_for_rename(self, sema: &Semantics) -> Option 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_opt(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 { @@ -129,33 +124,40 @@ pub fn range_for_rename(self, sema: &Semantics) -> Option match generic_param { - hir::GenericParam::TypeParam(type_param) => { - let src = type_param.source(sema.db)?; + hir::GenericParam::LifetimeParam(lifetime_param) => { + let src = lifetime_param.source(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(type_param) => type_param.name()?, - Either::Right(_trait) => return None, + Either::Left(x) => x.name()?, + Either::Right(_) => return None, }; src.with_value(name.syntax()).original_file_range_opt(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_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_opt(sema.db) } + Definition::BuiltinType(_) => return None, + Definition::SelfType(_) => return None, + Definition::BuiltinAttr(_) => return None, + Definition::ToolModule(_) => return None, }; 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()?; @@ -176,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)) @@ -238,35 +253,40 @@ fn rename_reference( } } - 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(); @@ -279,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) } @@ -290,23 +320,26 @@ pub fn source_edit_from_references( new_name: &str, ) -> TextEdit { let mut edit = TextEdit::builder(); - for reference in references { - let has_emitted_edit = 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 => - { + 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 => { + ast::NameLike::Name(name) if name.syntax().text_range() == range => { source_edit_from_name(&mut edit, name, new_name) } _ => false, }; if !has_emitted_edit { - edit.replace(reference.range, new_name.to_string()); + if !edited_ranges.contains(&range.start()) { + edit.replace(range, new_name.to_string()); + edited_ranges.push(range.start()); + } } } @@ -314,7 +347,7 @@ pub fn source_edit_from_references( } 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 ast::RecordPatField::for_field_name(name).is_some() { if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) { cov_mark::hit!(rename_record_pat_field_name_split); // Foo { ref mut field } -> Foo { new_name: ref mut field } @@ -336,10 +369,14 @@ fn source_edit_from_name_ref( new_name: &str, def: Definition, ) -> 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 { @@ -483,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),