src/tools/rust-analyzer/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 //! ```ignore
  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::{FieldSource, HasSource, InFile, ModuleSource, Semantics};
  28 use stdx::never;
  29 use syntax::{
  30     ast::{self, HasName},
  31     AstNode, SyntaxKind, TextRange, T,
  32 };
  33 use text_edit::{TextEdit, TextEditBuilder};
  34
  35 use crate::{
  36     defs::Definition,
  37     search::FileReference,
  38     source_change::{FileSystemEdit, SourceChange},
  39     syntax_helpers::node_ext::expr_as_name_ref,
  40     traits::convert_to_def_in_trait,
  41     RootDatabase,
  42 };
  43
  44 pub type Result<T, E = RenameError> = std::result::Result<T, E>;
  45
  46 #[derive(Debug)]
  47 pub struct RenameError(pub String);
  48
  49 impl fmt::Display for RenameError {
  50     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  51         fmt::Display::fmt(&self.0, f)
  52     }
  53 }
  54
  55 #[macro_export]
  56 macro_rules! _format_err {
  57     ($fmt:expr) => { RenameError(format!($fmt)) };
  58     ($fmt:expr, $($arg:tt)+) => { RenameError(format!($fmt, $($arg)+)) }
  59 }
  60 pub use _format_err as format_err;
  61
  62 #[macro_export]
  63 macro_rules! _bail {
  64     ($($tokens:tt)*) => { return Err(format_err!($($tokens)*)) }
  65 }
  66 pub use _bail as bail;
  67
  68 impl Definition {
  69     pub fn rename(
  70         &self,
  71         sema: &Semantics<'_, RootDatabase>,
  72         new_name: &str,
  73     ) -> Result<SourceChange> {
  74         match *self {
  75             Definition::Module(module) => rename_mod(sema, module, new_name),
  76             Definition::BuiltinType(_) => {
  77                 bail!("Cannot rename builtin type")
  78             }
  79             Definition::SelfType(_) => bail!("Cannot rename `Self`"),
  80             def => rename_reference(sema, def, new_name),
  81         }
  82     }
  83
  84     /// Textual range of the identifier which will change when renaming this
  85     /// `Definition`. Note that some definitions, like builtin types, can't be
  86     /// renamed.
  87     pub fn range_for_rename(self, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange> {
  88         let res = match self {
  89             Definition::Macro(mac) => {
  90                 let src = mac.source(sema.db)?;
  91                 let name = match &src.value {
  92                     Either::Left(it) => it.name()?,
  93                     Either::Right(it) => it.name()?,
  94                 };
  95                 src.with_value(name.syntax()).original_file_range_opt(sema.db)
  96             }
  97             Definition::Field(field) => {
  98                 let src = field.source(sema.db)?;
  99                 match &src.value {
 100                     FieldSource::Named(record_field) => {
 101                         let name = record_field.name()?;
 102                         src.with_value(name.syntax()).original_file_range_opt(sema.db)
 103                     }
 104                     FieldSource::Pos(_) => None,
 105                 }
 106             }
 107             Definition::Module(module) => {
 108                 let src = module.declaration_source(sema.db)?;
 109                 let name = src.value.name()?;
 110                 src.with_value(name.syntax()).original_file_range_opt(sema.db)
 111             }
 112             Definition::Function(it) => name_range(it, sema),
 113             Definition::Adt(adt) => match adt {
 114                 hir::Adt::Struct(it) => name_range(it, sema),
 115                 hir::Adt::Union(it) => name_range(it, sema),
 116                 hir::Adt::Enum(it) => name_range(it, sema),
 117             },
 118             Definition::Variant(it) => name_range(it, sema),
 119             Definition::Const(it) => name_range(it, sema),
 120             Definition::Static(it) => name_range(it, sema),
 121             Definition::Trait(it) => name_range(it, sema),
 122             Definition::TypeAlias(it) => name_range(it, sema),
 123             Definition::Local(local) => {
 124                 let src = local.source(sema.db);
 125                 let name = match &src.value {
 126                     Either::Left(bind_pat) => bind_pat.name()?,
 127                     Either::Right(_) => return None,
 128                 };
 129                 src.with_value(name.syntax()).original_file_range_opt(sema.db)
 130             }
 131             Definition::GenericParam(generic_param) => match generic_param {
 132                 hir::GenericParam::LifetimeParam(lifetime_param) => {
 133                     let src = lifetime_param.source(sema.db)?;
 134                     src.with_value(src.value.lifetime()?.syntax()).original_file_range_opt(sema.db)
 135                 }
 136                 _ => {
 137                     let x = match generic_param {
 138                         hir::GenericParam::TypeParam(it) => it.merge(),
 139                         hir::GenericParam::ConstParam(it) => it.merge(),
 140                         hir::GenericParam::LifetimeParam(_) => return None,
 141                     };
 142                     let src = x.source(sema.db)?;
 143                     let name = match &src.value {
 144                         Either::Left(x) => x.name()?,
 145                         Either::Right(_) => return None,
 146                     };
 147                     src.with_value(name.syntax()).original_file_range_opt(sema.db)
 148                 }
 149             },
 150             Definition::Label(label) => {
 151                 let src = label.source(sema.db);
 152                 let lifetime = src.value.lifetime()?;
 153                 src.with_value(lifetime.syntax()).original_file_range_opt(sema.db)
 154             }
 155             Definition::BuiltinType(_) => return None,
 156             Definition::SelfType(_) => return None,
 157             Definition::BuiltinAttr(_) => return None,
 158             Definition::ToolModule(_) => return None,
 159             // FIXME: This should be doable in theory
 160             Definition::DeriveHelper(_) => return None,
 161         };
 162         return res;
 163
 164         fn name_range<D>(def: D, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange>
 165         where
 166             D: HasSource,
 167             D::Ast: ast::HasName,
 168         {
 169             let src = def.source(sema.db)?;
 170             let name = src.value.name()?;
 171             src.with_value(name.syntax()).original_file_range_opt(sema.db)
 172         }
 173     }
 174 }
 175
 176 fn rename_mod(
 177     sema: &Semantics<'_, RootDatabase>,
 178     module: hir::Module,
 179     new_name: &str,
 180 ) -> Result<SourceChange> {
 181     if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
 182         bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
 183     }
 184
 185     let mut source_change = SourceChange::default();
 186
 187     if module.is_crate_root(sema.db) {
 188         return Ok(source_change);
 189     }
 190
 191     let InFile { file_id, value: def_source } = module.definition_source(sema.db);
 192     if let ModuleSource::SourceFile(..) = def_source {
 193         let anchor = file_id.original_file(sema.db);
 194
 195         let is_mod_rs = module.is_mod_rs(sema.db);
 196         let has_detached_child = module.children(sema.db).any(|child| !child.is_inline(sema.db));
 197
 198         // Module exists in a named file
 199         if !is_mod_rs {
 200             let path = format!("{}.rs", new_name);
 201             let dst = AnchoredPathBuf { anchor, path };
 202             source_change.push_file_system_edit(FileSystemEdit::MoveFile { src: anchor, dst })
 203         }
 204
 205         // Rename the dir if:
 206         //  - Module source is in mod.rs
 207         //  - Module has submodules defined in separate files
 208         let dir_paths = match (is_mod_rs, has_detached_child, module.name(sema.db)) {
 209             // Go up one level since the anchor is inside the dir we're trying to rename
 210             (true, _, Some(mod_name)) => {
 211                 Some((format!("../{}", mod_name), format!("../{}", new_name)))
 212             }
 213             // The anchor is on the same level as target dir
 214             (false, true, Some(mod_name)) => Some((mod_name.to_string(), new_name.to_string())),
 215             _ => None,
 216         };
 217
 218         if let Some((src, dst)) = dir_paths {
 219             let src = AnchoredPathBuf { anchor, path: src };
 220             let dst = AnchoredPathBuf { anchor, path: dst };
 221             source_change.push_file_system_edit(FileSystemEdit::MoveDir {
 222                 src,
 223                 src_id: anchor,
 224                 dst,
 225             })
 226         }
 227     }
 228
 229     if let Some(src) = module.declaration_source(sema.db) {
 230         let file_id = src.file_id.original_file(sema.db);
 231         match src.value.name() {
 232             Some(name) => {
 233                 if let Some(file_range) =
 234                     src.with_value(name.syntax()).original_file_range_opt(sema.db)
 235                 {
 236                     source_change.insert_source_edit(
 237                         file_id,
 238                         TextEdit::replace(file_range.range, new_name.to_string()),
 239                     )
 240                 };
 241             }
 242             _ => never!("Module source node is missing a name"),
 243         }
 244     }
 245
 246     let def = Definition::Module(module);
 247     let usages = def.usages(sema).all();
 248     let ref_edits = usages.iter().map(|(&file_id, references)| {
 249         (file_id, source_edit_from_references(references, def, new_name))
 250     });
 251     source_change.extend(ref_edits);
 252
 253     Ok(source_change)
 254 }
 255
 256 fn rename_reference(
 257     sema: &Semantics<'_, RootDatabase>,
 258     def: Definition,
 259     new_name: &str,
 260 ) -> Result<SourceChange> {
 261     let ident_kind = IdentifierKind::classify(new_name)?;
 262
 263     if matches!(
 264         def,
 265         Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
 266     ) {
 267         match ident_kind {
 268             IdentifierKind::Ident | IdentifierKind::Underscore => {
 269                 cov_mark::hit!(rename_not_a_lifetime_ident_ref);
 270                 bail!("Invalid name `{}`: not a lifetime identifier", new_name);
 271             }
 272             IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
 273         }
 274     } else {
 275         match ident_kind {
 276             IdentifierKind::Lifetime => {
 277                 cov_mark::hit!(rename_not_an_ident_ref);
 278                 bail!("Invalid name `{}`: not an identifier", new_name);
 279             }
 280             IdentifierKind::Ident => cov_mark::hit!(rename_non_local),
 281             IdentifierKind::Underscore => (),
 282         }
 283     }
 284
 285     let def = convert_to_def_in_trait(sema.db, def);
 286     let usages = def.usages(sema).all();
 287
 288     if !usages.is_empty() && ident_kind == IdentifierKind::Underscore {
 289         cov_mark::hit!(rename_underscore_multiple);
 290         bail!("Cannot rename reference to `_` as it is being referenced multiple times");
 291     }
 292     let mut source_change = SourceChange::default();
 293     source_change.extend(usages.iter().map(|(&file_id, references)| {
 294         (file_id, source_edit_from_references(references, def, new_name))
 295     }));
 296
 297     let mut insert_def_edit = |def| {
 298         let (file_id, edit) = source_edit_from_def(sema, def, new_name)?;
 299         source_change.insert_source_edit(file_id, edit);
 300         Ok(())
 301     };
 302     match def {
 303         Definition::Local(l) => l
 304             .associated_locals(sema.db)
 305             .iter()
 306             .try_for_each(|&local| insert_def_edit(Definition::Local(local))),
 307         def => insert_def_edit(def),
 308     }?;
 309     Ok(source_change)
 310 }
 311
 312 pub fn source_edit_from_references(
 313     references: &[FileReference],
 314     def: Definition,
 315     new_name: &str,
 316 ) -> TextEdit {
 317     let mut edit = TextEdit::builder();
 318     // macros can cause multiple refs to occur for the same text range, so keep track of what we have edited so far
 319     let mut edited_ranges = Vec::new();
 320     for &FileReference { range, ref name, .. } in references {
 321         let name_range = name.syntax().text_range();
 322         if name_range.len() != range.len() {
 323             // This usage comes from a different token kind that was downmapped to a NameLike in a macro
 324             // Renaming this will most likely break things syntax-wise
 325             continue;
 326         }
 327         let has_emitted_edit = match name {
 328             // if the ranges differ then the node is inside a macro call, we can't really attempt
 329             // to make special rewrites like shorthand syntax and such, so just rename the node in
 330             // the macro input
 331             ast::NameLike::NameRef(name_ref) if name_range == range => {
 332                 source_edit_from_name_ref(&mut edit, name_ref, new_name, def)
 333             }
 334             ast::NameLike::Name(name) if name_range == range => {
 335                 source_edit_from_name(&mut edit, name, new_name)
 336             }
 337             _ => false,
 338         };
 339         if !has_emitted_edit {
 340             if !edited_ranges.contains(&range.start()) {
 341                 edit.replace(range, new_name.to_string());
 342                 edited_ranges.push(range.start());
 343             }
 344         }
 345     }
 346
 347     edit.finish()
 348 }
 349
 350 fn source_edit_from_name(edit: &mut TextEditBuilder, name: &ast::Name, new_name: &str) -> bool {
 351     if ast::RecordPatField::for_field_name(name).is_some() {
 352         if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
 353             cov_mark::hit!(rename_record_pat_field_name_split);
 354             // Foo { ref mut field } -> Foo { new_name: ref mut field }
 355             //      ^ insert `new_name: `
 356
 357             // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
 358             // other name https://github.com/rust-lang/rust-analyzer/issues/6547
 359             edit.insert(ident_pat.syntax().text_range().start(), format!("{}: ", new_name));
 360             return true;
 361         }
 362     }
 363
 364     false
 365 }
 366
 367 fn source_edit_from_name_ref(
 368     edit: &mut TextEditBuilder,
 369     name_ref: &ast::NameRef,
 370     new_name: &str,
 371     def: Definition,
 372 ) -> bool {
 373     if name_ref.super_token().is_some() {
 374         return true;
 375     }
 376
 377     if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
 378         let rcf_name_ref = record_field.name_ref();
 379         let rcf_expr = record_field.expr();
 380         match &(rcf_name_ref, rcf_expr.and_then(|it| expr_as_name_ref(&it))) {
 381             // field: init-expr, check if we can use a field init shorthand
 382             (Some(field_name), Some(init)) => {
 383                 if field_name == name_ref {
 384                     if init.text() == new_name {
 385                         cov_mark::hit!(test_rename_field_put_init_shorthand);
 386                         // Foo { field: local } -> Foo { local }
 387                         //       ^^^^^^^ delete this
 388
 389                         // same names, we can use a shorthand here instead.
 390                         // we do not want to erase attributes hence this range start
 391                         let s = field_name.syntax().text_range().start();
 392                         let e = init.syntax().text_range().start();
 393                         edit.delete(TextRange::new(s, e));
 394                         return true;
 395                     }
 396                 } else if init == name_ref {
 397                     if field_name.text() == new_name {
 398                         cov_mark::hit!(test_rename_local_put_init_shorthand);
 399                         // Foo { field: local } -> Foo { field }
 400                         //            ^^^^^^^ delete this
 401
 402                         // same names, we can use a shorthand here instead.
 403                         // we do not want to erase attributes hence this range start
 404                         let s = field_name.syntax().text_range().end();
 405                         let e = init.syntax().text_range().end();
 406                         edit.delete(TextRange::new(s, e));
 407                         return true;
 408                     }
 409                 }
 410             }
 411             // init shorthand
 412             (None, Some(_)) if matches!(def, Definition::Field(_)) => {
 413                 cov_mark::hit!(test_rename_field_in_field_shorthand);
 414                 // Foo { field } -> Foo { new_name: field }
 415                 //       ^ insert `new_name: `
 416                 let offset = name_ref.syntax().text_range().start();
 417                 edit.insert(offset, format!("{}: ", new_name));
 418                 return true;
 419             }
 420             (None, Some(_)) if matches!(def, Definition::Local(_)) => {
 421                 cov_mark::hit!(test_rename_local_in_field_shorthand);
 422                 // Foo { field } -> Foo { field: new_name }
 423                 //            ^ insert `: new_name`
 424                 let offset = name_ref.syntax().text_range().end();
 425                 edit.insert(offset, format!(": {}", new_name));
 426                 return true;
 427             }
 428             _ => (),
 429         }
 430     } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
 431         let rcf_name_ref = record_field.name_ref();
 432         let rcf_pat = record_field.pat();
 433         match (rcf_name_ref, rcf_pat) {
 434             // field: rename
 435             (Some(field_name), Some(ast::Pat::IdentPat(pat)))
 436                 if field_name == *name_ref && pat.at_token().is_none() =>
 437             {
 438                 // field name is being renamed
 439                 if let Some(name) = pat.name() {
 440                     if name.text() == new_name {
 441                         cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
 442                         // Foo { field: ref mut local } -> Foo { ref mut field }
 443                         //       ^^^^^^^ delete this
 444                         //                      ^^^^^ replace this with `field`
 445
 446                         // same names, we can use a shorthand here instead/
 447                         // we do not want to erase attributes hence this range start
 448                         let s = field_name.syntax().text_range().start();
 449                         let e = pat.syntax().text_range().start();
 450                         edit.delete(TextRange::new(s, e));
 451                         edit.replace(name.syntax().text_range(), new_name.to_string());
 452                         return true;
 453                     }
 454                 }
 455             }
 456             _ => (),
 457         }
 458     }
 459     false
 460 }
 461
 462 fn source_edit_from_def(
 463     sema: &Semantics<'_, RootDatabase>,
 464     def: Definition,
 465     new_name: &str,
 466 ) -> Result<(FileId, TextEdit)> {
 467     let FileRange { file_id, range } = def
 468         .range_for_rename(sema)
 469         .ok_or_else(|| format_err!("No identifier available to rename"))?;
 470
 471     let mut edit = TextEdit::builder();
 472     if let Definition::Local(local) = def {
 473         if let Either::Left(pat) = local.source(sema.db).value {
 474             // special cases required for renaming fields/locals in Record patterns
 475             if let Some(pat_field) = pat.syntax().parent().and_then(ast::RecordPatField::cast) {
 476                 let name_range = pat.name().unwrap().syntax().text_range();
 477                 if let Some(name_ref) = pat_field.name_ref() {
 478                     if new_name == name_ref.text() && pat.at_token().is_none() {
 479                         // Foo { field: ref mut local } -> Foo { ref mut field }
 480                         //       ^^^^^^ delete this
 481                         //                      ^^^^^ replace this with `field`
 482                         cov_mark::hit!(test_rename_local_put_init_shorthand_pat);
 483                         edit.delete(
 484                             name_ref
 485                                 .syntax()
 486                                 .text_range()
 487                                 .cover_offset(pat.syntax().text_range().start()),
 488                         );
 489                         edit.replace(name_range, name_ref.text().to_string());
 490                     } else {
 491                         // Foo { field: ref mut local @ local 2} -> Foo { field: ref mut new_name @ local2 }
 492                         // Foo { field: ref mut local } -> Foo { field: ref mut new_name }
 493                         //                      ^^^^^ replace this with `new_name`
 494                         edit.replace(name_range, new_name.to_string());
 495                     }
 496                 } else {
 497                     // Foo { ref mut field } -> Foo { field: ref mut new_name }
 498                     //      ^ insert `field: `
 499                     //               ^^^^^ replace this with `new_name`
 500                     edit.insert(
 501                         pat.syntax().text_range().start(),
 502                         format!("{}: ", pat_field.field_name().unwrap()),
 503                     );
 504                     edit.replace(name_range, new_name.to_string());
 505                 }
 506             }
 507         }
 508     }
 509     if edit.is_empty() {
 510         edit.replace(range, new_name.to_string());
 511     }
 512     Ok((file_id, edit.finish()))
 513 }
 514
 515 #[derive(Copy, Clone, Debug, PartialEq)]
 516 pub enum IdentifierKind {
 517     Ident,
 518     Lifetime,
 519     Underscore,
 520 }
 521
 522 impl IdentifierKind {
 523     pub fn classify(new_name: &str) -> Result<IdentifierKind> {
 524         match parser::LexedStr::single_token(new_name) {
 525             Some(res) => match res {
 526                 (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
 527                 (T![_], _) => Ok(IdentifierKind::Underscore),
 528                 (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
 529                     Ok(IdentifierKind::Lifetime)
 530                 }
 531                 (SyntaxKind::LIFETIME_IDENT, _) => {
 532                     bail!("Invalid name `{}`: not a lifetime identifier", new_name)
 533                 }
 534                 (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
 535                 (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
 536             },
 537             None => bail!("Invalid name `{}`: not an identifier", new_name),
 538         }
 539     }
 540 }