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