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.
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
11 //! Another can of worms are macros:
14 //! macro_rules! m { () => { fn f() {} } }
17 //! f() // <- rename me
21 //! The correct behavior in such cases is probably to show a dialog to the user.
22 //! Our current behavior is ¯\_(ツ)_/¯.
25 use base_db::{AnchoredPathBuf, FileId, FileRange};
27 use hir::{FieldSource, HasSource, InFile, ModuleSource, Semantics};
31 AstNode, SyntaxKind, TextRange, T,
33 use text_edit::{TextEdit, TextEditBuilder};
37 search::FileReference,
38 source_change::{FileSystemEdit, SourceChange},
39 syntax_helpers::node_ext::expr_as_name_ref,
40 traits::convert_to_def_in_trait,
44 pub type Result<T, E = RenameError> = std::result::Result<T, E>;
47 pub struct RenameError(pub String);
49 impl fmt::Display for RenameError {
50 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
51 fmt::Display::fmt(&self.0, f)
56 macro_rules! _format_err {
57 ($fmt:expr) => { RenameError(format!($fmt)) };
58 ($fmt:expr, $($arg:tt)+) => { RenameError(format!($fmt, $($arg)+)) }
60 pub use _format_err as format_err;
64 ($($tokens:tt)*) => { return Err(format_err!($($tokens)*)) }
66 pub use _bail as bail;
71 sema: &Semantics<'_, RootDatabase>,
73 ) -> Result<SourceChange> {
75 Definition::Module(module) => rename_mod(sema, module, new_name),
76 Definition::BuiltinType(_) => {
77 bail!("Cannot rename builtin type")
79 Definition::SelfType(_) => bail!("Cannot rename `Self`"),
80 def => rename_reference(sema, def, new_name),
84 /// Textual range of the identifier which will change when renaming this
85 /// `Definition`. Note that some definitions, like builtin types, can't be
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()?,
95 src.with_value(name.syntax()).original_file_range_opt(sema.db)
97 Definition::Field(field) => {
98 let src = field.source(sema.db)?;
100 FieldSource::Named(record_field) => {
101 let name = record_field.name()?;
102 src.with_value(name.syntax()).original_file_range_opt(sema.db)
104 FieldSource::Pos(_) => None,
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)
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),
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,
129 src.with_value(name.syntax()).original_file_range_opt(sema.db)
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)
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,
142 let src = x.source(sema.db)?;
143 let name = match &src.value {
144 Either::Left(x) => x.name()?,
145 Either::Right(_) => return None,
147 src.with_value(name.syntax()).original_file_range_opt(sema.db)
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)
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,
164 fn name_range<D>(def: D, sema: &Semantics<'_, RootDatabase>) -> Option<FileRange>
167 D::Ast: ast::HasName,
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)
177 sema: &Semantics<'_, RootDatabase>,
180 ) -> Result<SourceChange> {
181 if IdentifierKind::classify(new_name)? != IdentifierKind::Ident {
182 bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
185 let mut source_change = SourceChange::default();
187 if module.is_crate_root(sema.db) {
188 return Ok(source_change);
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);
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));
198 // Module exists in a named file
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 })
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)))
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())),
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 {
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() {
233 if let Some(file_range) =
234 src.with_value(name.syntax()).original_file_range_opt(sema.db)
236 source_change.insert_source_edit(
238 TextEdit::replace(file_range.range, new_name.to_string()),
242 _ => never!("Module source node is missing a name"),
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))
251 source_change.extend(ref_edits);
257 sema: &Semantics<'_, RootDatabase>,
260 ) -> Result<SourceChange> {
261 let ident_kind = IdentifierKind::classify(new_name)?;
265 Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
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);
272 IdentifierKind::Lifetime => cov_mark::hit!(rename_lifetime),
276 IdentifierKind::Lifetime => {
277 cov_mark::hit!(rename_not_an_ident_ref);
278 bail!("Invalid name `{}`: not an identifier", new_name);
280 IdentifierKind::Ident => cov_mark::hit!(rename_non_local),
281 IdentifierKind::Underscore => (),
285 let def = convert_to_def_in_trait(sema.db, def);
286 let usages = def.usages(sema).all();
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");
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))
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);
303 Definition::Local(l) => l
304 .associated_locals(sema.db)
306 .try_for_each(|&local| insert_def_edit(Definition::Local(local))),
307 def => insert_def_edit(def),
312 pub fn source_edit_from_references(
313 references: &[FileReference],
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
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
331 ast::NameLike::NameRef(name_ref) if name_range == range => {
332 source_edit_from_name_ref(&mut edit, name_ref, new_name, def)
334 ast::NameLike::Name(name) if name_range == range => {
335 source_edit_from_name(&mut edit, name, new_name)
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());
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: `
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));
367 fn source_edit_from_name_ref(
368 edit: &mut TextEditBuilder,
369 name_ref: &ast::NameRef,
373 if name_ref.super_token().is_some() {
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
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));
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
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));
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));
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));
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) {
435 (Some(field_name), Some(ast::Pat::IdentPat(pat)))
436 if field_name == *name_ref && pat.at_token().is_none() =>
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`
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());
462 fn source_edit_from_def(
463 sema: &Semantics<'_, RootDatabase>,
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"))?;
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);
487 .cover_offset(pat.syntax().text_range().start()),
489 edit.replace(name_range, name_ref.text().to_string());
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());
497 // Foo { ref mut field } -> Foo { field: ref mut new_name }
498 // ^ insert `field: `
499 // ^^^^^ replace this with `new_name`
501 pat.syntax().text_range().start(),
502 format!("{}: ", pat_field.field_name().unwrap()),
504 edit.replace(name_range, new_name.to_string());
510 edit.replace(range, new_name.to_string());
512 Ok((file_id, edit.finish()))
515 #[derive(Copy, Clone, Debug, PartialEq)]
516 pub enum IdentifierKind {
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)
531 (SyntaxKind::LIFETIME_IDENT, _) => {
532 bail!("Invalid name `{}`: not a lifetime identifier", new_name)
534 (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
535 (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
537 None => bail!("Invalid name `{}`: not an identifier", new_name),