crates/ide_db/src/rename.rs

   1 //! Rename infrastructure for rust-analyzer. It is used primarily for the
   2 //! literal "rename" in the ide (look for tests there), but it is also available
   3 //! as a general-purpose service. For example, it is used by the fix for the
   4 //! "incorrect case" diagnostic.
   5 //!
   6 //! It leverages the [`crate::search`] functionality to find what needs to be
   7 //! renamed. The actual renames are tricky -- field shorthands need special
   8 //! attention, and, when renaming modules, you also want to rename files on the
   9 //! file system.
  10 //!
  11 //! Another can of worms are macros:
  12 //!
  13 //! ```
  14 //! macro_rules! m { () => { fn f() {} } }
  15 //! m!();
  16 //! fn main() {
  17 //!     f() // <- rename me
  18 //! }
  19 //! ```
  20 //!
  21 //! The correct behavior in such cases is probably to show a dialog to the user.
  22 //! Our current behavior is ¯\_(ツ)_/¯.
  23 use std::fmt;
  24
  25 use base_db::{AnchoredPathBuf, FileId, FileRange};
  26 use either::Either;
  27 use hir::{AsAssocItem, FieldSource, HasSource, InFile, ModuleSource, Semantics};
  28 use stdx::never;
  29 use syntax::{
  30     ast::{self, NameOwner},
  31     lex_single_syntax_kind, AstNode, SyntaxKind, TextRange, T,
  32 };
  33 use text_edit::TextEdit;
  34
  35 use crate::{
  36     defs::Definition,
  37     search::FileReference,
  38     source_change::{FileSystemEdit, SourceChange},
  39     RootDatabase,
  40 };
  41
  42 pub type Result<T, E = RenameError> = std::result::Result<T, E>;
  43
  44 #[derive(Debug)]
  45 pub struct RenameError(pub String);
  46
  47 impl fmt::Display for RenameError {
  48     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  49         fmt::Display::fmt(&self.0, f)
  50     }
  51 }
  52
  53 #[macro_export]
  54 macro_rules! _format_err {
  55     ($fmt:expr) => { RenameError(format!($fmt)) };
  56     ($fmt:expr, $($arg:tt)+) => { RenameError(format!($fmt, $($arg)+)) }
  57 }
  58 pub use _format_err as format_err;
  59
  60 #[macro_export]
  61 macro_rules! _bail {
  62     ($($tokens:tt)*) => { return Err(format_err!($($tokens)*)) }
  63 }
  64 pub use _bail as bail;
  65
  66 impl Definition {
  67     pub fn rename(&self, sema: &Semantics<RootDatabase>, new_name: &str) -> Result<SourceChange> {
  68         match *self {
  69             Definition::ModuleDef(hir::ModuleDef::Module(module)) => {
  70                 rename_mod(sema, module, new_name)
  71             }
  72             Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
  73                 bail!("Cannot rename builtin type")
  74             }
  75             Definition::SelfType(_) => bail!("Cannot rename `Self`"),
  76             def => rename_reference(sema, def, new_name),
  77         }
  78     }
  79
  80     /// Textual range of the identifier which will change when renaming this
  81     /// `Definition`. Note that some definitions, like buitin types, can't be
  82     /// renamed.
  83     pub fn range_for_rename(self, sema: &Semantics<RootDatabase>) -> Option<FileRange> {
  84         // FIXME: the `original_file_range` calls here are wrong -- they never fail,
  85         // and _fall back_ to the entirety of the macro call. Such fall back is
  86         // incorrect for renames. The safe behavior would be to return an error for
  87         // such cases. The correct behavior would be to return an auxiliary list of
  88         // "can't rename these occurrences in macros" items, and then show some kind
  89         // of a dialog to the user. See:
  90         cov_mark::hit!(macros_are_broken_lol);
  91
  92         let res = match self {
  93             Definition::Macro(mac) => {
  94                 let src = mac.source(sema.db)?;
  95                 let name = match &src.value {
  96                     Either::Left(it) => it.name()?,
  97                     Either::Right(it) => it.name()?,
  98                 };
  99                 src.with_value(name.syntax()).original_file_range(sema.db)
 100             }
 101             Definition::Field(field) => {
 102                 let src = field.source(sema.db)?;
 103
 104                 match &src.value {
 105                     FieldSource::Named(record_field) => {
 106                         let name = record_field.name()?;
 107                         src.with_value(name.syntax()).original_file_range(sema.db)
 108                     }
 109                     FieldSource::Pos(_) => {
 110                         return None;
 111                     }
 112                 }
 113             }
 114             Definition::ModuleDef(module_def) => match module_def {
 115                 hir::ModuleDef::Module(module) => {
 116                     let src = module.declaration_source(sema.db)?;
 117                     let name = src.value.name()?;
 118                     src.with_value(name.syntax()).original_file_range(sema.db)
 119                 }
 120                 hir::ModuleDef::Function(it) => name_range(it, sema)?,
 121                 hir::ModuleDef::Adt(adt) => match adt {
 122                     hir::Adt::Struct(it) => name_range(it, sema)?,
 123                     hir::Adt::Union(it) => name_range(it, sema)?,
 124                     hir::Adt::Enum(it) => name_range(it, sema)?,
 125                 },
 126                 hir::ModuleDef::Variant(it) => name_range(it, sema)?,
 127                 hir::ModuleDef::Const(it) => name_range(it, sema)?,
 128                 hir::ModuleDef::Static(it) => name_range(it, sema)?,
 129                 hir::ModuleDef::Trait(it) => name_range(it, sema)?,
 130                 hir::ModuleDef::TypeAlias(it) => name_range(it, sema)?,
 131                 hir::ModuleDef::BuiltinType(_) => return None,
 132             },
 133             Definition::SelfType(_) => return None,
 134             Definition::Local(local) => {
 135                 let src = local.source(sema.db);
 136                 let name = match &src.value {
 137                     Either::Left(bind_pat) => bind_pat.name()?,
 138                     Either::Right(_) => return None,
 139                 };
 140                 src.with_value(name.syntax()).original_file_range(sema.db)
 141             }
 142             Definition::GenericParam(generic_param) => match generic_param {
 143                 hir::GenericParam::TypeParam(type_param) => {
 144                     let src = type_param.source(sema.db)?;
 145                     let name = match &src.value {
 146                         Either::Left(type_param) => type_param.name()?,
 147                         Either::Right(_trait) => return None,
 148                     };
 149                     src.with_value(name.syntax()).original_file_range(sema.db)
 150                 }
 151                 hir::GenericParam::LifetimeParam(lifetime_param) => {
 152                     let src = lifetime_param.source(sema.db)?;
 153                     let lifetime = src.value.lifetime()?;
 154                     src.with_value(lifetime.syntax()).original_file_range(sema.db)
 155                 }
 156                 hir::GenericParam::ConstParam(it) => name_range(it, sema)?,
 157             },
 158             Definition::Label(label) => {
 159                 let src = label.source(sema.db);
 160                 let lifetime = src.value.lifetime()?;
 161                 src.with_value(lifetime.syntax()).original_file_range(sema.db)
 162             }
 163         };
 164         return Some(res);
 165
 166         fn name_range<D>(def: D, sema: &Semantics<RootDatabase>) -> Option<FileRange>
 167         where
 168             D: HasSource,
 169             D::Ast: ast::NameOwner,
 170         {
 171             let src = def.source(sema.db)?;
 172             let name = src.value.name()?;
 173             let res = src.with_value(name.syntax()).original_file_range(sema.db);
 174             Some(res)
 175         }
 176     }
 177 }
 178
 179 fn rename_mod(
 180     sema: &Semantics<RootDatabase>,
 181     module: hir::Module,
 182     new_name: &str,
 183 ) -> Result<SourceChange> {
 184     if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
 185         bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
 186     }
 187
 188     let mut source_change = SourceChange::default();
 189
 190     let InFile { file_id, value: def_source } = module.definition_source(sema.db);
 191     let file_id = file_id.original_file(sema.db);
 192     if let ModuleSource::SourceFile(..) = def_source {
 193         // mod is defined in path/to/dir/mod.rs
 194         let path = if module.is_mod_rs(sema.db) {
 195             format!("../{}/mod.rs", new_name)
 196         } else {
 197             format!("{}.rs", new_name)
 198         };
 199         let dst = AnchoredPathBuf { anchor: file_id, path };
 200         let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
 201         source_change.push_file_system_edit(move_file);
 202     }
 203
 204     if let Some(InFile { file_id, value: decl_source }) = module.declaration_source(sema.db) {
 205         let file_id = file_id.original_file(sema.db);
 206         match decl_source.name() {
 207             Some(name) => source_change.insert_source_edit(
 208                 file_id,
 209                 TextEdit::replace(name.syntax().text_range(), new_name.to_string()),
 210             ),
 211             _ => never!("Module source node is missing a name"),
 212         }
 213     }
 214     let def = Definition::ModuleDef(hir::ModuleDef::Module(module));
 215     let usages = def.usages(sema).all();
 216     let ref_edits = usages.iter().map(|(&file_id, references)| {
 217         (file_id, source_edit_from_references(references, def, new_name))
 218     });
 219     source_change.extend(ref_edits);
 220
 221     Ok(source_change)
 222 }
 223
 224 fn rename_reference(
 225     sema: &Semantics<RootDatabase>,
 226     mut def: Definition,
 227     new_name: &str,
 228 ) -> Result<SourceChange> {
 229     let ident_kind = IdentifierKind::classify(new_name)?;
 230
 231     if matches!(
 232         def,
 233         Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
 234     ) {
 235         match ident_kind {
 236             IdentifierKind::Ident | IdentifierKind::Underscore => {
 237                 cov_mark::hit!(rename_not_a_lifetime_ident_ref);
 238                 bail!("Invalid name `{}`: not a lifetime identifier", new_name);
 239             }
 240             IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
 241         }
 242     } else {
 243         match ident_kind {
 244             IdentifierKind::Lifetime => {
 245                 cov_mark::hit!(rename_not_an_ident_ref);
 246                 bail!("Invalid name `{}`: not an identifier", new_name);
 247             }
 248             IdentifierKind::Ident => cov_mark::hit!(rename_non_local),
 249             IdentifierKind::Underscore => (),
 250         }
 251     }
 252
 253     def = match def {
 254         // HACK: resolve trait impl items to the item def of the trait definition
 255         // so that we properly resolve all trait item references
 256         Definition::ModuleDef(mod_def) => mod_def
 257             .as_assoc_item(sema.db)
 258             .and_then(|it| it.containing_trait_impl(sema.db))
 259             .and_then(|it| {
 260                 it.items(sema.db).into_iter().find_map(|it| match (it, mod_def) {
 261                     (hir::AssocItem::Function(trait_func), hir::ModuleDef::Function(func))
 262                         if trait_func.name(sema.db) == func.name(sema.db) =>
 263                     {
 264                         Some(Definition::ModuleDef(hir::ModuleDef::Function(trait_func)))
 265                     }
 266                     (hir::AssocItem::Const(trait_konst), hir::ModuleDef::Const(konst))
 267                         if trait_konst.name(sema.db) == konst.name(sema.db) =>
 268                     {
 269                         Some(Definition::ModuleDef(hir::ModuleDef::Const(trait_konst)))
 270                     }
 271                     (
 272                         hir::AssocItem::TypeAlias(trait_type_alias),
 273                         hir::ModuleDef::TypeAlias(type_alias),
 274                     ) if trait_type_alias.name(sema.db) == type_alias.name(sema.db) => {
 275                         Some(Definition::ModuleDef(hir::ModuleDef::TypeAlias(trait_type_alias)))
 276                     }
 277                     _ => None,
 278                 })
 279             })
 280             .unwrap_or(def),
 281         _ => def,
 282     };
 283     let usages = def.usages(sema).all();
 284
 285     if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
 286         cov_mark::hit!(rename_underscore_multiple);
 287         bail!("Cannot rename reference to `_` as it is being referenced multiple times");
 288     }
 289     let mut source_change = SourceChange::default();
 290     source_change.extend(usages.iter().map(|(&file_id, references)| {
 291         (file_id, source_edit_from_references(references, def, new_name))
 292     }));
 293
 294     let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
 295     source_change.insert_source_edit(file_id, edit);
 296     Ok(source_change)
 297 }
 298
 299 pub fn source_edit_from_references(
 300     references: &[FileReference],
 301     def: Definition,
 302     new_name: &str,
 303 ) -> TextEdit {
 304     let mut edit = TextEdit::builder();
 305     for reference in references {
 306         let (range, replacement) = match &reference.name {
 307             // if the ranges differ then the node is inside a macro call, we can't really attempt
 308             // to make special rewrites like shorthand syntax and such, so just rename the node in
 309             // the macro input
 310             ast::NameLike::NameRef(name_ref)
 311                 if name_ref.syntax().text_range() == reference.range =>
 312             {
 313                 source_edit_from_name_ref(name_ref, new_name, def)
 314             }
 315             ast::NameLike::Name(name) if name.syntax().text_range() == reference.range => {
 316                 source_edit_from_name(name, new_name)
 317             }
 318             _ => None,
 319         }
 320         .unwrap_or_else(|| (reference.range, new_name.to_string()));
 321         edit.replace(range, replacement);
 322     }
 323
 324     edit.finish()
 325 }
 326
 327 fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
 328     if let Some(_) = ast::RecordPatField::for_field_name(name) {
 329         if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
 330             cov_mark::hit!(rename_record_pat_field_name_split);
 331             // Foo { ref mut field } -> Foo { new_name: ref mut field }
 332             //      ^ insert `new_name: `
 333
 334             // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
 335             // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
 336             return Some((
 337                 TextRange::empty(ident_pat.syntax().text_range().start()),
 338                 format!("{}: ", new_name),
 339             ));
 340         }
 341     }
 342
 343     None
 344 }
 345
 346 fn source_edit_from_name_ref(
 347     name_ref: &ast::NameRef,
 348     new_name: &str,
 349     def: Definition,
 350 ) -> Option<(TextRange, String)> {
 351     if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
 352         let rcf_name_ref = record_field.name_ref();
 353         let rcf_expr = record_field.expr();
 354         match &(rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
 355             // field: init-expr, check if we can use a field init shorthand
 356             (Some(field_name), Some(init)) => {
 357                 if field_name == name_ref {
 358                     if init.text() == new_name {
 359                         cov_mark::hit!(test_rename_field_put_init_shorthand);
 360                         // Foo { field: local } -> Foo { local }
 361                         //      ^^^^^^^^ delete this
 362                         // FIXME: Actually delete this instead of replacing the entire thing
 363
 364                         // same names, we can use a shorthand here instead.
 365                         // we do not want to erase attributes hence this range start
 366                         let s = field_name.syntax().text_range().start();
 367                         let e = record_field.syntax().text_range().end();
 368                         return Some((TextRange::new(s, e), new_name.to_owned()));
 369                     }
 370                 } else if init == name_ref {
 371                     if field_name.text() == new_name {
 372                         cov_mark::hit!(test_rename_local_put_init_shorthand);
 373                         // Foo { field: local } -> Foo { field }
 374                         //            ^^^^^^^ delete this
 375                         // FIXME: Actually delete this instead of replacing the entire thing
 376
 377                         // same names, we can use a shorthand here instead.
 378                         // we do not want to erase attributes hence this range start
 379                         let s = field_name.syntax().text_range().start();
 380                         let e = record_field.syntax().text_range().end();
 381                         return Some((TextRange::new(s, e), new_name.to_owned()));
 382                     }
 383                 }
 384                 None
 385             }
 386             // init shorthand
 387             (None, Some(_)) if matches!(def, Definition::Field(_)) => {
 388                 cov_mark::hit!(test_rename_field_in_field_shorthand);
 389                 // Foo { field } -> Foo { new_name: field }
 390                 //       ^ insert `new_name: `
 391                 let s = name_ref.syntax().text_range().start();
 392                 Some((TextRange::empty(s), format!("{}: ", new_name)))
 393             }
 394             (None, Some(_)) if matches!(def, Definition::Local(_)) => {
 395                 cov_mark::hit!(test_rename_local_in_field_shorthand);
 396                 // Foo { field } -> Foo { field: new_name }
 397                 //            ^ insert `: new_name`
 398                 let s = name_ref.syntax().text_range().end();
 399                 Some((TextRange::empty(s), format!(": {}", new_name)))
 400             }
 401             _ => None,
 402         }
 403     } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
 404         let rcf_name_ref = record_field.name_ref();
 405         let rcf_pat = record_field.pat();
 406         match (rcf_name_ref, rcf_pat) {
 407             // field: rename
 408             (Some(field_name), Some(ast::Pat::IdentPat(pat)))
 409                 if field_name == *name_ref && pat.at_token().is_none() =>
 410             {
 411                 // field name is being renamed
 412                 if pat.name().map_or(false, |it| it.text() == new_name) {
 413                     cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
 414                     // Foo { field: ref mut local } -> Foo { ref mut field }
 415                     //       ^^^^^^^ delete this
 416                     //                      ^^^^^ replace this with `field`
 417                     // FIXME: do this the way its written here
 418
 419                     // same names, we can use a shorthand here instead/
 420                     // we do not want to erase attributes hence this range start
 421                     let s = field_name.syntax().text_range().start();
 422                     let e = record_field.syntax().text_range().end();
 423                     Some((TextRange::new(s, e), pat.to_string()))
 424                 } else {
 425                     None
 426                 }
 427             }
 428             _ => None,
 429         }
 430     } else {
 431         None
 432     }
 433 }
 434
 435 fn source_edit_from_def(
 436     sema: &Semantics<RootDatabase>,
 437     def: Definition,
 438     new_name: &str,
 439 ) -> Result<(FileId, TextEdit)> {
 440     let FileRange { file_id, range } = def
 441         .range_for_rename(sema)
 442         .ok_or_else(|| format_err!("No identifier available to rename"))?;
 443
 444     let mut edit = TextEdit::builder();
 445     if let Definition::Local(local) = def {
 446         if let Either::Left(pat) = local.source(sema.db).value {
 447             // special cases required for renaming fields/locals in Record patterns
 448             if let Some(pat_field) = pat.syntax().parent().and_then(ast::RecordPatField::cast) {
 449                 let name_range = pat.name().unwrap().syntax().text_range();
 450                 if let Some(name_ref) = pat_field.name_ref() {
 451                     if new_name == name_ref.text() && pat.at_token().is_none() {
 452                         // Foo { field: ref mut local } -> Foo { ref mut field }
 453                         //       ^^^^^^ delete this
 454                         //                      ^^^^^ replace this with `field`
 455                         cov_mark::hit!(test_rename_local_put_init_shorthand_pat);
 456                         edit.delete(
 457                             name_ref
 458                                 .syntax()
 459                                 .text_range()
 460                                 .cover_offset(pat.syntax().text_range().start()),
 461                         );
 462                         edit.replace(name_range, name_ref.text().to_string());
 463                     } else {
 464                         // Foo { field: ref mut local @ local 2} -> Foo { field: ref mut new_name @ local2 }
 465                         // Foo { field: ref mut local } -> Foo { field: ref mut new_name }
 466                         //                      ^^^^^ replace this with `new_name`
 467                         edit.replace(name_range, new_name.to_string());
 468                     }
 469                 } else {
 470                     // Foo { ref mut field } -> Foo { field: ref mut new_name }
 471                     //      ^ insert `field: `
 472                     //               ^^^^^ replace this with `new_name`
 473                     edit.insert(
 474                         pat.syntax().text_range().start(),
 475                         format!("{}: ", pat_field.field_name().unwrap()),
 476                     );
 477                     edit.replace(name_range, new_name.to_string());
 478                 }
 479             }
 480         }
 481     }
 482     if edit.is_empty() {
 483         edit.replace(range, new_name.to_string());
 484     }
 485     Ok((file_id, edit.finish()))
 486 }
 487
 488 #[derive(Copy, Clone, Debug, PartialEq)]
 489 pub enum IdentifierKind {
 490     Ident,
 491     Lifetime,
 492     Underscore,
 493 }
 494
 495 impl IdentifierKind {
 496     pub fn classify(new_name: &str) -> Result<IdentifierKind> {
 497         match lex_single_syntax_kind(new_name) {
 498             Some(res) => match res {
 499                 (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
 500                 (T![_], _) => Ok(IdentifierKind::Underscore),
 501                 (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
 502                     Ok(IdentifierKind::Lifetime)
 503                 }
 504                 (SyntaxKind::LIFETIME_IDENT, _) => {
 505                     bail!("Invalid name `{}`: not a lifetime identifier", new_name)
 506                 }
 507                 (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
 508                 (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
 509             },
 510             None => bail!("Invalid name `{}`: not an identifier", new_name),
 511         }
 512     }
 513 }