5 files changed, 136 insertions, 7 deletions

diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index b9ec3f10b..c4770f336 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -239,7 +239,7 @@ impl ImportCandidate {
             return None;
         }
         Some(Self::TraitMethod(
-            sema.type_of_expr(&method_call.expr()?)?,
+            sema.type_of_expr(&method_call.receiver()?)?,
             method_call.name_ref()?.syntax().to_string(),
         ))
     }
diff --git a/crates/assists/src/handlers/merge_imports.rs b/crates/assists/src/handlers/merge_imports.rs
index 47d465404..35b884206 100644
--- a/crates/assists/src/handlers/merge_imports.rs
+++ b/crates/assists/src/handlers/merge_imports.rs
@@ -8,6 +8,7 @@ use syntax::{
 
 use crate::{
     assist_context::{AssistContext, Assists},
+    utils::next_prev,
     AssistId, AssistKind,
 };
 
@@ -66,10 +67,6 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
     )
 }
 
-fn next_prev() -> impl Iterator<Item = Direction> {
-    [Direction::Next, Direction::Prev].iter().copied()
-}
-
 fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option<ast::UseTree> {
     let lhs_path = old.path()?;
     let rhs_path = new.path()?;
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index f3dcca534..4e252edf0 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -82,9 +82,10 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
+    use super::*;
+
     #[test]
     fn test_remove_dbg() {
         check_assist(remove_dbg, "<|>dbg!(1 + 1)", "1 + 1");
diff --git a/crates/assists/src/handlers/remove_unused_param.rs b/crates/assists/src/handlers/remove_unused_param.rs
new file mode 100644
index 000000000..5fccca54b
--- /dev/null
+++ b/crates/assists/src/handlers/remove_unused_param.rs
@@ -0,0 +1,131 @@
+use ide_db::{defs::Definition, search::Reference};
+use syntax::{
+    algo::find_node_at_range,
+    ast::{self, ArgListOwner},
+    AstNode, SyntaxNode, TextRange, T,
+};
+use test_utils::mark;
+
+use crate::{
+    assist_context::AssistBuilder, utils::next_prev, AssistContext, AssistId, AssistKind, Assists,
+};
+
+// Assist: remove_unused_param
+//
+// Removes unused function parameter.
+//
+// ```
+// fn frobnicate(x: i32<|>) {}
+//
+// fn main() {
+//     frobnicate(92);
+// }
+// ```
+// ->
+// ```
+// fn frobnicate() {}
+//
+// fn main() {
+//     frobnicate();
+// }
+// ```
+pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let param: ast::Param = ctx.find_node_at_offset()?;
+    let ident_pat = match param.pat()? {
+        ast::Pat::IdentPat(it) => it,
+        _ => return None,
+    };
+    let func = param.syntax().ancestors().find_map(ast::Fn::cast)?;
+    let param_position = func.param_list()?.params().position(|it| it == param)?;
+
+    let fn_def = {
+        let func = ctx.sema.to_def(&func)?;
+        Definition::ModuleDef(func.into())
+    };
+
+    let param_def = {
+        let local = ctx.sema.to_def(&ident_pat)?;
+        Definition::Local(local)
+    };
+    if param_def.usages(&ctx.sema).at_least_one() {
+        mark::hit!(keep_used);
+        return None;
+    }
+    acc.add(
+        AssistId("remove_unused_param", AssistKind::Refactor),
+        "Remove unused parameter",
+        param.syntax().text_range(),
+        |builder| {
+            builder.delete(range_with_coma(param.syntax()));
+            for usage in fn_def.usages(&ctx.sema).all() {
+                process_usage(ctx, builder, usage, param_position);
+            }
+        },
+    )
+}
+
+fn process_usage(
+    ctx: &AssistContext,
+    builder: &mut AssistBuilder,
+    usage: Reference,
+    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)?;
+    if call_expr.expr()?.syntax().text_range() != usage.file_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_with_coma(arg.syntax()));
+
+    Some(())
+}
+
+fn range_with_coma(node: &SyntaxNode) -> TextRange {
+    let up_to = next_prev().find_map(|dir| {
+        node.siblings_with_tokens(dir)
+            .filter_map(|it| it.into_token())
+            .find(|it| it.kind() == T![,])
+    });
+    let up_to = up_to.map_or(node.text_range(), |it| it.text_range());
+    node.text_range().cover(up_to)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn remove_unused() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn a() { foo(9, 2) }
+fn foo(x: i32, <|>y: i32) { x; }
+fn b() { foo(9, 2,) }
+"#,
+            r#"
+fn a() { foo(9) }
+fn foo(x: i32) { x; }
+fn b() { foo(9, ) }
+"#,
+        );
+    }
+
+    #[test]
+    fn keep_used() {
+        mark::check!(keep_used);
+        check_assist_not_applicable(
+            remove_unused_param,
+            r#"
+fn foo(x: i32, <|>y: i32) { y; }
+fn main() { foo(9, 2) }
+"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/replace_unwrap_with_match.rs b/crates/assists/src/handlers/replace_unwrap_with_match.rs
index 9705f11b7..4043c219c 100644
--- a/crates/assists/src/handlers/replace_unwrap_with_match.rs
+++ b/crates/assists/src/handlers/replace_unwrap_with_match.rs
@@ -42,7 +42,7 @@ pub(crate) fn replace_unwrap_with_match(acc: &mut Assists, ctx: &AssistContext)
     if name.text() != "unwrap" {
         return None;
     }
-    let caller = method_call.expr()?;
+    let caller = method_call.receiver()?;
     let ty = ctx.sema.type_of_expr(&caller)?;
     let happy_variant = TryEnum::from_ty(&ctx.sema, &ty)?.happy_case();
     let target = method_call.syntax().text_range();