3 files changed, 107 insertions, 90 deletions

diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 40028fc01..21b13977b 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -2,12 +2,16 @@ use std::iter;
 
 use either::Either;
 use hir::{AsName, Module, ModuleDef, Name, Variant};
-use ide_db::helpers::{
-    insert_use::{insert_use, ImportScope},
-    mod_path_to_ast,
+use ide_db::{
+    defs::Definition,
+    helpers::{
+        insert_use::{insert_use, ImportScope},
+        mod_path_to_ast,
+    },
+    search::{FileReference, FileReferences},
+    RootDatabase,
 };
-use ide_db::{defs::Definition, search::Reference, RootDatabase};
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashSet;
 use syntax::{
     algo::{find_node_at_offset, SyntaxRewriter},
     ast::{self, edit::IndentLevel, make, AstNode, NameOwner, VisibilityOwner},
@@ -58,29 +62,29 @@ pub(crate) fn extract_struct_from_enum_variant(
             let mut visited_modules_set = FxHashSet::default();
             let current_module = enum_hir.module(ctx.db());
             visited_modules_set.insert(current_module);
-            let mut rewriters = FxHashMap::default();
-            for reference in usages {
-                let rewriter = rewriters
-                    .entry(reference.file_range.file_id)
-                    .or_insert_with(SyntaxRewriter::default);
-                let source_file = ctx.sema.parse(reference.file_range.file_id);
-                update_reference(
-                    ctx,
-                    rewriter,
-                    reference,
-                    &source_file,
-                    &enum_module_def,
-                    &variant_hir_name,
-                    &mut visited_modules_set,
-                );
-            }
-            let mut rewriter =
-                rewriters.remove(&ctx.frange.file_id).unwrap_or_else(SyntaxRewriter::default);
-            for (file_id, rewriter) in rewriters {
+            let mut def_rewriter = None;
+            for FileReferences { file_id, references: refs } in usages {
+                let mut rewriter = SyntaxRewriter::default();
+                let source_file = ctx.sema.parse(file_id);
+                for reference in refs {
+                    update_reference(
+                        ctx,
+                        &mut rewriter,
+                        reference,
+                        &source_file,
+                        &enum_module_def,
+                        &variant_hir_name,
+                        &mut visited_modules_set,
+                    );
+                }
+                if file_id == ctx.frange.file_id {
+                    def_rewriter = Some(rewriter);
+                    continue;
+                }
                 builder.edit_file(file_id);
                 builder.rewrite(rewriter);
             }
-            builder.edit_file(ctx.frange.file_id);
+            let mut rewriter = def_rewriter.unwrap_or_default();
             update_variant(&mut rewriter, &variant);
             extract_struct_def(
                 &mut rewriter,
@@ -90,6 +94,7 @@ pub(crate) fn extract_struct_from_enum_variant(
                 &variant.parent_enum().syntax().clone().into(),
                 enum_ast.visibility(),
             );
+            builder.edit_file(ctx.frange.file_id);
             builder.rewrite(rewriter);
         },
     )
@@ -205,13 +210,13 @@ fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Opti
 fn update_reference(
     ctx: &AssistContext,
     rewriter: &mut SyntaxRewriter,
-    reference: Reference,
+    reference: FileReference,
     source_file: &SourceFile,
     enum_module_def: &ModuleDef,
     variant_hir_name: &Name,
     visited_modules_set: &mut FxHashSet<Module>,
 ) -> Option<()> {
-    let offset = reference.file_range.range.start();
+    let offset = reference.range.start();
     let (segment, expr) = if let Some(path_expr) =
         find_node_at_offset::<ast::PathExpr>(source_file.syntax(), offset)
     {
diff --git a/crates/assists/src/handlers/inline_local_variable.rs b/crates/assists/src/handlers/inline_local_variable.rs
index d559be9cb..928df6825 100644
--- a/crates/assists/src/handlers/inline_local_variable.rs
+++ b/crates/assists/src/handlers/inline_local_variable.rs
@@ -1,4 +1,7 @@
-use ide_db::{defs::Definition, search::ReferenceKind};
+use ide_db::{
+    defs::Definition,
+    search::{FileReference, ReferenceKind},
+};
 use syntax::{
     ast::{self, AstNode, AstToken},
     TextRange,
@@ -63,48 +66,44 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
         let_stmt.syntax().text_range()
     };
 
-    let mut wrap_in_parens = vec![true; refs.len()];
-
-    for (i, desc) in refs.iter().enumerate() {
-        let usage_node = ctx
-            .covering_node_for_range(desc.file_range.range)
-            .ancestors()
-            .find_map(ast::PathExpr::cast)?;
-        let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
-        let usage_parent = match usage_parent_option {
-            Some(u) => u,
-            None => {
-                wrap_in_parens[i] = false;
-                continue;
-            }
-        };
-
-        wrap_in_parens[i] = match (&initializer_expr, usage_parent) {
-            (ast::Expr::CallExpr(_), _)
-            | (ast::Expr::IndexExpr(_), _)
-            | (ast::Expr::MethodCallExpr(_), _)
-            | (ast::Expr::FieldExpr(_), _)
-            | (ast::Expr::TryExpr(_), _)
-            | (ast::Expr::RefExpr(_), _)
-            | (ast::Expr::Literal(_), _)
-            | (ast::Expr::TupleExpr(_), _)
-            | (ast::Expr::ArrayExpr(_), _)
-            | (ast::Expr::ParenExpr(_), _)
-            | (ast::Expr::PathExpr(_), _)
-            | (ast::Expr::BlockExpr(_), _)
-            | (ast::Expr::EffectExpr(_), _)
-            | (_, ast::Expr::CallExpr(_))
-            | (_, ast::Expr::TupleExpr(_))
-            | (_, ast::Expr::ArrayExpr(_))
-            | (_, ast::Expr::ParenExpr(_))
-            | (_, ast::Expr::ForExpr(_))
-            | (_, ast::Expr::WhileExpr(_))
-            | (_, ast::Expr::BreakExpr(_))
-            | (_, ast::Expr::ReturnExpr(_))
-            | (_, ast::Expr::MatchExpr(_)) => false,
-            _ => true,
-        };
-    }
+    let wrap_in_parens = refs
+        .iter()
+        .flat_map(|refs| &refs.references)
+        .map(|&FileReference { range, .. }| {
+            let usage_node =
+                ctx.covering_node_for_range(range).ancestors().find_map(ast::PathExpr::cast)?;
+            let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
+            let usage_parent = match usage_parent_option {
+                Some(u) => u,
+                None => return Ok(false),
+            };
+
+            Ok(!matches!((&initializer_expr, usage_parent),
+                (ast::Expr::CallExpr(_), _)
+                | (ast::Expr::IndexExpr(_), _)
+                | (ast::Expr::MethodCallExpr(_), _)
+                | (ast::Expr::FieldExpr(_), _)
+                | (ast::Expr::TryExpr(_), _)
+                | (ast::Expr::RefExpr(_), _)
+                | (ast::Expr::Literal(_), _)
+                | (ast::Expr::TupleExpr(_), _)
+                | (ast::Expr::ArrayExpr(_), _)
+                | (ast::Expr::ParenExpr(_), _)
+                | (ast::Expr::PathExpr(_), _)
+                | (ast::Expr::BlockExpr(_), _)
+                | (ast::Expr::EffectExpr(_), _)
+                | (_, ast::Expr::CallExpr(_))
+                | (_, ast::Expr::TupleExpr(_))
+                | (_, ast::Expr::ArrayExpr(_))
+                | (_, ast::Expr::ParenExpr(_))
+                | (_, ast::Expr::ForExpr(_))
+                | (_, ast::Expr::WhileExpr(_))
+                | (_, ast::Expr::BreakExpr(_))
+                | (_, ast::Expr::ReturnExpr(_))
+                | (_, ast::Expr::MatchExpr(_))
+            ))
+        })
+        .collect::<Result<Vec<_>, _>>()?;
 
     let init_str = initializer_expr.syntax().text().to_string();
     let init_in_paren = format!("({})", &init_str);
@@ -116,15 +115,17 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
         target,
         move |builder| {
             builder.delete(delete_range);
-            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
+            for (reference, should_wrap) in
+                refs.iter().flat_map(|refs| &refs.references).zip(wrap_in_parens)
+            {
                 let replacement =
                     if should_wrap { init_in_paren.clone() } else { init_str.clone() };
-                match desc.kind {
+                match reference.kind {
                     ReferenceKind::FieldShorthandForLocal => {
                         mark::hit!(inline_field_shorthand);
-                        builder.insert(desc.file_range.range.end(), format!(": {}", replacement))
+                        builder.insert(reference.range.end(), format!(": {}", replacement))
                     }
-                    _ => builder.replace(desc.file_range.range, replacement),
+                    _ => builder.replace(reference.range, replacement),
                 }
             }
         },
diff --git a/crates/assists/src/handlers/remove_unused_param.rs b/crates/assists/src/handlers/remove_unused_param.rs
index 56e8b5229..4f3b8ac46 100644
--- a/crates/assists/src/handlers/remove_unused_param.rs
+++ b/crates/assists/src/handlers/remove_unused_param.rs
@@ -1,8 +1,11 @@
-use ide_db::{defs::Definition, search::Reference};
+use ide_db::{
+    defs::Definition,
+    search::{FileReference, FileReferences},
+};
 use syntax::{
     algo::find_node_at_range,
     ast::{self, ArgListOwner},
-    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
+    AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use test_utils::mark;
 use SyntaxKind::WHITESPACE;
@@ -58,32 +61,40 @@ pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Opt
         param.syntax().text_range(),
         |builder| {
             builder.delete(range_to_remove(param.syntax()));
-            for usage in fn_def.usages(&ctx.sema).all() {
-                process_usage(ctx, builder, usage, param_position);
+            for usages in fn_def.usages(&ctx.sema).all() {
+                process_usages(ctx, builder, usages, param_position);
             }
         },
     )
 }
 
-fn process_usage(
+fn process_usages(
     ctx: &AssistContext,
     builder: &mut AssistBuilder,
-    usage: Reference,
+    usages: FileReferences,
+    arg_to_remove: usize,
+) {
+    let source_file = ctx.sema.parse(usages.file_id);
+    builder.edit_file(usages.file_id);
+    for usage in usages.references {
+        if let Some(text_range) = process_usage(&source_file, usage, arg_to_remove) {
+            builder.delete(text_range);
+        }
+    }
+}
+
+fn process_usage(
+    source_file: &SourceFile,
+    FileReference { range, .. }: FileReference,
     arg_to_remove: usize,
-) -> Option<()> {
-    let source_file = ctx.sema.parse(usage.file_range.file_id);
-    let call_expr: ast::CallExpr =
-        find_node_at_range(source_file.syntax(), usage.file_range.range)?;
+) -> Option<TextRange> {
+    let call_expr: ast::CallExpr = find_node_at_range(source_file.syntax(), range)?;
     let call_expr_range = call_expr.expr()?.syntax().text_range();
-    if !call_expr_range.contains_range(usage.file_range.range) {
+    if !call_expr_range.contains_range(range) {
         return None;
     }
     let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
-
-    builder.edit_file(usage.file_range.file_id);
-    builder.delete(range_to_remove(arg.syntax()));
-
-    Some(())
+    Some(range_to_remove(arg.syntax()))
 }
 
 fn range_to_remove(node: &SyntaxNode) -> TextRange {