1 files changed, 97 insertions, 61 deletions

diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 66f8bee99..25692793b 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -5,11 +5,13 @@
 use std::{
     io::Write as _,
     process::{self, Stdio},
+    sync::Arc,
 };
 
 use ide::{
-    CompletionResolveCapability, FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData,
-    NavigationTarget, Query, RangeInfo, Runnable, RunnableKind, SearchScope, SymbolKind, TextEdit,
+    AssistConfig, CompletionResolveCapability, FileId, FilePosition, FileRange, HoverAction,
+    HoverGotoTypeData, LineIndex, NavigationTarget, Query, RangeInfo, Runnable, RunnableKind,
+    SearchScope, SourceChange, SymbolKind, TextEdit,
 };
 use itertools::Itertools;
 use lsp_server::ErrorCode;
@@ -400,6 +402,45 @@ pub(crate) fn handle_workspace_symbol(
     }
 }
 
+pub(crate) fn handle_will_rename_files(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::RenameFilesParams,
+) -> Result<Option<lsp_types::WorkspaceEdit>> {
+    let _p = profile::span("handle_will_rename_files");
+
+    let source_changes: Vec<SourceChange> = params
+        .files
+        .into_iter()
+        .filter_map(|file_rename| {
+            let from = Url::parse(&file_rename.old_uri).ok()?;
+            let to = Url::parse(&file_rename.new_uri).ok()?;
+
+            let from_path = from.to_file_path().ok()?;
+            let to_path = to.to_file_path().ok()?;
+
+            // Limit to single-level moves for now.
+            match (from_path.parent(), to_path.parent()) {
+                (Some(p1), Some(p2)) if p1 == p2 => {
+                    let new_name = to_path.file_stem()?;
+                    let new_name = new_name.to_str()?;
+                    Some((snap.url_to_file_id(&from).ok()?, new_name.to_string()))
+                }
+                _ => None,
+            }
+        })
+        .filter_map(|(file_id, new_name)| {
+            snap.analysis.will_rename_file(file_id, &new_name).ok()?
+        })
+        .collect();
+
+    // Drop file system edits since we're just renaming things on the same level
+    let edits = source_changes.into_iter().map(|it| it.source_file_edits).flatten().collect();
+    let source_change = SourceChange::from_edits(edits, Vec::new());
+
+    let workspace_edit = to_proto::workspace_edit(&snap, source_change)?;
+    Ok(Some(workspace_edit))
+}
+
 pub(crate) fn handle_goto_definition(
     snap: GlobalStateSnapshot,
     params: lsp_types::GotoDefinitionParams,
@@ -865,58 +906,8 @@ pub(crate) fn handle_formatting(
     }
 }
 
-fn handle_fixes(
-    snap: &GlobalStateSnapshot,
-    params: &lsp_types::CodeActionParams,
-    res: &mut Vec<lsp_ext::CodeAction>,
-) -> Result<()> {
-    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
-    let line_index = snap.analysis.file_line_index(file_id)?;
-    let range = from_proto::text_range(&line_index, params.range);
-
-    match &params.context.only {
-        Some(v) => {
-            if !v.iter().any(|it| {
-                it == &lsp_types::CodeActionKind::EMPTY
-                    || it == &lsp_types::CodeActionKind::QUICKFIX
-            }) {
-                return Ok(());
-            }
-        }
-        None => {}
-    };
-
-    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics, file_id)?;
-
-    for fix in diagnostics
-        .into_iter()
-        .filter_map(|d| d.fix)
-        .filter(|fix| fix.fix_trigger_range.intersect(range).is_some())
-    {
-        let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
-        let action = lsp_ext::CodeAction {
-            title: fix.label.to_string(),
-            group: None,
-            kind: Some(CodeActionKind::QUICKFIX),
-            edit: Some(edit),
-            is_preferred: Some(false),
-            data: None,
-        };
-        res.push(action);
-    }
-
-    for fix in snap.check_fixes.get(&file_id).into_iter().flatten() {
-        let fix_range = from_proto::text_range(&line_index, fix.range);
-        if fix_range.intersect(range).is_none() {
-            continue;
-        }
-        res.push(fix.action.clone());
-    }
-    Ok(())
-}
-
 pub(crate) fn handle_code_action(
-    mut snap: GlobalStateSnapshot,
+    snap: GlobalStateSnapshot,
     params: lsp_types::CodeActionParams,
 ) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
     let _p = profile::span("handle_code_action");
@@ -932,24 +923,35 @@ pub(crate) fn handle_code_action(
     let range = from_proto::text_range(&line_index, params.range);
     let frange = FileRange { file_id, range };
 
-    snap.config.assist.allowed = params
-        .clone()
-        .context
-        .only
-        .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
+    let assists_config = AssistConfig {
+        allowed: params
+            .clone()
+            .context
+            .only
+            .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect()),
+        ..snap.config.assist
+    };
 
     let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
 
-    handle_fixes(&snap, &params, &mut res)?;
+    let include_quick_fixes = match &params.context.only {
+        Some(v) => v.iter().any(|it| {
+            it == &lsp_types::CodeActionKind::EMPTY || it == &lsp_types::CodeActionKind::QUICKFIX
+        }),
+        None => true,
+    };
+    if include_quick_fixes {
+        add_quick_fixes(&snap, frange, &line_index, &mut res)?;
+    }
 
     if snap.config.client_caps.code_action_resolve {
         for (index, assist) in
-            snap.analysis.unresolved_assists(&snap.config.assist, frange)?.into_iter().enumerate()
+            snap.analysis.unresolved_assists(&assists_config, frange)?.into_iter().enumerate()
         {
             res.push(to_proto::unresolved_code_action(&snap, params.clone(), assist, index)?);
         }
     } else {
-        for assist in snap.analysis.resolved_assists(&snap.config.assist, frange)?.into_iter() {
+        for assist in snap.analysis.resolved_assists(&assists_config, frange)?.into_iter() {
             res.push(to_proto::resolved_code_action(&snap, assist)?);
         }
     }
@@ -957,6 +959,40 @@ pub(crate) fn handle_code_action(
     Ok(Some(res))
 }
 
+fn add_quick_fixes(
+    snap: &GlobalStateSnapshot,
+    frange: FileRange,
+    line_index: &Arc<LineIndex>,
+    acc: &mut Vec<lsp_ext::CodeAction>,
+) -> Result<()> {
+    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics, frange.file_id)?;
+
+    for fix in diagnostics
+        .into_iter()
+        .filter_map(|d| d.fix)
+        .filter(|fix| fix.fix_trigger_range.intersect(frange.range).is_some())
+    {
+        let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
+        let action = lsp_ext::CodeAction {
+            title: fix.label.to_string(),
+            group: None,
+            kind: Some(CodeActionKind::QUICKFIX),
+            edit: Some(edit),
+            is_preferred: Some(false),
+            data: None,
+        };
+        acc.push(action);
+    }
+
+    for fix in snap.check_fixes.get(&frange.file_id).into_iter().flatten() {
+        let fix_range = from_proto::text_range(&line_index, fix.range);
+        if fix_range.intersect(frange.range).is_some() {
+            acc.push(fix.action.clone());
+        }
+    }
+    Ok(())
+}
+
 pub(crate) fn handle_code_action_resolve(
     mut snap: GlobalStateSnapshot,
     mut code_action: lsp_ext::CodeAction,