1 //! Renaming functionality.
3 //! This is mostly front-end for [`ide_db::rename`], but it also includes the
4 //! tests. This module also implements a couple of magic tricks, like renaming
5 //! `self` and to `self` (to switch between associated function and method).
7 use hir::{AsAssocItem, InFile, Semantics};
10 defs::{Definition, NameClass, NameRefClass},
11 rename::{bail, format_err, source_edit_from_references, IdentifierKind},
14 use itertools::Itertools;
15 use stdx::{always, never};
16 use syntax::{ast, AstNode, SyntaxNode};
18 use text_edit::TextEdit;
20 use crate::{FilePosition, RangeInfo, SourceChange};
22 pub use ide_db::rename::RenameError;
24 type RenameResult<T> = Result<T, RenameError>;
26 /// Prepares a rename. The sole job of this function is to return the TextRange of the thing that is
27 /// being targeted for a rename.
28 pub(crate) fn prepare_rename(
30 position: FilePosition,
31 ) -> RenameResult<RangeInfo<()>> {
32 let sema = Semantics::new(db);
33 let source_file = sema.parse(position.file_id);
34 let syntax = source_file.syntax();
36 let mut defs = find_definitions(&sema, syntax, position)?;
39 // - `find_definitions` is implemented so that it returns a non-empty vec
40 // in the `Ok` case. But that's not expressed by the type signature, hence `unwrap()`
41 // here which ... wart.
42 // - is "just take the first `name_like`" correct? If not, what do?
43 let (name_like, _def) = defs.next().unwrap();
44 let frange = sema.original_range(name_like.syntax());
45 always!(frange.range.contains_inclusive(position.offset) && frange.file_id == position.file_id);
46 Ok(RangeInfo::new(frange.range, ()))
51 // Renames the item below the cursor and all of its references
54 // | Editor | Shortcut
56 // | VS Code | kbd:[F2]
59 // image::https://user-images.githubusercontent.com/48062697/113065582-055aae80-91b1-11eb-8ade-2b58e6d81883.gif[]
62 position: FilePosition,
64 ) -> RenameResult<SourceChange> {
65 let sema = Semantics::new(db);
66 let source_file = sema.parse(position.file_id);
67 let syntax = source_file.syntax();
69 let defs = find_definitions(&sema, syntax, position)?;
71 let ops: RenameResult<Vec<SourceChange>> = defs
72 .map(|(_namelike, def)| {
73 if let Definition::Local(local) = def {
74 if let Some(self_param) = local.as_self_param(sema.db) {
75 cov_mark::hit!(rename_self_to_param);
76 return rename_self_to_param(&sema, local, self_param, new_name);
78 if new_name == "self" {
79 cov_mark::hit!(rename_to_self);
80 return rename_to_self(&sema, local);
83 def.rename(&sema, new_name)
87 .reduce(|acc, elem| acc.merge(elem))
88 .ok_or_else(|| format_err!("No references found at position"))
91 /// Called by the client when it is about to rename a file.
92 pub(crate) fn will_rename_file(
96 ) -> Option<SourceChange> {
97 let sema = Semantics::new(db);
98 let module = sema.to_module_def(file_id)?;
99 let def = Definition::ModuleDef(module.into());
100 let mut change = def.rename(&sema, new_name_stem).ok()?;
101 change.file_system_edits.clear();
106 sema: &Semantics<RootDatabase>,
108 position: FilePosition,
109 ) -> RenameResult<impl Iterator<Item = (ast::NameLike, Definition)>> {
111 .find_nodes_at_offset_with_descend::<ast::NameLike>(syntax, position.offset)
113 let res = match &name_like {
114 // renaming aliases would rename the item being aliased as the HIR doesn't track aliases yet
115 ast::NameLike::Name(name)
119 .map_or(false, |it| ast::Rename::can_cast(it.kind())) =>
121 bail!("Renaming aliases is currently unsupported")
123 ast::NameLike::Name(name) => NameClass::classify(sema, name)
124 .map(|class| match class {
125 NameClass::Definition(it) | NameClass::ConstReference(it) => it,
126 NameClass::PatFieldShorthand { local_def, field_ref: _ } => {
127 Definition::Local(local_def)
130 .map(|def| (name_like.clone(), def))
131 .ok_or_else(|| format_err!("No references found at position")),
132 ast::NameLike::NameRef(name_ref) => NameRefClass::classify(sema, name_ref)
133 .map(|class| match class {
134 NameRefClass::Definition(def) => def,
135 NameRefClass::FieldShorthand { local_ref, field_ref: _ } => {
136 Definition::Local(local_ref)
140 // if the name differs from the definitions name it has to be an alias
141 if def.name(sema.db).map_or(false, |it| it.to_string() != name_ref.text()) {
144 Some((name_like.clone(), def))
147 .ok_or_else(|| format_err!("Renaming aliases is currently unsupported")),
148 ast::NameLike::Lifetime(lifetime) => {
149 NameRefClass::classify_lifetime(sema, lifetime)
150 .and_then(|class| match class {
151 NameRefClass::Definition(def) => Some(def),
155 NameClass::classify_lifetime(sema, lifetime).and_then(|it| match it {
156 NameClass::Definition(it) => Some(it),
160 .map(|def| (name_like, def))
161 .ok_or_else(|| format_err!("No references found at position"))
167 // TODO avoid collect() somehow?
168 let v: RenameResult<Vec<(ast::NameLike, Definition)>> = symbols.collect();
171 // TODO is "unique by `Definition`" correct?
174 Err(format_err!("No references found at position"))
176 Ok(v.into_iter().unique_by(|t| t.1))
183 fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
184 if never!(local.is_self(sema.db)) {
185 bail!("rename_to_self invoked on self");
188 let fn_def = match local.parent(sema.db) {
189 hir::DefWithBody::Function(func) => func,
190 _ => bail!("Cannot rename local to self outside of function"),
193 if fn_def.self_param(sema.db).is_some() {
194 bail!("Method already has a self parameter");
197 let params = fn_def.assoc_fn_params(sema.db);
198 let first_param = params
200 .ok_or_else(|| format_err!("Cannot rename local to self unless it is a parameter"))?;
201 if first_param.as_local(sema.db) != local {
202 bail!("Only the first parameter may be renamed to self");
205 let assoc_item = fn_def
206 .as_assoc_item(sema.db)
207 .ok_or_else(|| format_err!("Cannot rename parameter to self for free function"))?;
208 let impl_ = match assoc_item.container(sema.db) {
209 hir::AssocItemContainer::Trait(_) => {
210 bail!("Cannot rename parameter to self for trait functions");
212 hir::AssocItemContainer::Impl(impl_) => impl_,
214 let first_param_ty = first_param.ty();
215 let impl_ty = impl_.self_ty(sema.db);
216 let (ty, self_param) = if impl_ty.remove_ref().is_some() {
217 // if the impl is a ref to the type we can just match the `&T` with self directly
218 (first_param_ty.clone(), "self")
220 first_param_ty.remove_ref().map_or((first_param_ty.clone(), "self"), |ty| {
221 (ty, if first_param_ty.is_mutable_reference() { "&mut self" } else { "&self" })
226 bail!("Parameter type differs from impl block type");
229 let InFile { file_id, value: param_source } =
230 first_param.source(sema.db).ok_or_else(|| format_err!("No source for parameter found"))?;
232 let def = Definition::Local(local);
233 let usages = def.usages(sema).all();
234 let mut source_change = SourceChange::default();
235 source_change.extend(usages.iter().map(|(&file_id, references)| {
236 (file_id, source_edit_from_references(references, def, "self"))
238 source_change.insert_source_edit(
239 file_id.original_file(sema.db),
240 TextEdit::replace(param_source.syntax().text_range(), String::from(self_param)),
245 fn rename_self_to_param(
246 sema: &Semantics<RootDatabase>,
248 self_param: hir::SelfParam,
250 ) -> RenameResult<SourceChange> {
251 if new_name == "self" {
252 // Let's do nothing rather than complain.
253 cov_mark::hit!(rename_self_to_self);
254 return Ok(SourceChange::default());
257 let identifier_kind = IdentifierKind::classify(new_name)?;
259 let InFile { file_id, value: self_param } =
260 self_param.source(sema.db).ok_or_else(|| format_err!("cannot find function source"))?;
262 let def = Definition::Local(local);
263 let usages = def.usages(sema).all();
264 let edit = text_edit_from_self_param(&self_param, new_name)
265 .ok_or_else(|| format_err!("No target type found"))?;
266 if usages.len() > 1 && identifier_kind == IdentifierKind::Underscore {
267 bail!("Cannot rename reference to `_` as it is being referenced multiple times");
269 let mut source_change = SourceChange::default();
270 source_change.insert_source_edit(file_id.original_file(sema.db), edit);
271 source_change.extend(usages.iter().map(|(&file_id, references)| {
272 (file_id, source_edit_from_references(references, def, new_name))
277 fn text_edit_from_self_param(self_param: &ast::SelfParam, new_name: &str) -> Option<TextEdit> {
278 fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
279 if let Some(ast::Type::PathType(p)) = impl_def.self_ty() {
280 return Some(p.path()?.segment()?.name_ref()?.text().to_string());
285 let impl_def = self_param.syntax().ancestors().find_map(ast::Impl::cast)?;
286 let type_name = target_type_name(&impl_def)?;
288 let mut replacement_text = String::from(new_name);
289 replacement_text.push_str(": ");
290 match (self_param.amp_token(), self_param.mut_token()) {
291 (Some(_), None) => replacement_text.push('&'),
292 (Some(_), Some(_)) => replacement_text.push_str("&mut "),
295 replacement_text.push_str(type_name.as_str());
297 Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))
302 use expect_test::{expect, Expect};
303 use stdx::trim_indent;
304 use test_utils::assert_eq_text;
305 use text_edit::TextEdit;
307 use crate::{fixture, FileId};
309 use super::{RangeInfo, RenameError};
312 fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
313 let ra_fixture_after = &trim_indent(ra_fixture_after);
314 let (analysis, position) = fixture::position(ra_fixture_before);
315 let rename_result = analysis
316 .rename(position, new_name)
317 .unwrap_or_else(|err| panic!("Rename to '{}' was cancelled: {}", new_name, err));
318 match rename_result {
319 Ok(source_change) => {
320 let mut text_edit_builder = TextEdit::builder();
321 let mut file_id: Option<FileId> = None;
322 for edit in source_change.source_file_edits {
323 file_id = Some(edit.0);
324 for indel in edit.1.into_iter() {
325 text_edit_builder.replace(indel.delete, indel.insert);
328 if let Some(file_id) = file_id {
329 let mut result = analysis.file_text(file_id).unwrap().to_string();
330 text_edit_builder.finish().apply(&mut result);
331 assert_eq_text!(ra_fixture_after, &*result);
335 if ra_fixture_after.starts_with("error:") {
336 let error_message = ra_fixture_after
339 .skip("error:".len())
340 .collect::<String>();
341 assert_eq!(error_message.trim(), err.to_string());
343 panic!("Rename to '{}' failed unexpectedly: {}", new_name, err)
349 fn check_expect(new_name: &str, ra_fixture: &str, expect: Expect) {
350 let (analysis, position) = fixture::position(ra_fixture);
352 analysis.rename(position, new_name).unwrap().expect("Expect returned a RenameError");
353 expect.assert_debug_eq(&source_change)
356 fn check_prepare(ra_fixture: &str, expect: Expect) {
357 let (analysis, position) = fixture::position(ra_fixture);
358 let result = analysis
359 .prepare_rename(position)
360 .unwrap_or_else(|err| panic!("PrepareRename was cancelled: {}", err));
362 Ok(RangeInfo { range, info: () }) => {
363 let source = analysis.file_text(position.file_id).unwrap();
364 expect.assert_eq(&format!("{:?}: {}", range, &source[range]))
366 Err(RenameError(err)) => expect.assert_eq(&err),
371 fn test_prepare_rename_namelikes() {
372 check_prepare(r"fn name$0<'lifetime>() {}", expect![[r#"3..7: name"#]]);
373 check_prepare(r"fn name<'lifetime$0>() {}", expect![[r#"8..17: 'lifetime"#]]);
374 check_prepare(r"fn name<'lifetime>() { name$0(); }", expect![[r#"23..27: name"#]]);
378 fn test_prepare_rename_in_macro() {
386 expect![[r#"83..86: Foo"#]],
391 fn test_prepare_rename_keyword() {
392 check_prepare(r"struct$0 Foo;", expect![[r#"No references found at position"#]]);
396 fn test_prepare_rename_tuple_field() {
406 expect![[r#"No references found at position"#]],
411 fn test_prepare_rename_builtin() {
418 expect![[r#"No references found at position"#]],
423 fn test_prepare_rename_self() {
429 fn foo(self) -> Self$0 {
434 expect![[r#"No references found at position"#]],
439 fn test_rename_to_underscore() {
440 check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
444 fn test_rename_to_raw_identifier() {
445 check("r#fn", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let r#fn = 1; }"#);
449 fn test_rename_to_invalid_identifier1() {
452 r#"fn main() { let i$0 = 1; }"#,
453 "error: Invalid name `invalid!`: not an identifier",
458 fn test_rename_to_invalid_identifier2() {
461 r#"fn main() { let i$0 = 1; }"#,
462 "error: Invalid name `multiple tokens`: not an identifier",
467 fn test_rename_to_invalid_identifier3() {
470 r#"fn main() { let i$0 = 1; }"#,
471 "error: Invalid name `let`: not an identifier",
476 fn test_rename_to_invalid_identifier_lifetime() {
477 cov_mark::check!(rename_not_an_ident_ref);
480 r#"fn main() { let i$0 = 1; }"#,
481 "error: Invalid name `'foo`: not an identifier",
486 fn test_rename_to_invalid_identifier_lifetime2() {
487 cov_mark::check!(rename_not_a_lifetime_ident_ref);
490 r#"fn main<'a>(_: &'a$0 ()) {}"#,
491 "error: Invalid name `foo`: not a lifetime identifier",
496 fn test_rename_to_underscore_invalid() {
497 cov_mark::check!(rename_underscore_multiple);
500 r#"fn main(foo$0: ()) {foo;}"#,
501 "error: Cannot rename reference to `_` as it is being referenced multiple times",
506 fn test_rename_mod_invalid() {
510 "error: Invalid name `'foo`: cannot rename module to 'foo",
515 fn test_rename_for_local() {
544 fn test_rename_unresolved_reference() {
547 r#"fn main() { let _ = unresolved_ref$0; }"#,
548 "error: No references found at position",
553 fn test_rename_for_macro_args() {
557 macro_rules! foo {($i:ident) => {$i} }
564 macro_rules! foo {($i:ident) => {$i} }
574 fn test_rename_for_macro_args_rev() {
578 macro_rules! foo {($i:ident) => {$i} }
585 macro_rules! foo {($i:ident) => {$i} }
595 fn test_rename_for_macro_define_fn() {
599 macro_rules! define_fn {($id:ident) => { fn $id{} }}
606 macro_rules! define_fn {($id:ident) => { fn $id{} }}
616 fn test_rename_for_macro_define_fn_rev() {
620 macro_rules! define_fn {($id:ident) => { fn $id{} }}
627 macro_rules! define_fn {($id:ident) => { fn $id{} }}
637 fn test_rename_for_param_inside() {
638 check("j", r#"fn foo(i : u32) -> u32 { i$0 }"#, r#"fn foo(j : u32) -> u32 { j }"#);
642 fn test_rename_refs_for_fn_param() {
643 check("j", r#"fn foo(i$0 : u32) -> u32 { i }"#, r#"fn foo(j : u32) -> u32 { j }"#);
647 fn test_rename_for_mut_param() {
648 check("j", r#"fn foo(mut i$0 : u32) -> u32 { i }"#, r#"fn foo(mut j : u32) -> u32 { j }"#);
652 fn test_rename_struct_field() {
656 struct Foo { field$0: i32 }
659 fn new(i: i32) -> Self {
665 struct Foo { foo: i32 }
668 fn new(i: i32) -> Self {
677 fn test_rename_field_in_field_shorthand() {
678 cov_mark::check!(test_rename_field_in_field_shorthand);
682 struct Foo { foo$0: i32 }
685 fn new(foo: i32) -> Self {
691 struct Foo { field: i32 }
694 fn new(foo: i32) -> Self {
703 fn test_rename_local_in_field_shorthand() {
704 cov_mark::check!(test_rename_local_in_field_shorthand);
708 struct Foo { i: i32 }
711 fn new(i$0: i32) -> Self {
717 struct Foo { i: i32 }
720 fn new(j: i32) -> Self {
729 fn test_field_shorthand_correct_struct() {
733 struct Foo { i$0: i32 }
734 struct Bar { i: i32 }
737 fn new(i: i32) -> Self {
743 struct Foo { j: i32 }
744 struct Bar { i: i32 }
747 fn new(i: i32) -> Self {
756 fn test_shadow_local_for_struct_shorthand() {
760 struct Foo { i: i32 }
762 fn baz(i$0: i32) -> Self {
771 struct Foo { i: i32 }
773 fn baz(j: i32) -> Self {
774 let x = Foo { i: j };
785 fn test_rename_mod() {
817 dst: AnchoredPathBuf {
832 fn test_rename_mod_in_use_tree() {
842 pub struct FooContent;
845 use crate::foo$0::FooContent;
876 dst: AnchoredPathBuf {
891 fn test_rename_mod_in_dir() {
919 dst: AnchoredPathBuf {
923 path: "../foo2/mod.rs",
934 fn test_rename_unusually_nested_mod() {
939 mod outer { mod fo$0o; }
963 dst: AnchoredPathBuf {
978 fn test_module_rename_in_path() {
983 pub use self::bar as qux;
987 fn main() { foo::bar(); }
991 pub use self::bar as qux;
995 fn main() { baz::bar(); }
1001 fn test_rename_mod_filename_and_path() {
1019 source_file_edits: {
1041 file_system_edits: [
1046 dst: AnchoredPathBuf {
1061 fn test_enum_variant_from_module_1() {
1062 cov_mark::check!(rename_non_local);
1067 pub enum Foo { Bar$0 }
1070 fn func(f: foo::Foo) {
1078 pub enum Foo { Baz }
1081 fn func(f: foo::Foo) {
1091 fn test_enum_variant_from_module_2() {
1096 pub struct Foo { pub bar$0: uint }
1099 fn foo(f: foo::Foo) {
1105 pub struct Foo { pub baz: uint }
1108 fn foo(f: foo::Foo) {
1116 fn test_parameter_to_self() {
1117 cov_mark::check!(rename_to_self);
1121 struct Foo { i: i32 }
1124 fn f(foo$0: &mut Foo) -> i32 {
1130 struct Foo { i: i32 }
1133 fn f(&mut self) -> i32 {
1142 struct Foo { i: i32 }
1145 fn f(foo$0: Foo) -> i32 {
1151 struct Foo { i: i32 }
1163 fn test_parameter_to_self_error_no_impl() {
1167 struct Foo { i: i32 }
1169 fn f(foo$0: &mut Foo) -> i32 {
1173 "error: Cannot rename parameter to self for free function",
1178 struct Foo { i: i32 }
1182 fn f(foo$0: &mut Foo) -> i32 {
1187 "error: Parameter type differs from impl block type",
1192 fn test_parameter_to_self_error_not_first() {
1196 struct Foo { i: i32 }
1198 fn f(x: (), foo$0: &mut Foo) -> i32 {
1203 "error: Only the first parameter may be renamed to self",
1208 fn test_parameter_to_self_impl_ref() {
1212 struct Foo { i: i32 }
1214 fn f(foo$0: &Foo) -> i32 {
1220 struct Foo { i: i32 }
1231 fn test_self_to_parameter() {
1235 struct Foo { i: i32 }
1238 fn f(&mut $0self) -> i32 {
1244 struct Foo { i: i32 }
1247 fn f(foo: &mut Foo) -> i32 {
1256 fn test_owned_self_to_parameter() {
1257 cov_mark::check!(rename_self_to_param);
1261 struct Foo { i: i32 }
1264 fn f($0self) -> i32 {
1270 struct Foo { i: i32 }
1273 fn f(foo: Foo) -> i32 {
1282 fn test_self_in_path_to_parameter() {
1286 struct Foo { i: i32 }
1289 fn f(&self) -> i32 {
1296 struct Foo { i: i32 }
1299 fn f(foo: &Foo) -> i32 {
1309 fn test_rename_field_put_init_shorthand() {
1310 cov_mark::check!(test_rename_field_put_init_shorthand);
1314 struct Foo { i$0: i32 }
1316 fn foo(bar: i32) -> Foo {
1321 struct Foo { bar: i32 }
1323 fn foo(bar: i32) -> Foo {
1331 fn test_rename_local_put_init_shorthand() {
1332 cov_mark::check!(test_rename_local_put_init_shorthand);
1336 struct Foo { i: i32 }
1338 fn foo(bar$0: i32) -> Foo {
1343 struct Foo { i: i32 }
1345 fn foo(i: i32) -> Foo {
1353 fn test_struct_field_pat_into_shorthand() {
1354 cov_mark::check!(test_rename_field_put_init_shorthand_pat);
1358 struct Foo { i$0: i32 }
1361 let Foo { i: ref baz @ qux } = foo;
1366 struct Foo { baz: i32 }
1369 let Foo { baz: ref baz @ qux } = foo;
1377 struct Foo { i$0: i32 }
1380 let Foo { i: ref baz } = foo;
1385 struct Foo { baz: i32 }
1388 let Foo { ref baz } = foo;
1396 fn test_struct_local_pat_into_shorthand() {
1397 cov_mark::check!(test_rename_local_put_init_shorthand_pat);
1401 struct Foo { field: i32 }
1404 let Foo { field: qux$0 } = foo;
1409 struct Foo { field: i32 }
1412 let Foo { field } = foo;
1420 struct Foo { field: i32 }
1423 let Foo { field: x @ qux$0 } = foo;
1428 struct Foo { field: i32 }
1431 let Foo { field: x @ field } = foo;
1439 fn test_rename_binding_in_destructure_pat() {
1440 let expected_fixture = r#"
1446 let Foo { i: bar } = foo;
1458 let Foo { i: b } = foo;
1472 let Foo { i } = foo;
1481 fn test_rename_binding_in_destructure_param_pat() {
1489 fn foo(Foo { i }: Foo) -> i32 {
1498 fn foo(Foo { i: bar }: Foo) -> i32 {
1506 fn test_struct_field_complex_ident_pat() {
1507 cov_mark::check!(rename_record_pat_field_name_split);
1511 struct Foo { i$0: i32 }
1514 let Foo { ref i } = foo;
1518 struct Foo { baz: i32 }
1521 let Foo { baz: ref i } = foo;
1528 fn test_rename_lifetimes() {
1529 cov_mark::check!(rename_lifetime);
1536 impl<'a> Foo<'a> for &'a () {
1537 fn foo() -> &'a$0 () {
1546 impl<'yeeee> Foo<'yeeee> for &'yeeee () {
1547 fn foo() -> &'yeeee () {
1556 fn test_rename_bind_pat() {
1561 enum CustomOption<T> {
1566 let test_variable = CustomOption::Some(22);
1568 match test_variable {
1569 CustomOption::Some(foo$0) if foo == 11 => {}
1575 enum CustomOption<T> {
1580 let test_variable = CustomOption::Some(22);
1582 match test_variable {
1583 CustomOption::Some(new_name) if new_name == 11 => {}
1591 fn test_rename_label() {
1595 fn foo<'a>() -> &'a () {
1604 fn foo<'a>() -> &'a () {
1616 fn test_self_to_self() {
1617 cov_mark::check!(rename_self_to_self);
1636 fn test_rename_field_in_pat_in_macro_doesnt_shorthand() {
1637 // ideally we would be able to make this emit a short hand, but I doubt this is easily possible
1643 let $pattern = loop {};
1650 foo!(Foo { bar: baz });
1656 let $pattern = loop {};
1663 foo!(Foo { baz: baz });
1670 fn test_rename_tuple_field() {
1681 "error: No identifier available to rename",
1686 fn test_rename_builtin() {
1694 "error: Cannot rename builtin type",
1699 fn test_rename_self() {
1706 fn foo(self) -> Self$0 {
1711 "error: Cannot rename `Self`",
1716 fn test_rename_ignores_self_ty() {
1722 impl Foo where Self: {}
1727 impl Fo0 where Self: {}
1733 fn test_rename_fails_on_aliases() {
1740 "error: Renaming aliases is currently unsupported",
1749 "error: Renaming aliases is currently unsupported",
1754 fn test_rename_trait_method() {
1834 fn test_rename_trait_method_prefix_of_second() {
1853 fn test_rename_trait_const() {
1862 fn f() { <()>::FOO; }";
1873 fn f() { <()>::BAR; }"#,
1886 fn f() { <()>::BAR; }"#,
1899 fn f() { <()>::BAR$0; }"#,
1905 fn defs_from_macros_arent_renamed() {
1909 macro_rules! m { () => { fn f() {} } }
1913 "error: No identifier available to rename",
1918 fn attributed_item() {
1922 //- proc_macros: identity
1924 #[proc_macros::identity]
1931 #[proc_macros::identity]
1940 fn in_macro_multi_mapping() {
1945 macro_rules! match_ast2 {
1949 $( if $node { $res } else )*
1964 macro_rules! match_ast2 {
1968 $( if $node { $res } else )*