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