62 files changed, 260 insertions, 462 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();
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 14834480a..2e0d191a6 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -152,6 +152,7 @@ mod handlers {
     mod raw_string;
     mod remove_dbg;
     mod remove_mut;
+    mod remove_unused_param;
     mod reorder_fields;
     mod replace_if_let_with_match;
     mod replace_let_with_if_let;
@@ -198,6 +199,7 @@ mod handlers {
             raw_string::remove_hash,
             remove_dbg::remove_dbg,
             remove_mut::remove_mut,
+            remove_unused_param::remove_unused_param,
             reorder_fields::reorder_fields,
             replace_if_let_with_match::replace_if_let_with_match,
             replace_let_with_if_let::replace_let_with_if_let,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 173567003..04c8fd1f9 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -751,6 +751,27 @@ impl Walrus {
 }
 
 #[test]
+fn doctest_remove_unused_param() {
+    check_doc_test(
+        "remove_unused_param",
+        r#####"
+fn frobnicate(x: i32<|>) {}
+
+fn main() {
+    frobnicate(92);
+}
+"#####,
+        r#####"
+fn frobnicate() {}
+
+fn main() {
+    frobnicate();
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_reorder_fields() {
     check_doc_test(
         "reorder_fields",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 84ccacafe..d071d6502 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -9,7 +9,7 @@ use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use syntax::{
     ast::{self, make, NameOwner},
-    AstNode,
+    AstNode, Direction,
     SyntaxKind::*,
     SyntaxNode, TextSize, T,
 };
@@ -311,3 +311,7 @@ pub use prelude::*;
         Some(def)
     }
 }
+
+pub(crate) fn next_prev() -> impl Iterator<Item = Direction> {
+    [Direction::Next, Direction::Prev].iter().copied()
+}
diff --git a/crates/expect/Cargo.toml b/crates/expect/Cargo.toml
deleted file mode 100644
index b54d3a60e..000000000
--- a/crates/expect/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "expect"
-version = "0.0.0"
-license = "MIT OR Apache-2.0"
-authors = ["rust-analyzer developers"]
-edition = "2018"
-
-[lib]
-doctest = false
-
-[dependencies]
-once_cell = "1"
-difference = "2"
-
-stdx = { path = "../stdx" }
diff --git a/crates/expect/src/lib.rs b/crates/expect/src/lib.rs
deleted file mode 100644
index bd83895f7..000000000
--- a/crates/expect/src/lib.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-//! Snapshot testing library, see
-//! https://github.com/rust-analyzer/rust-analyzer/pull/5101
-use std::{
-    collections::HashMap,
-    env, fmt, fs, mem,
-    ops::Range,
-    panic,
-    path::{Path, PathBuf},
-    sync::Mutex,
-};
-
-use difference::Changeset;
-use once_cell::sync::Lazy;
-use stdx::{lines_with_ends, trim_indent};
-
-const HELP: &str = "
-You can update all `expect![[]]` tests by running:
-
-    env UPDATE_EXPECT=1 cargo test
-
-To update a single test, place the cursor on `expect` token and use `run` feature of rust-analyzer.
-";
-
-fn update_expect() -> bool {
-    env::var("UPDATE_EXPECT").is_ok()
-}
-
-/// expect![[r#"inline snapshot"#]]
-#[macro_export]
-macro_rules! expect {
-    [[$data:literal]] => {$crate::Expect {
-        position: $crate::Position {
-            file: file!(),
-            line: line!(),
-            column: column!(),
-        },
-        data: $data,
-    }};
-    [[]] => { $crate::expect![[""]] };
-}
-
-/// expect_file!["/crates/foo/test_data/bar.html"]
-#[macro_export]
-macro_rules! expect_file {
-    [$path:expr] => {$crate::ExpectFile {
-        path: std::path::PathBuf::from($path)
-    }};
-}
-
-#[derive(Debug)]
-pub struct Expect {
-    pub position: Position,
-    pub data: &'static str,
-}
-
-#[derive(Debug)]
-pub struct ExpectFile {
-    pub path: PathBuf,
-}
-
-#[derive(Debug)]
-pub struct Position {
-    pub file: &'static str,
-    pub line: u32,
-    pub column: u32,
-}
-
-impl fmt::Display for Position {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}:{}:{}", self.file, self.line, self.column)
-    }
-}
-
-impl Expect {
-    pub fn assert_eq(&self, actual: &str) {
-        let trimmed = self.trimmed();
-        if trimmed == actual {
-            return;
-        }
-        Runtime::fail_expect(self, &trimmed, actual);
-    }
-    pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) {
-        let actual = format!("{:#?}\n", actual);
-        self.assert_eq(&actual)
-    }
-
-    fn trimmed(&self) -> String {
-        if !self.data.contains('\n') {
-            return self.data.to_string();
-        }
-        trim_indent(self.data)
-    }
-
-    fn locate(&self, file: &str) -> Location {
-        let mut target_line = None;
-        let mut line_start = 0;
-        for (i, line) in lines_with_ends(file).enumerate() {
-            if i == self.position.line as usize - 1 {
-                let pat = "expect![[";
-                let offset = line.find(pat).unwrap();
-                let literal_start = line_start + offset + pat.len();
-                let indent = line.chars().take_while(|&it| it == ' ').count();
-                target_line = Some((literal_start, indent));
-                break;
-            }
-            line_start += line.len();
-        }
-        let (literal_start, line_indent) = target_line.unwrap();
-        let literal_length =
-            file[literal_start..].find("]]").expect("Couldn't find matching `]]` for `expect![[`.");
-        let literal_range = literal_start..literal_start + literal_length;
-        Location { line_indent, literal_range }
-    }
-}
-
-impl ExpectFile {
-    pub fn assert_eq(&self, actual: &str) {
-        let expected = self.read();
-        if actual == expected {
-            return;
-        }
-        Runtime::fail_file(self, &expected, actual);
-    }
-    pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) {
-        let actual = format!("{:#?}\n", actual);
-        self.assert_eq(&actual)
-    }
-    fn read(&self) -> String {
-        fs::read_to_string(self.abs_path()).unwrap_or_default().replace("\r\n", "\n")
-    }
-    fn write(&self, contents: &str) {
-        fs::write(self.abs_path(), contents).unwrap()
-    }
-    fn abs_path(&self) -> PathBuf {
-        WORKSPACE_ROOT.join(&self.path)
-    }
-}
-
-#[derive(Default)]
-struct Runtime {
-    help_printed: bool,
-    per_file: HashMap<&'static str, FileRuntime>,
-}
-static RT: Lazy<Mutex<Runtime>> = Lazy::new(Default::default);
-
-impl Runtime {
-    fn fail_expect(expect: &Expect, expected: &str, actual: &str) {
-        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
-        if update_expect() {
-            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.position);
-            rt.per_file
-                .entry(expect.position.file)
-                .or_insert_with(|| FileRuntime::new(expect))
-                .update(expect, actual);
-            return;
-        }
-        rt.panic(expect.position.to_string(), expected, actual);
-    }
-
-    fn fail_file(expect: &ExpectFile, expected: &str, actual: &str) {
-        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
-        if update_expect() {
-            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.path.display());
-            expect.write(actual);
-            return;
-        }
-        rt.panic(expect.path.display().to_string(), expected, actual);
-    }
-
-    fn panic(&mut self, position: String, expected: &str, actual: &str) {
-        let print_help = !mem::replace(&mut self.help_printed, true);
-        let help = if print_help { HELP } else { "" };
-
-        let diff = Changeset::new(actual, expected, "\n");
-
-        println!(
-            "\n
-\x1b[1m\x1b[91merror\x1b[97m: expect test failed\x1b[0m
-   \x1b[1m\x1b[34m-->\x1b[0m {}
-{}
-\x1b[1mExpect\x1b[0m:
-----
-{}
-----
-
-\x1b[1mActual\x1b[0m:
-----
-{}
-----
-
-\x1b[1mDiff\x1b[0m:
-----
-{}
-----
-",
-            position, help, expected, actual, diff
-        );
-        // Use resume_unwind instead of panic!() to prevent a backtrace, which is unnecessary noise.
-        panic::resume_unwind(Box::new(()));
-    }
-}
-
-struct FileRuntime {
-    path: PathBuf,
-    original_text: String,
-    patchwork: Patchwork,
-}
-
-impl FileRuntime {
-    fn new(expect: &Expect) -> FileRuntime {
-        let path = WORKSPACE_ROOT.join(expect.position.file);
-        let original_text = fs::read_to_string(&path).unwrap();
-        let patchwork = Patchwork::new(original_text.clone());
-        FileRuntime { path, original_text, patchwork }
-    }
-    fn update(&mut self, expect: &Expect, actual: &str) {
-        let loc = expect.locate(&self.original_text);
-        let patch = format_patch(loc.line_indent.clone(), actual);
-        self.patchwork.patch(loc.literal_range, &patch);
-        fs::write(&self.path, &self.patchwork.text).unwrap()
-    }
-}
-
-#[derive(Debug)]
-struct Location {
-    line_indent: usize,
-    literal_range: Range<usize>,
-}
-
-#[derive(Debug)]
-struct Patchwork {
-    text: String,
-    indels: Vec<(Range<usize>, usize)>,
-}
-
-impl Patchwork {
-    fn new(text: String) -> Patchwork {
-        Patchwork { text, indels: Vec::new() }
-    }
-    fn patch(&mut self, mut range: Range<usize>, patch: &str) {
-        self.indels.push((range.clone(), patch.len()));
-        self.indels.sort_by_key(|(delete, _insert)| delete.start);
-
-        let (delete, insert) = self
-            .indels
-            .iter()
-            .take_while(|(delete, _)| delete.start < range.start)
-            .map(|(delete, insert)| (delete.end - delete.start, insert))
-            .fold((0usize, 0usize), |(x1, y1), (x2, y2)| (x1 + x2, y1 + y2));
-
-        for pos in &mut [&mut range.start, &mut range.end] {
-            **pos -= delete;
-            **pos += insert;
-        }
-
-        self.text.replace_range(range, &patch);
-    }
-}
-
-fn format_patch(line_indent: usize, patch: &str) -> String {
-    let mut max_hashes = 0;
-    let mut cur_hashes = 0;
-    for byte in patch.bytes() {
-        if byte != b'#' {
-            cur_hashes = 0;
-            continue;
-        }
-        cur_hashes += 1;
-        max_hashes = max_hashes.max(cur_hashes);
-    }
-    let hashes = &"#".repeat(max_hashes + 1);
-    let indent = &" ".repeat(line_indent);
-    let is_multiline = patch.contains('\n');
-
-    let mut buf = String::new();
-    buf.push('r');
-    buf.push_str(hashes);
-    buf.push('"');
-    if is_multiline {
-        buf.push('\n');
-    }
-    let mut final_newline = false;
-    for line in lines_with_ends(patch) {
-        if is_multiline && !line.trim().is_empty() {
-            buf.push_str(indent);
-            buf.push_str("    ");
-        }
-        buf.push_str(line);
-        final_newline = line.ends_with('\n');
-    }
-    if final_newline {
-        buf.push_str(indent);
-    }
-    buf.push('"');
-    buf.push_str(hashes);
-    buf
-}
-
-static WORKSPACE_ROOT: Lazy<PathBuf> = Lazy::new(|| {
-    let my_manifest =
-        env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned());
-    // Heuristic, see https://github.com/rust-lang/cargo/issues/3946
-    Path::new(&my_manifest)
-        .ancestors()
-        .filter(|it| it.join("Cargo.toml").exists())
-        .last()
-        .unwrap()
-        .to_path_buf()
-});
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_format_patch() {
-        let patch = format_patch(0, "hello\nworld\n");
-        expect![[r##"
-            r#"
-                hello
-                world
-            "#"##]]
-        .assert_eq(&patch);
-
-        let patch = format_patch(4, "single line");
-        expect![[r##"r#"single line"#"##]].assert_eq(&patch);
-    }
-
-    #[test]
-    fn test_patchwork() {
-        let mut patchwork = Patchwork::new("one two three".to_string());
-        patchwork.patch(4..7, "zwei");
-        patchwork.patch(0..3, "один");
-        patchwork.patch(8..13, "3");
-        expect![[r#"
-            Patchwork {
-                text: "один zwei 3",
-                indels: [
-                    (
-                        0..3,
-                        8,
-                    ),
-                    (
-                        4..7,
-                        4,
-                    ),
-                    (
-                        8..13,
-                        1,
-                    ),
-                ],
-            }
-        "#]]
-        .assert_debug_eq(&patchwork);
-    }
-}
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 8c5f2ff98..1594d4f0f 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -573,7 +573,7 @@ impl<'db> SemanticsImpl<'db> {
 
     fn is_unsafe_method_call(&self, method_call_expr: &ast::MethodCallExpr) -> bool {
         method_call_expr
-            .expr()
+            .receiver()
             .and_then(|expr| {
                 let field_expr = match expr {
                     ast::Expr::FieldExpr(field_expr) => field_expr,
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 403bc2aff..57745322f 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -32,4 +32,4 @@ cfg = { path = "../cfg" }
 tt = { path = "../tt" }
 
 [dev-dependencies]
-expect = { path = "../expect" }
+expect-test = "0.1"
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index a26251cde..30ac12a12 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -329,7 +329,7 @@ impl ExprCollector<'_> {
                 self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
             }
             ast::Expr::MethodCallExpr(e) => {
-                let receiver = self.collect_expr_opt(e.expr());
+                let receiver = self.collect_expr_opt(e.receiver());
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().map(|e| self.collect_expr(e)).collect()
                 } else {
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index d32a0bdaf..a442fb63a 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -328,7 +328,7 @@ pub fn search_dependencies<'a>(
 #[cfg(test)]
 mod tests {
     use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::{test_db::TestDB, AssocContainerId, Lookup};
 
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index 9c5bf72bd..620e697d4 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -1,5 +1,5 @@
 use base_db::fixture::WithFixture;
-use expect::{expect, Expect};
+use expect_test::{expect, Expect};
 use hir_expand::{db::AstDatabase, HirFileId, InFile};
 use rustc_hash::FxHashSet;
 use std::sync::Arc;
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index b105d56b2..8aaf7a158 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -7,7 +7,7 @@ mod primitives;
 use std::sync::Arc;
 
 use base_db::{fixture::WithFixture, SourceDatabase};
-use expect::{expect, Expect};
+use expect_test::{expect, Expect};
 use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index a319b0ce8..06da0d0ec 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -30,8 +30,7 @@ syntax = { path = "../syntax" }
 test_utils = { path = "../test_utils" }
 
 [dev-dependencies]
+expect-test = "0.1"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
 tracing-tree = { version = "0.1.4" }
-
-expect = { path = "../expect" }
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index 91c9d38c5..0445efc9e 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -11,7 +11,7 @@ mod display_source_code;
 use std::{env, sync::Arc};
 
 use base_db::{fixture::WithFixture, FileRange, SourceDatabase, SourceDatabaseExt};
-use expect::Expect;
+use expect_test::Expect;
 use hir_def::{
     body::{BodySourceMap, SyntheticSyntax},
     child_by_source::ChildBySource,
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index 17efd75cb..7bc6c79f3 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches};
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index d887c7a79..597a195d0 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -1,6 +1,6 @@
 use std::fs;
 
-use expect::expect;
+use expect_test::expect;
 use test_utils::project_dir;
 
 use super::{check_infer, check_types};
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index fa68355aa..23b2601e6 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 
 use super::{check_infer, check_types};
 
diff --git a/crates/hir_ty/src/tests/never_type.rs b/crates/hir_ty/src/tests/never_type.rs
index 49538b572..335c474df 100644
--- a/crates/hir_ty/src/tests/never_type.rs
+++ b/crates/hir_ty/src/tests/never_type.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 
 use super::{check_infer_with_mismatches, check_types};
 
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 39fabf7eb..aeb191c79 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches};
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index b9ab0f357..94d86b0d1 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 use test_utils::mark;
 
 use super::{check_infer, check_types};
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 59eb59d5f..48db23a34 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 
 use super::{check_infer, check_types};
 
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 526e61caf..1f1056962 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -1,4 +1,4 @@
-use expect::expect;
+use expect_test::expect;
 use test_utils::mark;
 
 use super::{check_infer, check_infer_with_mismatches, check_types};
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index e4b970c73..700944430 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -32,4 +32,4 @@ ssr = { path = "../ssr" }
 hir = { path = "../hir" }
 
 [dev-dependencies]
-expect = { path = "../expect" }
+expect-test = "0.1"
diff --git a/crates/ide/src/call_info.rs b/crates/ide/src/call_info.rs
index 86abd2d8c..7e83a2381 100644
--- a/crates/ide/src/call_info.rs
+++ b/crates/ide/src/call_info.rs
@@ -229,7 +229,7 @@ impl FnCallNode {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::mock_analysis::analysis_and_position;
diff --git a/crates/ide/src/completion/complete_attribute.rs b/crates/ide/src/completion/complete_attribute.rs
index 042c3ecef..0abfaebcb 100644
--- a/crates/ide/src/completion/complete_attribute.rs
+++ b/crates/ide/src/completion/complete_attribute.rs
@@ -383,7 +383,7 @@ const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_dot.rs b/crates/ide/src/completion/complete_dot.rs
index 5488db43f..0b9f1798a 100644
--- a/crates/ide/src/completion/complete_dot.rs
+++ b/crates/ide/src/completion/complete_dot.rs
@@ -61,7 +61,7 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
diff --git a/crates/ide/src/completion/complete_fn_param.rs b/crates/ide/src/completion/complete_fn_param.rs
index 7c63ce58f..9efe25461 100644
--- a/crates/ide/src/completion/complete_fn_param.rs
+++ b/crates/ide/src/completion/complete_fn_param.rs
@@ -66,7 +66,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_keyword.rs b/crates/ide/src/completion/complete_keyword.rs
index 22ada3cf2..95e4ff1ac 100644
--- a/crates/ide/src/completion/complete_keyword.rs
+++ b/crates/ide/src/completion/complete_keyword.rs
@@ -174,7 +174,7 @@ fn complete_return(
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{
         test_utils::{check_edit, completion_list},
diff --git a/crates/ide/src/completion/complete_macro_in_item_position.rs b/crates/ide/src/completion/complete_macro_in_item_position.rs
index 0447f0511..fc8625d8e 100644
--- a/crates/ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ide/src/completion/complete_macro_in_item_position.rs
@@ -15,7 +15,7 @@ pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_pattern.rs b/crates/ide/src/completion/complete_pattern.rs
index aceb77cb5..5a13574d4 100644
--- a/crates/ide/src/completion/complete_pattern.rs
+++ b/crates/ide/src/completion/complete_pattern.rs
@@ -33,7 +33,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_postfix.rs b/crates/ide/src/completion/complete_postfix.rs
index d50b13c52..84c4e129d 100644
--- a/crates/ide/src/completion/complete_postfix.rs
+++ b/crates/ide/src/completion/complete_postfix.rs
@@ -238,7 +238,7 @@ fn postfix_snippet(
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{
         test_utils::{check_edit, completion_list},
diff --git a/crates/ide/src/completion/complete_qualified_path.rs b/crates/ide/src/completion/complete_qualified_path.rs
index 74794dc88..accb09f7e 100644
--- a/crates/ide/src/completion/complete_qualified_path.rs
+++ b/crates/ide/src/completion/complete_qualified_path.rs
@@ -146,7 +146,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::completion::{
diff --git a/crates/ide/src/completion/complete_record.rs b/crates/ide/src/completion/complete_record.rs
index 74b94594d..ceb8d16c1 100644
--- a/crates/ide/src/completion/complete_record.rs
+++ b/crates/ide/src/completion/complete_record.rs
@@ -18,7 +18,7 @@ pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_snippet.rs b/crates/ide/src/completion/complete_snippet.rs
index 4368e4eec..c3b03b199 100644
--- a/crates/ide/src/completion/complete_snippet.rs
+++ b/crates/ide/src/completion/complete_snippet.rs
@@ -70,7 +70,7 @@ fn ${1:feature}() {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{test_utils::completion_list, CompletionKind};
 
diff --git a/crates/ide/src/completion/complete_trait_impl.rs b/crates/ide/src/completion/complete_trait_impl.rs
index d0d3a9f34..1a2b1e8a5 100644
--- a/crates/ide/src/completion/complete_trait_impl.rs
+++ b/crates/ide/src/completion/complete_trait_impl.rs
@@ -225,7 +225,7 @@ fn make_const_compl_syntax(const_: &ast::Const) -> String {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::completion::{
         test_utils::{check_edit, completion_list},
diff --git a/crates/ide/src/completion/complete_unqualified_path.rs b/crates/ide/src/completion/complete_unqualified_path.rs
index 824227f31..1f1b682a7 100644
--- a/crates/ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ide/src/completion/complete_unqualified_path.rs
@@ -64,7 +64,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::completion::{
diff --git a/crates/ide/src/completion/completion_context.rs b/crates/ide/src/completion/completion_context.rs
index 85456a66f..5adac7ebc 100644
--- a/crates/ide/src/completion/completion_context.rs
+++ b/crates/ide/src/completion/completion_context.rs
@@ -457,7 +457,7 @@ impl<'a> CompletionContext<'a> {
         if let Some(method_call_expr) = ast::MethodCallExpr::cast(parent) {
             // As above
             self.dot_receiver = method_call_expr
-                .expr()
+                .receiver()
                 .map(|e| e.syntax().text_range())
                 .and_then(|r| find_node_with_range(original_file, r));
             self.is_call = true;
diff --git a/crates/ide/src/completion/presentation.rs b/crates/ide/src/completion/presentation.rs
index a73f8ab0b..3371aed2d 100644
--- a/crates/ide/src/completion/presentation.rs
+++ b/crates/ide/src/completion/presentation.rs
@@ -464,7 +464,7 @@ fn guess_macro_braces(macro_name: &str, docs: &str) -> (&'static str, &'static s
 mod tests {
     use std::cmp::Reverse;
 
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::mark;
 
     use crate::{
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 92b5adaa2..b2b972b02 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -214,7 +214,7 @@ fn check_struct_shorthand_initialization(
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use stdx::trim_indent;
     use test_utils::assert_eq_text;
 
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index e77106177..1ee80c2dd 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -421,7 +421,7 @@ pub(crate) fn description_from_symbol(db: &RootDatabase, symbol: &FileSymbol) ->
 
 #[cfg(test)]
 mod tests {
-    use expect::expect;
+    use expect_test::expect;
 
     use crate::{mock_analysis::single_file, Query};
 
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 31455709d..8a285bcf7 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -120,7 +120,7 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index c90247ba6..6168fb837 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -164,7 +164,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use super::*;
 
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 300c00edc..c75b2a510 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -353,7 +353,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 #[cfg(test)]
 mod tests {
     use base_db::FileLoader;
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 596bc872d..583f39d85 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -336,7 +336,7 @@ fn get_callable(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<Call
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use test_utils::extract_annotations;
 
     use crate::{inlay_hints::InlayHintsConfig, mock_analysis::single_file};
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index d73dc9cd0..301629763 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -270,7 +270,7 @@ fn rename_reference(
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
     use stdx::trim_indent;
     use test_utils::{assert_eq_text, mark};
     use text_edit::TextEdit;
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index c3e07c8de..4139f329e 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -268,7 +268,7 @@ fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use expect::{expect, Expect};
+    use expect_test::{expect, Expect};
 
     use crate::mock_analysis::analysis_and_position;
 
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index be88b2f9c..25d6f7abd 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -724,7 +724,8 @@ fn highlight_method_call(
             hir::Access::Shared => (),
             hir::Access::Exclusive => h |= HighlightModifier::Mutable,
             hir::Access::Owned => {
-                if let Some(receiver_ty) = method_call.expr().and_then(|it| sema.type_of_expr(&it))
+                if let Some(receiver_ty) =
+                    method_call.receiver().and_then(|it| sema.type_of_expr(&it))
                 {
                     if !receiver_ty.is_copy(sema.db) {
                         h |= HighlightModifier::Consuming
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index ccb76f552..1c3fea058 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -1,6 +1,6 @@
 use std::fs;
 
-use expect::{expect_file, ExpectFile};
+use expect_test::{expect_file, ExpectFile};
 use test_utils::project_dir;
 
 use crate::{mock_analysis::single_file, FileRange, TextRange};
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index ce7631c69..edab1d644 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -203,11 +203,25 @@ impl<'a> FindUsages<'a> {
     }
 
     pub fn at_least_one(self) -> bool {
-        self.all().is_empty()
+        let mut found = false;
+        self.search(&mut |_reference| {
+            found = true;
+            true
+        });
+        found
     }
 
     pub fn all(self) -> Vec<Reference> {
-        let _p = profile::span("Definition::find_usages");
+        let mut res = Vec::new();
+        self.search(&mut |reference| {
+            res.push(reference);
+            false
+        });
+        res
+    }
+
+    fn search(self, sink: &mut dyn FnMut(Reference) -> bool) {
+        let _p = profile::span("FindUsages:search");
         let sema = self.sema;
 
         let search_scope = {
@@ -219,13 +233,11 @@ impl<'a> FindUsages<'a> {
         };
 
         let name = match self.def.name(sema.db) {
-            None => return Vec::new(),
             Some(it) => it.to_string(),
+            None => return,
         };
 
         let pat = name.as_str();
-        let mut refs = vec![];
-
         for (file_id, search_range) in search_scope {
             let text = sema.db.file_text(file_id);
             let search_range =
@@ -240,10 +252,9 @@ impl<'a> FindUsages<'a> {
                 }
 
                 let name_ref: ast::NameRef =
-                    if let Some(name_ref) = sema.find_node_at_offset_with_descend(&tree, offset) {
-                        name_ref
-                    } else {
-                        continue;
+                    match sema.find_node_at_offset_with_descend(&tree, offset) {
+                        Some(it) => it,
+                        None => continue,
                     };
 
                 match classify_name_ref(&sema, &name_ref) {
@@ -256,43 +267,45 @@ impl<'a> FindUsages<'a> {
                             ReferenceKind::Other
                         };
 
-                        let file_range = sema.original_range(name_ref.syntax());
-                        refs.push(Reference {
-                            file_range,
+                        let reference = Reference {
+                            file_range: sema.original_range(name_ref.syntax()),
                             kind,
                             access: reference_access(&def, &name_ref),
-                        });
+                        };
+                        if sink(reference) {
+                            return;
+                        }
                     }
                     Some(NameRefClass::FieldShorthand { local, field }) => {
-                        match self.def {
-                            Definition::Field(_) if &field == self.def => refs.push(Reference {
+                        let reference = match self.def {
+                            Definition::Field(_) if &field == self.def => Reference {
                                 file_range: self.sema.original_range(name_ref.syntax()),
                                 kind: ReferenceKind::FieldShorthandForField,
                                 access: reference_access(&field, &name_ref),
-                            }),
-                            Definition::Local(l) if &local == l => refs.push(Reference {
+                            },
+                            Definition::Local(l) if &local == l => Reference {
                                 file_range: self.sema.original_range(name_ref.syntax()),
                                 kind: ReferenceKind::FieldShorthandForLocal,
                                 access: reference_access(&Definition::Local(local), &name_ref),
-                            }),
-
-                            _ => {} // not a usage
+                            },
+                            _ => continue, // not a usage
                         };
+                        if sink(reference) {
+                            return;
+                        }
                     }
                     _ => {} // not a usage
                 }
             }
         }
-        refs
     }
 }
 
 fn reference_access(def: &Definition, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
     // Only Locals and Fields have accesses for now.
-    match def {
-        Definition::Local(_) | Definition::Field(_) => {}
-        _ => return None,
-    };
+    if !matches!(def, Definition::Local(_) | Definition::Field(_)) {
+        return None;
+    }
 
     let mode = name_ref.syntax().ancestors().find_map(|node| {
         match_ast! {
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index c7c1eda0f..068a961dc 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -57,7 +57,7 @@ proc_macro_srv = { path = "../proc_macro_srv" }
 winapi = "0.3.8"
 
 [dev-dependencies]
-expect = { path = "../expect" }
+expect-test = "0.1"
 test_utils = { path = "../test_utils" }
 mbe = { path = "../mbe" }
 tt = { path = "../tt" }
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index df5583897..e52b97913 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -256,7 +256,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
 mod tests {
     use super::*;
 
-    use expect::{expect_file, ExpectFile};
+    use expect_test::{expect_file, ExpectFile};
 
     fn check(diagnostics_json: &str, expect: ExpectFile) {
         check_with_config(DiagnosticsMapConfig::default(), diagnostics_json, expect)
diff --git a/crates/ssr/Cargo.toml b/crates/ssr/Cargo.toml
index 7c2090de3..22b6af0fa 100644
--- a/crates/ssr/Cargo.toml
+++ b/crates/ssr/Cargo.toml
@@ -22,4 +22,4 @@ hir = { path = "../hir" }
 test_utils = { path = "../test_utils" }
 
 [dev-dependencies]
-expect = { path = "../expect" }
+expect-test = "0.1"
diff --git a/crates/ssr/src/matching.rs b/crates/ssr/src/matching.rs
index 26968c474..948862a77 100644
--- a/crates/ssr/src/matching.rs
+++ b/crates/ssr/src/matching.rs
@@ -546,10 +546,12 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
         // information on the placeholder match about autoderef and autoref. This allows us to use
         // the placeholder in a context where autoderef and autoref don't apply.
         if code_resolved_function.self_param(self.sema.db).is_some() {
-            if let (Some(pattern_type), Some(expr)) = (&pattern_ufcs.qualifier_type, &code.expr()) {
+            if let (Some(pattern_type), Some(expr)) =
+                (&pattern_ufcs.qualifier_type, &code.receiver())
+            {
                 let deref_count = self.check_expr_type(pattern_type, expr)?;
                 let pattern_receiver = pattern_args.next();
-                self.attempt_match_opt(phase, pattern_receiver.clone(), code.expr())?;
+                self.attempt_match_opt(phase, pattern_receiver.clone(), code.receiver())?;
                 if let Phase::Second(match_out) = phase {
                     if let Some(placeholder_value) = pattern_receiver
                         .and_then(|n| self.get_placeholder_for_node(n.syntax()))
@@ -568,7 +570,7 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                 }
             }
         } else {
-            self.attempt_match_opt(phase, pattern_args.next(), code.expr())?;
+            self.attempt_match_opt(phase, pattern_args.next(), code.receiver())?;
         }
         let mut code_args =
             code.arg_list().ok_or_else(|| match_error!("Code method call has no args"))?.args();
diff --git a/crates/ssr/src/replacing.rs b/crates/ssr/src/replacing.rs
index 29284e3f1..7e7ce37bd 100644
--- a/crates/ssr/src/replacing.rs
+++ b/crates/ssr/src/replacing.rs
@@ -3,7 +3,7 @@
 use crate::{resolving::ResolvedRule, Match, SsrMatches};
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
-use syntax::ast::{self, AstToken};
+use syntax::ast::{self, AstNode, AstToken};
 use syntax::{SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize};
 use test_utils::mark;
 use text_edit::TextEdit;
@@ -93,7 +93,6 @@ impl ReplacementRenderer<'_> {
     }
 
     fn render_node(&mut self, node: &SyntaxNode) {
-        use syntax::ast::AstNode;
         if let Some(mod_path) = self.match_info.rendered_template_paths.get(&node) {
             self.out.push_str(&mod_path.to_string());
             // Emit everything except for the segment's name-ref, since we already effectively
@@ -206,11 +205,10 @@ impl ReplacementRenderer<'_> {
 /// method call doesn't count. e.g. if the token is `$a`, then `$a.foo()` will return true, while
 /// `($a + $b).foo()` or `x.foo($a)` will return false.
 fn token_is_method_call_receiver(token: &SyntaxToken) -> bool {
-    use syntax::ast::AstNode;
     // Find the first method call among the ancestors of `token`, then check if the only token
     // within the receiver is `token`.
     if let Some(receiver) =
-        token.ancestors().find_map(ast::MethodCallExpr::cast).and_then(|call| call.expr())
+        token.ancestors().find_map(ast::MethodCallExpr::cast).and_then(|call| call.receiver())
     {
         let tokens = receiver.syntax().descendants_with_tokens().filter_map(|node_or_token| {
             match node_or_token {
@@ -226,7 +224,6 @@ fn token_is_method_call_receiver(token: &SyntaxToken) -> bool {
 }
 
 fn parse_as_kind(code: &str, kind: SyntaxKind) -> Option<SyntaxNode> {
-    use syntax::ast::AstNode;
     if ast::Expr::can_cast(kind) {
         if let Ok(expr) = ast::Expr::parse(code) {
             return Some(expr.syntax().clone());
diff --git a/crates/ssr/src/tests.rs b/crates/ssr/src/tests.rs
index e45c88864..20231a9bc 100644
--- a/crates/ssr/src/tests.rs
+++ b/crates/ssr/src/tests.rs
@@ -1,6 +1,6 @@
 use crate::{MatchFinder, SsrRule};
 use base_db::{salsa::Durability, FileId, FilePosition, FileRange, SourceDatabaseExt};
-use expect::{expect, Expect};
+use expect_test::{expect, Expect};
 use rustc_hash::FxHashSet;
 use std::sync::Arc;
 use test_utils::{mark, RangeOrOffset};
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index ec3132da8..6818f3ad8 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -30,6 +30,6 @@ parser = { path = "../parser" }
 [dev-dependencies]
 walkdir = "2.3.1"
 rayon = "1"
+expect-test = "0.1"
 
 test_utils = { path = "../test_utils" }
-expect = { path = "../expect" }
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 3d49309d1..6317407c6 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -66,6 +66,7 @@ impl ParamList {
     pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
     pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RetType {
@@ -809,7 +810,7 @@ pub struct MethodCallExpr {
 impl ast::AttrsOwner for MethodCallExpr {}
 impl ast::ArgListOwner for MethodCallExpr {}
 impl MethodCallExpr {
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
diff --git a/crates/syntax/src/tests.rs b/crates/syntax/src/tests.rs
index ddc718369..8c217dfe0 100644
--- a/crates/syntax/src/tests.rs
+++ b/crates/syntax/src/tests.rs
@@ -4,7 +4,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use expect::expect_file;
+use expect_test::expect_file;
 use rayon::prelude::*;
 use test_utils::project_dir;