feat: append as <name> when renaming inside an "UseTree".

test: include `rename_path_inside_use_tree`.

Keeps tracks the progress of the changes. 3 other tests broke with the changes
of this.

feat: rename all other usages within the current file.

feat: fix most of the implementation problems.

test: `rename_path_inside_use_tree` tests a more complicated scenario.

Author: UserIsntAvailable

crates/ide/src/rename.rs

@@ -9,6 +9,7 @@ use ide_db::{
     base_db::{FileId, FileRange},
     defs::{Definition, NameClass, NameRefClass},
     rename::{bail, format_err, source_edit_from_references, IdentifierKind},
+    source_change::SourceChangeBuilder,
     RootDatabase,
 };
 use itertools::Itertools;
@@ -91,24 +92,52 @@ pub(crate) fn rename(
     let syntax = source_file.syntax();
 
     let defs = find_definitions(&sema, syntax, position)?;
+    let alias_fallback = alias_fallback(&sema, syntax, position, new_name)?;
+
+    let ops: RenameResult<Vec<SourceChange>> = match alias_fallback {
+        Some(_) => defs
+            .map(|(.., def)| {
+                let mut usages = def.usages(&sema).all();
+
+                // Remove the usage that triggered this rename operation.
+                match usages.references.get_mut(&position.file_id) {
+                    Some(refs) => {
+                        let position = refs
+                            .iter()
+                            .position(|ref_| ref_.range.contains_inclusive(position.offset));
+                        never!(position.is_none());
+                        refs.remove(position.unwrap());
+                    }
+                    None => never!(),
+                };
 
-    let ops: RenameResult<Vec<SourceChange>> = defs
-        .map(|(.., def)| {
-            if let Definition::Local(local) = def {
-                if let Some(self_param) = local.as_self_param(sema.db) {
-                    cov_mark::hit!(rename_self_to_param);
-                    return rename_self_to_param(&sema, local, self_param, new_name);
-                }
-                if new_name == "self" {
-                    cov_mark::hit!(rename_to_self);
-                    return rename_to_self(&sema, local);
+                let mut source_change = SourceChange::default();
+                source_change.extend(usages.iter().map(|(&file_id, refs)| {
+                    (file_id, source_edit_from_references(refs, def, new_name))
+                }));
+
+                Ok(source_change)
+            })
+            .collect(),
+        None => defs
+            .map(|(.., def)| {
+                if let Definition::Local(local) = def {
+                    if let Some(self_param) = local.as_self_param(sema.db) {
+                        cov_mark::hit!(rename_self_to_param);
+                        return rename_self_to_param(&sema, local, self_param, new_name);
+                    }
+                    if new_name == "self" {
+                        cov_mark::hit!(rename_to_self);
+                        return rename_to_self(&sema, local);
+                    }
                 }
-            }
-            def.rename(&sema, new_name, rename_external)
-        })
-        .collect();
+                def.rename(&sema, new_name, rename_external)
+            })
+            .collect(),
+    };
 
     ops?.into_iter()
+        .chain(alias_fallback)
         .reduce(|acc, elem| acc.merge(elem))
         .ok_or_else(|| format_err!("No references found at position"))
 }
@@ -131,6 +160,46 @@ pub(crate) fn will_rename_file(
     Some(change)
 }
 
+// FIXME: Allow usage with `extern crate`?
+fn alias_fallback(
+    sema: &Semantics<'_, RootDatabase>,
+    syntax: &SyntaxNode,
+    FilePosition { file_id, offset }: FilePosition,
+    new_name: &str,
+) -> RenameResult<Option<SourceChange>> {
+    match sema.find_node_at_offset_with_descend::<ast::UseTree>(syntax, offset) {
+        Some(use_tree) => {
+            if let Some(_rename) = use_tree.rename() {
+                return Ok(None); // FIXME: path already has an alias
+            };
+
+            if let Some(last_segment) = use_tree.path().and_then(|path| path.segments().last()) {
+                if !last_segment
+                    .name_ref()
+                    .is_some_and(|name| name.syntax().text_range().contains_inclusive(offset))
+                {
+                    return Ok(None); // FIXME: path isn't last path segment
+                }
+            };
+
+            match IdentifierKind::classify(new_name)? {
+                IdentifierKind::Ident => (),
+                IdentifierKind::Lifetime => {
+                    bail!("Cannot alias reference to a lifetime identifier")
+                }
+                IdentifierKind::Underscore => bail!("Cannot alias reference to `_`"),
+            };
+
+            let mut builder = SourceChangeBuilder::new(file_id);
+            let offset = use_tree.syntax().text_range().end();
+            builder.insert(offset, format!(" as {new_name}"));
+
+            Ok(Some(builder.finish()))
+        }
+        None => Ok(None),
+    }
+}
+
 fn find_definitions(
     sema: &Semantics<'_, RootDatabase>,
     syntax: &SyntaxNode,
@@ -2707,4 +2776,27 @@ fn test() {
 "#,
         );
     }
+
+    #[test]
+    fn rename_path_inside_use_tree() {
+        check(
+            "Baz",
+            r#"
+mod foo { pub struct Foo; }
+mod bar { use super::Foo; }
+
+use foo::Foo$0;
+
+fn main() { let _: Foo; }
+"#,
+            r#"
+mod foo { pub struct Foo; }
+mod bar { use super::Baz; }
+
+use foo::Foo as Baz;
+
+fn main() { let _: Baz; }
+"#,
+        )
+    }
 }