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 rename_range(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(_) => return None,
 147                         Either::Right(type_param) => type_param.name()?,
 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, // is target a lifetime?
 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, def) {
 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     edit.finish()
 324 }
 325
 326 fn source_edit_from_name(name: &ast::Name, new_name: &str) -> Option<(TextRange, String)> {
 327     if let Some(_) = ast::RecordPatField::for_field_name(name) {
 328         if let Some(ident_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
 329             return Some((
 330                 TextRange::empty(ident_pat.syntax().text_range().start()),
 331                 [new_name, ": "].concat(),
 332             ));
 333         }
 334     }
 335     None
 336 }
 337
 338 fn source_edit_from_name_ref(
 339     name_ref: &ast::NameRef,
 340     new_name: &str,
 341     def: Definition,
 342 ) -> Option<(TextRange, String)> {
 343     if let Some(record_field) = ast::RecordExprField::for_name_ref(name_ref) {
 344         let rcf_name_ref = record_field.name_ref();
 345         let rcf_expr = record_field.expr();
 346         match (rcf_name_ref, rcf_expr.and_then(|it| it.name_ref())) {
 347             // field: init-expr, check if we can use a field init shorthand
 348             (Some(field_name), Some(init)) => {
 349                 if field_name == *name_ref {
 350                     if init.text() == new_name {
 351                         cov_mark::hit!(test_rename_field_put_init_shorthand);
 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 = record_field.syntax().text_range().end();
 356                         return Some((TextRange::new(s, e), new_name.to_owned()));
 357                     }
 358                 } else if init == *name_ref {
 359                     if field_name.text() == new_name {
 360                         cov_mark::hit!(test_rename_local_put_init_shorthand);
 361                         // same names, we can use a shorthand here instead.
 362                         // we do not want to erase attributes hence this range start
 363                         let s = field_name.syntax().text_range().start();
 364                         let e = record_field.syntax().text_range().end();
 365                         return Some((TextRange::new(s, e), new_name.to_owned()));
 366                     }
 367                 }
 368                 None
 369             }
 370             // init shorthand
 371             // FIXME: instead of splitting the shorthand, recursively trigger a rename of the
 372             // other name https://github.com/rust-analyzer/rust-analyzer/issues/6547
 373             (None, Some(_)) if matches!(def, Definition::Field(_)) => {
 374                 cov_mark::hit!(test_rename_field_in_field_shorthand);
 375                 let s = name_ref.syntax().text_range().start();
 376                 Some((TextRange::empty(s), format!("{}: ", new_name)))
 377             }
 378             (None, Some(_)) if matches!(def, Definition::Local(_)) => {
 379                 cov_mark::hit!(test_rename_local_in_field_shorthand);
 380                 let s = name_ref.syntax().text_range().end();
 381                 Some((TextRange::empty(s), format!(": {}", new_name)))
 382             }
 383             _ => None,
 384         }
 385     } else if let Some(record_field) = ast::RecordPatField::for_field_name_ref(name_ref) {
 386         let rcf_name_ref = record_field.name_ref();
 387         let rcf_pat = record_field.pat();
 388         match (rcf_name_ref, rcf_pat) {
 389             // field: rename
 390             (Some(field_name), Some(ast::Pat::IdentPat(pat))) if field_name == *name_ref => {
 391                 // field name is being renamed
 392                 if pat.name().map_or(false, |it| it.text() == new_name) {
 393                     cov_mark::hit!(test_rename_field_put_init_shorthand_pat);
 394                     // same names, we can use a shorthand here instead/
 395                     // we do not want to erase attributes hence this range start
 396                     let s = field_name.syntax().text_range().start();
 397                     let e = record_field.syntax().text_range().end();
 398                     Some((TextRange::new(s, e), pat.to_string()))
 399                 } else {
 400                     None
 401                 }
 402             }
 403             _ => None,
 404         }
 405     } else {
 406         None
 407     }
 408 }
 409
 410 fn source_edit_from_def(
 411     sema: &Semantics<RootDatabase>,
 412     def: Definition,
 413     new_name: &str,
 414 ) -> Result<(FileId, TextEdit)> {
 415     let frange =
 416         def.rename_range(sema).ok_or_else(|| format_err!("No identifier available to rename"))?;
 417
 418     let mut replacement_text = String::new();
 419     let mut repl_range = frange.range;
 420     if let Definition::Local(local) = def {
 421         if let Either::Left(pat) = local.source(sema.db).value {
 422             if matches!(
 423                 pat.syntax().parent().and_then(ast::RecordPatField::cast),
 424                 Some(pat_field) if pat_field.name_ref().is_none()
 425             ) {
 426                 replacement_text.push_str(": ");
 427                 replacement_text.push_str(new_name);
 428                 repl_range = TextRange::new(
 429                     pat.syntax().text_range().end(),
 430                     pat.syntax().text_range().end(),
 431                 );
 432             }
 433         }
 434     }
 435     if replacement_text.is_empty() {
 436         replacement_text.push_str(new_name);
 437     }
 438     let edit = TextEdit::replace(repl_range, replacement_text);
 439     Ok((frange.file_id, edit))
 440 }
 441
 442 #[derive(Copy, Clone, Debug, PartialEq)]
 443 pub enum IdentifierKind {
 444     Ident,
 445     Lifetime,
 446     Underscore,
 447 }
 448
 449 impl IdentifierKind {
 450     pub fn classify(new_name: &str) -> Result<IdentifierKind> {
 451         match lex_single_syntax_kind(new_name) {
 452             Some(res) => match res {
 453                 (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
 454                 (T![_], _) => Ok(IdentifierKind::Underscore),
 455                 (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
 456                     Ok(IdentifierKind::Lifetime)
 457                 }
 458                 (SyntaxKind::LIFETIME_IDENT, _) => {
 459                     bail!("Invalid name `{}`: not a lifetime identifier", new_name)
 460                 }
 461                 (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
 462                 (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
 463             },
 464             None => bail!("Invalid name `{}`: not an identifier", new_name),
 465         }
 466     }
 467 }