58 files changed, 6104 insertions, 5836 deletions

diff --git a/.gitattributes b/.gitattributes
index e749e1dc9..4cd50e481 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1,6 @@
 * text=auto eol=lf
 crates/ra_syntax/test_data/** -text eof=LF
+# Older git versions try to fix line endings on images, this prevents it.
+*.png binary
+*.jpg binary
+*.ico binary
diff --git a/Cargo.lock b/Cargo.lock
index e0ba7b688..029698808 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -126,9 +126,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 
 [[package]]
 name = "chalk-derive"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9396f12a23b1a40d5019aa81bc0cbd7ccd2c9736d6bc4afc95868533c2346dcb"
+checksum = "eea3a22f0c30b2504ac4ab58934dac0d00b92a4d7788df32795cabca24c3f929"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -138,9 +138,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-ir"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87e9c67d500717d65ede27affb7ae40efe240d86fbefff1006fe0ffb62d4caf9"
+checksum = "fb617b643e145e3b151502799e91a9625dd5daf1cf05dc2cb821bc75ae0c9cbd"
 dependencies = [
  "chalk-derive",
  "lazy_static",
@@ -148,9 +148,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-recursive"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8fd2ac0fc06c857b95614d229bbe8ea317d1d94a7e8b9442a3f05c9a2c2d5f4"
+checksum = "d280565c8eefbf9b2bc615df49c7dfd971faad37774bf65734e626fd23864bd6"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -161,9 +161,9 @@ dependencies = [
 
 [[package]]
 name = "chalk-solve"
-version = "0.17.0"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a79166f2405c1e51eadcc1344f5ee833c7b391532dd78f64a0731a9a123cc58"
+checksum = "be906fbca3f3077dce0e76d9864771d0f450c946af0d86b569fb9504148a065a"
 dependencies = [
  "chalk-derive",
  "chalk-ir",
@@ -206,20 +206,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "console"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c0994e656bba7b922d8dd1245db90672ffb701e684e45be58f20719d69abc5a"
-dependencies = [
- "encode_unicode",
- "lazy_static",
- "libc",
- "terminal_size",
- "termios",
- "winapi 0.3.9",
-]
-
-[[package]]
 name = "crc32fast"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -230,12 +216,12 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cced8691919c02aac3cb0a1bc2e9b73d89e832bf9a06fc579d4e71b68a2da061"
+checksum = "09ee0cc8804d5393478d743b035099520087a5186f3b93fa58cec08fa62407b6"
 dependencies = [
+ "cfg-if",
  "crossbeam-utils",
- "maybe-uninit",
 ]
 
 [[package]]
@@ -299,12 +285,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69b26e475fd29098530e709294e94e661974c851aed42512793f120fed4e199f"
 
 [[package]]
-name = "dtoa"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"
-
-[[package]]
 name = "either"
 version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -320,12 +300,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "encode_unicode"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
-
-[[package]]
 name = "env_logger"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -386,12 +360,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "fs_extra"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f2a4a2034423744d2cc7ca2068453168dcdb82c438419e639a26bd87839c674"
-
-[[package]]
 name = "fsevent"
 version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -538,20 +506,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "insta"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "617e921abc813f96a3b00958c079e7bf1e2db998f8a04f1546dd967373a418ee"
-dependencies = [
- "console",
- "difference",
- "lazy_static",
- "serde",
- "serde_json",
- "serde_yaml",
-]
-
-[[package]]
 name = "instant"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -582,38 +536,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
 
 [[package]]
-name = "jemalloc-ctl"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c502a5ff9dd2924f1ed32ba96e3b65735d837b4bfd978d3161b1702e66aca4b7"
-dependencies = [
- "jemalloc-sys",
- "libc",
- "paste",
-]
-
-[[package]]
-name = "jemalloc-sys"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d3b9f3f5c9b31aa0f5ed3260385ac205db665baa41d49bb8338008ae94ede45"
-dependencies = [
- "cc",
- "fs_extra",
- "libc",
-]
-
-[[package]]
-name = "jemallocator"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43ae63fcfc45e99ab3d1b29a46782ad679e98436c3169d15a167a1108a724b69"
-dependencies = [
- "jemalloc-sys",
- "libc",
-]
-
-[[package]]
 name = "jod-thread"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -666,12 +588,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "linked-hash-map"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
-
-[[package]]
 name = "lock_api"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -703,9 +619,9 @@ dependencies = [
 
 [[package]]
 name = "lsp-types"
-version = "0.77.0"
+version = "0.78.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "897c6c8930fbf12b67deffc83729287bb379dd5e5a4bd0ae2d81eff8d6503db6"
+checksum = "d2e6cf68e3492cfa2035f0382c1da1b6ab045db0320feca505b86b4f13d66c27"
 dependencies = [
  "base64",
  "bitflags",
@@ -921,25 +837,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "paste"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880"
-dependencies = [
- "paste-impl",
- "proc-macro-hack",
-]
-
-[[package]]
-name = "paste-impl"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6"
-dependencies = [
- "proc-macro-hack",
-]
-
-[[package]]
 name = "paths"
 version = "0.1.0"
 
@@ -978,12 +875,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
 
 [[package]]
-name = "proc-macro-hack"
-version = "0.5.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e0456befd48169b9f13ef0f0ad46d492cf9d2dbb918bcf38e01eed4ce3ec5e4"
-
-[[package]]
 name = "proc-macro2"
 version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1128,7 +1019,6 @@ dependencies = [
  "chalk-solve",
  "ena",
  "expect",
- "insta",
  "itertools",
  "log",
  "ra_arena",
@@ -1187,7 +1077,7 @@ dependencies = [
  "ra_text_edit",
  "rayon",
  "rustc-hash",
- "superslice",
+ "stdx",
  "test_utils",
 ]
 
@@ -1245,9 +1135,8 @@ name = "ra_prof"
 version = "0.1.0"
 dependencies = [
  "backtrace",
- "jemalloc-ctl",
- "jemallocator",
- "mimalloc",
+ "cfg-if",
+ "libc",
  "once_cell",
  "ra_arena",
 ]
@@ -1472,6 +1361,7 @@ dependencies = [
  "log",
  "lsp-server",
  "lsp-types",
+ "mimalloc",
  "parking_lot",
  "pico-args",
  "ra_cfg",
@@ -1506,9 +1396,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-ap-rustc_lexer"
-version = "666.0.0"
+version = "669.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e00c526f9f8430ea4cd2178d25b02bfc7debe6677350c57292f92f50e65d2fe"
+checksum = "456af5f09c006cf6c22c1a433ee0232c4bb74bdc6c647a010166a47c94ed2a63"
 dependencies = [
  "unicode-xid",
 ]
@@ -1660,18 +1550,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "serde_yaml"
-version = "0.8.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae3e2dd40a7cdc18ca80db804b7f461a39bb721160a85c9a1fa30134bf3c02a5"
-dependencies = [
- "dtoa",
- "linked-hash-map",
- "serde",
- "yaml-rust",
-]
-
-[[package]]
 name = "sharded-slab"
 version = "0.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1706,12 +1584,6 @@ name = "stdx"
 version = "0.1.0"
 
 [[package]]
-name = "superslice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
-
-[[package]]
 name = "syn"
 version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1758,25 +1630,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "terminal_size"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a14cd9f8c72704232f0bfc8455c0e861f0ad4eb60cc9ec8a170e231414c1e13"
-dependencies = [
- "libc",
- "winapi 0.3.9",
-]
-
-[[package]]
-name = "termios"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0fcee7b24a25675de40d5bb4de6e41b0df07bc9856295e7e2b3a3600c400c2"
-dependencies = [
- "libc",
-]
-
-[[package]]
 name = "test_utils"
 version = "0.1.0"
 dependencies = [
@@ -2065,12 +1918,3 @@ dependencies = [
  "quote",
  "walkdir",
 ]
-
-[[package]]
-name = "yaml-rust"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39f0c922f1a334134dc2f7a8b67dc5d25f0735263feec974345ff706bcf20b0d"
-dependencies = [
- "linked-hash-map",
-]
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index 24e5f6963..def00f7d8 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -36,7 +36,7 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex
 
     acc.add(
         AssistId("change_return_type_to_result", AssistKind::RefactorRewrite),
-        "Change return type to Result",
+        "Wrap return type in Result",
         type_ref.syntax().text_range(),
         |builder| {
             let mut tail_return_expr_collector = TailReturnCollector::new();
diff --git a/crates/ra_assists/src/handlers/extract_variable.rs b/crates/ra_assists/src/handlers/extract_variable.rs
index 481baf1a4..098adf078 100644
--- a/crates/ra_assists/src/handlers/extract_variable.rs
+++ b/crates/ra_assists/src/handlers/extract_variable.rs
@@ -2,7 +2,6 @@ use ra_syntax::{
     ast::{self, AstNode},
     SyntaxKind::{
         BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
-        WHITESPACE,
     },
     SyntaxNode,
 };
@@ -36,22 +35,20 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
         mark::hit!(extract_var_in_comment_is_not_applicable);
         return None;
     }
-    let expr = node.ancestors().find_map(valid_target_expr)?;
-    let (anchor_stmt, wrap_in_block) = anchor_stmt(expr.clone())?;
-    let indent = anchor_stmt.prev_sibling_or_token()?.as_token()?.clone();
-    if indent.kind() != WHITESPACE {
-        return None;
-    }
-    let target = expr.syntax().text_range();
+    let to_extract = node.ancestors().find_map(valid_target_expr)?;
+    let anchor = Anchor::from(&to_extract)?;
+    let indent = anchor.syntax().prev_sibling_or_token()?.as_token()?.clone();
+    let target = to_extract.syntax().text_range();
     acc.add(
         AssistId("extract_variable", AssistKind::RefactorExtract),
         "Extract into variable",
         target,
         move |edit| {
-            let field_shorthand = match expr.syntax().parent().and_then(ast::RecordField::cast) {
-                Some(field) => field.name_ref(),
-                None => None,
-            };
+            let field_shorthand =
+                match to_extract.syntax().parent().and_then(ast::RecordField::cast) {
+                    Some(field) => field.name_ref(),
+                    None => None,
+                };
 
             let mut buf = String::new();
 
@@ -60,26 +57,20 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
                 None => "var_name".to_string(),
             };
             let expr_range = match &field_shorthand {
-                Some(it) => it.syntax().text_range().cover(expr.syntax().text_range()),
-                None => expr.syntax().text_range(),
+                Some(it) => it.syntax().text_range().cover(to_extract.syntax().text_range()),
+                None => to_extract.syntax().text_range(),
             };
 
-            if wrap_in_block {
+            if let Anchor::WrapInBlock(_) = anchor {
                 format_to!(buf, "{{ let {} = ", var_name);
             } else {
                 format_to!(buf, "let {} = ", var_name);
             };
-            format_to!(buf, "{}", expr.syntax());
+            format_to!(buf, "{}", to_extract.syntax());
 
-            let full_stmt = ast::ExprStmt::cast(anchor_stmt.clone());
-            let is_full_stmt = if let Some(expr_stmt) = &full_stmt {
-                Some(expr.syntax().clone()) == expr_stmt.expr().map(|e| e.syntax().clone())
-            } else {
-                false
-            };
-            if is_full_stmt {
+            if let Anchor::Replace(stmt) = anchor {
                 mark::hit!(test_extract_var_expr_stmt);
-                if full_stmt.unwrap().semicolon_token().is_none() {
+                if stmt.semicolon_token().is_none() {
                     buf.push_str(";");
                 }
                 match ctx.config.snippet_cap {
@@ -107,7 +98,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
             }
 
             edit.replace(expr_range, var_name.clone());
-            let offset = anchor_stmt.text_range().start();
+            let offset = anchor.syntax().text_range().start();
             match ctx.config.snippet_cap {
                 Some(cap) => {
                     let snip =
@@ -117,8 +108,8 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
                 None => edit.insert(offset, buf),
             }
 
-            if wrap_in_block {
-                edit.insert(anchor_stmt.text_range().end(), " }");
+            if let Anchor::WrapInBlock(_) = anchor {
+                edit.insert(anchor.syntax().text_range().end(), " }");
             }
         },
     )
@@ -138,32 +129,48 @@ fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
     }
 }
 
-/// Returns the syntax node which will follow the freshly extractd var
-/// and a boolean indicating whether we have to wrap it within a { } block
-/// to produce correct code.
-/// It can be a statement, the last in a block expression or a wanna be block
-/// expression like a lambda or match arm.
-fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
-    expr.syntax().ancestors().find_map(|node| {
-        if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
-            if expr.syntax() == &node {
-                mark::hit!(test_extract_var_last_expr);
-                return Some((node, false));
+enum Anchor {
+    Before(SyntaxNode),
+    Replace(ast::ExprStmt),
+    WrapInBlock(SyntaxNode),
+}
+
+impl Anchor {
+    fn from(to_extract: &ast::Expr) -> Option<Anchor> {
+        to_extract.syntax().ancestors().find_map(|node| {
+            if let Some(expr) =
+                node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr())
+            {
+                if expr.syntax() == &node {
+                    mark::hit!(test_extract_var_last_expr);
+                    return Some(Anchor::Before(node));
+                }
             }
-        }
 
-        if let Some(parent) = node.parent() {
-            if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
-                return Some((node, true));
+            if let Some(parent) = node.parent() {
+                if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
+                    return Some(Anchor::WrapInBlock(node));
+                }
             }
-        }
 
-        if ast::Stmt::cast(node.clone()).is_some() {
-            return Some((node, false));
-        }
+            if let Some(stmt) = ast::Stmt::cast(node.clone()) {
+                if let ast::Stmt::ExprStmt(stmt) = stmt {
+                    if stmt.expr().as_ref() == Some(to_extract) {
+                        return Some(Anchor::Replace(stmt));
+                    }
+                }
+                return Some(Anchor::Before(node));
+            }
+            None
+        })
+    }
 
-        None
-    })
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Anchor::Before(it) | Anchor::WrapInBlock(it) => it,
+            Anchor::Replace(stmt) => stmt.syntax(),
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index e212557c8..1d3ed3c6a 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -3,6 +3,7 @@ use ra_db::FileId;
 use ra_syntax::{ast, AstNode, TextRange, TextSize};
 
 use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
+use ast::VisibilityOwner;
 
 // FIXME: this really should be a fix for diagnostic, rather than an assist.
 
@@ -48,7 +49,8 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
         return None;
     };
 
-    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db(), def)?;
+    let (offset, current_visibility, target, target_file, target_name) =
+        target_data_for_def(ctx.db(), def)?;
 
     let missing_visibility =
         if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
@@ -61,8 +63,20 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
     acc.add(AssistId("fix_visibility", AssistKind::QuickFix), assist_label, target, |builder| {
         builder.edit_file(target_file);
         match ctx.config.snippet_cap {
-            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
-            None => builder.insert(offset, format!("{} ", missing_visibility)),
+            Some(cap) => match current_visibility {
+                Some(current_visibility) => builder.replace_snippet(
+                    cap,
+                    current_visibility.syntax().text_range(),
+                    format!("$0{}", missing_visibility),
+                ),
+                None => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            },
+            None => match current_visibility {
+                Some(current_visibility) => {
+                    builder.replace(current_visibility.syntax().text_range(), missing_visibility)
+                }
+                None => builder.insert(offset, format!("{} ", missing_visibility)),
+            },
         }
     })
 }
@@ -82,14 +96,14 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
     let target_module = parent.module(ctx.db());
 
     let in_file_source = record_field_def.source(ctx.db());
-    let (offset, target) = match in_file_source.value {
+    let (offset, current_visibility, target) = match in_file_source.value {
         hir::FieldSource::Named(it) => {
             let s = it.syntax();
-            (vis_offset(s), s.text_range())
+            (vis_offset(s), it.visibility(), s.text_range())
         }
         hir::FieldSource::Pos(it) => {
             let s = it.syntax();
-            (vis_offset(s), s.text_range())
+            (vis_offset(s), it.visibility(), s.text_range())
         }
     };
 
@@ -104,8 +118,20 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
     acc.add(AssistId("fix_visibility", AssistKind::QuickFix), assist_label, target, |builder| {
         builder.edit_file(target_file);
         match ctx.config.snippet_cap {
-            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
-            None => builder.insert(offset, format!("{} ", missing_visibility)),
+            Some(cap) => match current_visibility {
+                Some(current_visibility) => builder.replace_snippet(
+                    cap,
+                    dbg!(current_visibility.syntax()).text_range(),
+                    format!("$0{}", missing_visibility),
+                ),
+                None => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            },
+            None => match current_visibility {
+                Some(current_visibility) => {
+                    builder.replace(current_visibility.syntax().text_range(), missing_visibility)
+                }
+                None => builder.insert(offset, format!("{} ", missing_visibility)),
+            },
         }
     })
 }
@@ -113,24 +139,30 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
 fn target_data_for_def(
     db: &dyn HirDatabase,
     def: hir::ModuleDef,
-) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
+) -> Option<(TextSize, Option<ast::Visibility>, TextRange, FileId, Option<hir::Name>)> {
     fn offset_target_and_file_id<S, Ast>(
         db: &dyn HirDatabase,
         x: S,
-    ) -> (TextSize, TextRange, FileId)
+    ) -> (TextSize, Option<ast::Visibility>, TextRange, FileId)
     where
         S: HasSource<Ast = Ast>,
-        Ast: AstNode,
+        Ast: AstNode + ast::VisibilityOwner,
     {
         let source = x.source(db);
         let in_file_syntax = source.syntax();
         let file_id = in_file_syntax.file_id;
         let syntax = in_file_syntax.value;
-        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
+        let current_visibility = source.value.visibility();
+        (
+            vis_offset(syntax),
+            current_visibility,
+            syntax.text_range(),
+            file_id.original_file(db.upcast()),
+        )
     }
 
     let target_name;
-    let (offset, target, target_file) = match def {
+    let (offset, current_visibility, target, target_file) = match def {
         hir::ModuleDef::Function(f) => {
             target_name = Some(f.name(db));
             offset_target_and_file_id(db, f)
@@ -164,13 +196,13 @@ fn target_data_for_def(
             let in_file_source = m.declaration_source(db)?;
             let file_id = in_file_source.file_id.original_file(db.upcast());
             let syntax = in_file_source.value.syntax();
-            (vis_offset(syntax), syntax.text_range(), file_id)
+            (vis_offset(syntax), in_file_source.value.visibility(), syntax.text_range(), file_id)
         }
         // Enum variants can't be private, we can't modify builtin types
         hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
     };
 
-    Some((offset, target, target_file, target_name))
+    Some((offset, current_visibility, target, target_file, target_name))
 }
 
 #[cfg(test)]
@@ -523,6 +555,34 @@ struct Bar;
     }
 
     #[test]
+    fn replaces_pub_crate_with_pub() {
+        check_assist(
+            fix_visibility,
+            r"
+//- /main.rs crate:a deps:foo
+foo::Bar<|>
+//- /lib.rs crate:foo
+pub(crate) struct Bar;
+",
+            r"$0pub struct Bar;
+",
+        );
+        check_assist(
+            fix_visibility,
+            r"
+//- /main.rs crate:a deps:foo
+fn main() {
+    foo::Foo { <|>bar: () };
+}
+//- /lib.rs crate:foo
+pub struct Foo { pub(crate) bar: () }
+",
+            r"pub struct Foo { $0pub bar: () }
+",
+        );
+    }
+
+    #[test]
     #[ignore]
     // FIXME handle reexports properly
     fn fix_visibility_of_reexport() {
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 1ad92a1f8..a2b9f3e35 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -11,7 +11,7 @@ pub use hir_def::db::{
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
-    MacroArgQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
+    MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
 };
 pub use hir_ty::db::{
     AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index beeb98559..8fee4b15e 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -36,6 +36,8 @@ pub struct ItemScope {
 
     defs: Vec<ModuleDefId>,
     impls: Vec<ImplId>,
+    /// Traits imported via `use Trait as _;`.
+    unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
     /// Macros visible in current module in legacy textual scope
     ///
     /// For macros invoked by an unqualified identifier like `bar!()`, `legacy_macros` will be searched in first.
@@ -126,10 +128,13 @@ impl ItemScope {
     }
 
     pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
-        self.types.values().filter_map(|(def, _)| match def {
-            ModuleDefId::TraitId(t) => Some(*t),
-            _ => None,
-        })
+        self.types
+            .values()
+            .filter_map(|(def, _)| match def {
+                ModuleDefId::TraitId(t) => Some(*t),
+                _ => None,
+            })
+            .chain(self.unnamed_trait_imports.keys().copied())
     }
 
     pub(crate) fn define_def(&mut self, def: ModuleDefId) {
@@ -148,6 +153,14 @@ impl ItemScope {
         self.legacy_macros.insert(name, mac);
     }
 
+    pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> {
+        self.unnamed_trait_imports.get(&tr).copied()
+    }
+
+    pub(crate) fn push_unnamed_trait(&mut self, tr: TraitId, vis: Visibility) {
+        self.unnamed_trait_imports.insert(tr, vis);
+    }
+
     pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
         let mut changed = false;
 
@@ -241,8 +254,12 @@ impl ItemScope {
         changed
     }
 
-    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Name, PerNs)> + 'a {
-        self.entries().map(|(name, res)| (name.clone(), res))
+    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Option<Name>, PerNs)> + 'a {
+        self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
+            self.unnamed_trait_imports
+                .iter()
+                .map(|(tr, vis)| (None, PerNs::types(ModuleDefId::TraitId(*tr), *vis))),
+        )
     }
 
     pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 5a9de3d3e..3d9b55a73 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -239,7 +239,7 @@ impl CrateDefMap {
             entries.sort_by_key(|(name, _)| name.clone());
 
             for (name, def) in entries {
-                format_to!(buf, "{}:", name);
+                format_to!(buf, "{}:", name.map_or("_".to_string(), |name| name.to_string()));
 
                 if def.types.is_some() {
                     buf.push_str(" t");
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index d85a86c0a..a030cab47 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -310,7 +310,7 @@ impl DefCollector<'_> {
         if export {
             self.update(
                 self.def_map.root,
-                &[(name, PerNs::macros(macro_, Visibility::Public))],
+                &[(Some(name), PerNs::macros(macro_, Visibility::Public))],
                 Visibility::Public,
                 ImportType::Named,
             );
@@ -336,7 +336,7 @@ impl DefCollector<'_> {
     fn define_proc_macro(&mut self, name: Name, macro_: MacroDefId) {
         self.update(
             self.def_map.root,
-            &[(name, PerNs::macros(macro_, Visibility::Public))],
+            &[(Some(name), PerNs::macros(macro_, Visibility::Public))],
             Visibility::Public,
             ImportType::Named,
         );
@@ -534,7 +534,7 @@ impl DefCollector<'_> {
                             let name = variant_data.name.clone();
                             let variant = EnumVariantId { parent: e, local_id };
                             let res = PerNs::both(variant.into(), variant.into(), vis);
-                            (name, res)
+                            (Some(name), res)
                         })
                         .collect::<Vec<_>>();
                     self.update(module_id, &resolutions, vis, ImportType::Glob);
@@ -550,15 +550,15 @@ impl DefCollector<'_> {
             match import.path.segments.last() {
                 Some(last_segment) => {
                     let name = match &import.alias {
-                        Some(ImportAlias::Alias(name)) => name.clone(),
-                        Some(ImportAlias::Underscore) => last_segment.clone(), // FIXME rust-analyzer#2736
-                        None => last_segment.clone(),
+                        Some(ImportAlias::Alias(name)) => Some(name.clone()),
+                        Some(ImportAlias::Underscore) => None,
+                        None => Some(last_segment.clone()),
                     };
                     log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
 
                     // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
                     if import.is_extern_crate && module_id == self.def_map.root {
-                        if let Some(def) = def.take_types() {
+                        if let (Some(def), Some(name)) = (def.take_types(), name.as_ref()) {
                             self.def_map.extern_prelude.insert(name.clone(), def);
                         }
                     }
@@ -573,7 +573,7 @@ impl DefCollector<'_> {
     fn update(
         &mut self,
         module_id: LocalModuleId,
-        resolutions: &[(Name, PerNs)],
+        resolutions: &[(Option<Name>, PerNs)],
         vis: Visibility,
         import_type: ImportType,
     ) {
@@ -584,7 +584,7 @@ impl DefCollector<'_> {
     fn update_recursive(
         &mut self,
         module_id: LocalModuleId,
-        resolutions: &[(Name, PerNs)],
+        resolutions: &[(Option<Name>, PerNs)],
         // All resolutions are imported with this visibility; the visibilies in
         // the `PerNs` values are ignored and overwritten
         vis: Visibility,
@@ -595,15 +595,51 @@ impl DefCollector<'_> {
             // prevent stack overflows (but this shouldn't be possible)
             panic!("infinite recursion in glob imports!");
         }
-        let scope = &mut self.def_map.modules[module_id].scope;
         let mut changed = false;
+
         for (name, res) in resolutions {
-            changed |= scope.push_res_with_import(
-                &mut self.from_glob_import,
-                (module_id, name.clone()),
-                res.with_visibility(vis),
-                import_type,
-            );
+            match name {
+                Some(name) => {
+                    let scope = &mut self.def_map.modules[module_id].scope;
+                    changed |= scope.push_res_with_import(
+                        &mut self.from_glob_import,
+                        (module_id, name.clone()),
+                        res.with_visibility(vis),
+                        import_type,
+                    );
+                }
+                None => {
+                    let tr = match res.take_types() {
+                        Some(ModuleDefId::TraitId(tr)) => tr,
+                        Some(other) => {
+                            log::debug!("non-trait `_` import of {:?}", other);
+                            continue;
+                        }
+                        None => continue,
+                    };
+                    let old_vis = self.def_map.modules[module_id].scope.unnamed_trait_vis(tr);
+                    let should_update = match old_vis {
+                        None => true,
+                        Some(old_vis) => {
+                            let max_vis = old_vis.max(vis, &self.def_map).unwrap_or_else(|| {
+                                panic!("`Tr as _` imports with unrelated visibilities {:?} and {:?} (trait {:?})", old_vis, vis, tr);
+                            });
+
+                            if max_vis == old_vis {
+                                false
+                            } else {
+                                mark::hit!(upgrade_underscore_visibility);
+                                true
+                            }
+                        }
+                    };
+
+                    if should_update {
+                        changed = true;
+                        self.def_map.modules[module_id].scope.push_unnamed_trait(tr, vis);
+                    }
+                }
+            }
         }
 
         if !changed {
@@ -950,7 +986,7 @@ impl ModCollector<'_, '_> {
                         .unwrap_or(Visibility::Public);
                     self.def_collector.update(
                         self.module_id,
-                        &[(name.clone(), PerNs::from_def(id, vis, has_constructor))],
+                        &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
                         vis,
                         ImportType::Named,
                     )
@@ -1057,7 +1093,7 @@ impl ModCollector<'_, '_> {
         self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
         self.def_collector.update(
             self.module_id,
-            &[(name, PerNs::from_def(def, vis, false))],
+            &[(Some(name), PerNs::from_def(def, vis, false))],
             vis,
             ImportType::Named,
         );
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 205d3528b..839b1de57 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -558,3 +558,133 @@ mod b {
         "#]],
     );
 }
+
+#[test]
+fn underscore_import() {
+    check(
+        r#"
+//- /main.rs
+use tr::Tr as _;
+use tr::Tr2 as _;
+
+mod tr {
+    pub trait Tr {}
+    pub trait Tr2 {}
+}
+    "#,
+        expect![[r#"
+            crate
+            _: t
+            _: t
+            tr: t
+
+            crate::tr
+            Tr: t
+            Tr2: t
+        "#]],
+    );
+}
+
+#[test]
+fn underscore_reexport() {
+    check(
+        r#"
+//- /main.rs
+mod tr {
+    pub trait PubTr {}
+    pub trait PrivTr {}
+}
+mod reex {
+    use crate::tr::PrivTr as _;
+    pub use crate::tr::PubTr as _;
+}
+use crate::reex::*;
+    "#,
+        expect![[r#"
+            crate
+            _: t
+            reex: t
+            tr: t
+
+            crate::tr
+            PrivTr: t
+            PubTr: t
+
+            crate::reex
+            _: t
+            _: t
+        "#]],
+    );
+}
+
+#[test]
+fn underscore_pub_crate_reexport() {
+    mark::check!(upgrade_underscore_visibility);
+    check(
+        r#"
+//- /main.rs crate:main deps:lib
+use lib::*;
+
+//- /lib.rs crate:lib
+use tr::Tr as _;
+pub use tr::Tr as _;
+
+mod tr {
+    pub trait Tr {}
+}
+    "#,
+        expect![[r#"
+            crate
+            _: t
+        "#]],
+    );
+}
+
+#[test]
+fn underscore_nontrait() {
+    check(
+        r#"
+//- /main.rs
+mod m {
+    pub struct Struct;
+    pub enum Enum {}
+    pub const CONST: () = ();
+}
+use crate::m::{Struct as _, Enum as _, CONST as _};
+    "#,
+        expect![[r#"
+            crate
+            m: t
+
+            crate::m
+            CONST: v
+            Enum: t
+            Struct: t v
+        "#]],
+    );
+}
+
+#[test]
+fn underscore_name_conflict() {
+    check(
+        r#"
+//- /main.rs
+struct Tr;
+
+use tr::Tr as _;
+
+mod tr {
+    pub trait Tr {}
+}
+    "#,
+        expect![[r#"
+            crate
+            _: t
+            Tr: t v
+            tr: t
+
+            crate::tr
+            Tr: t
+        "#]],
+    );
+}
diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs
index 8136cb50c..1abffb4c3 100644
--- a/crates/ra_hir_def/src/visibility.rs
+++ b/crates/ra_hir_def/src/visibility.rs
@@ -5,6 +5,7 @@ use ra_syntax::ast;
 
 use crate::{
     db::DefDatabase,
+    nameres::CrateDefMap,
     path::{ModPath, PathKind},
     ModuleId,
 };
@@ -115,7 +116,7 @@ impl Visibility {
 
     pub(crate) fn is_visible_from_def_map(
         self,
-        def_map: &crate::nameres::CrateDefMap,
+        def_map: &CrateDefMap,
         from_module: crate::LocalModuleId,
     ) -> bool {
         let to_module = match self {
@@ -129,4 +130,42 @@ impl Visibility {
         });
         ancestors.any(|m| m == to_module.local_id)
     }
+
+    /// Returns the most permissive visibility of `self` and `other`.
+    ///
+    /// If there is no subset relation between `self` and `other`, returns `None` (ie. they're only
+    /// visible in unrelated modules).
+    pub(crate) fn max(self, other: Visibility, def_map: &CrateDefMap) -> Option<Visibility> {
+        match (self, other) {
+            (Visibility::Module(_), Visibility::Public)
+            | (Visibility::Public, Visibility::Module(_))
+            | (Visibility::Public, Visibility::Public) => Some(Visibility::Public),
+            (Visibility::Module(mod_a), Visibility::Module(mod_b)) => {
+                if mod_a.krate != mod_b.krate {
+                    return None;
+                }
+
+                let mut a_ancestors = std::iter::successors(Some(mod_a.local_id), |m| {
+                    let parent_id = def_map[*m].parent?;
+                    Some(parent_id)
+                });
+                let mut b_ancestors = std::iter::successors(Some(mod_b.local_id), |m| {
+                    let parent_id = def_map[*m].parent?;
+                    Some(parent_id)
+                });
+
+                if a_ancestors.any(|m| m == mod_b.local_id) {
+                    // B is above A
+                    return Some(Visibility::Module(mod_b));
+                }
+
+                if b_ancestors.any(|m| m == mod_a.local_id) {
+                    // A is above B
+                    return Some(Visibility::Module(mod_a));
+                }
+
+                None
+            }
+        }
+    }
 }
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index bf30d7151..e0ad1567f 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -6,7 +6,7 @@ use mbe::{ExpandResult, MacroRules};
 use ra_db::{salsa, SourceDatabase};
 use ra_parser::FragmentKind;
 use ra_prof::profile;
-use ra_syntax::{algo::diff, AstNode, Parse, SyntaxKind::*, SyntaxNode};
+use ra_syntax::{algo::diff, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
 
 use crate::{
     ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId,
@@ -72,6 +72,8 @@ pub trait AstDatabase: SourceDatabase {
 
     #[salsa::interned]
     fn intern_macro(&self, macro_call: MacroCallLoc) -> LazyMacroId;
+    fn macro_arg_text(&self, id: MacroCallId) -> Option<GreenNode>;
+    #[salsa::transparent]
     fn macro_arg(&self, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>>;
     fn macro_def(&self, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>>;
     fn parse_macro(&self, macro_file: MacroFile)
@@ -148,10 +150,7 @@ pub(crate) fn macro_def(
     }
 }
 
-pub(crate) fn macro_arg(
-    db: &dyn AstDatabase,
-    id: MacroCallId,
-) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
+pub(crate) fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
     let id = match id {
         MacroCallId::LazyMacro(id) => id,
         MacroCallId::EagerMacro(_id) => {
@@ -161,7 +160,15 @@ pub(crate) fn macro_arg(
     };
     let loc = db.lookup_intern_macro(id);
     let arg = loc.kind.arg(db)?;
-    let (tt, tmap) = mbe::syntax_node_to_token_tree(&arg)?;
+    Some(arg.green().clone())
+}
+
+pub(crate) fn macro_arg(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
+    let arg = db.macro_arg_text(id)?;
+    let (tt, tmap) = mbe::syntax_node_to_token_tree(&SyntaxNode::new_root(arg))?;
     Some(Arc::new((tt, tmap)))
 }
 
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 1cf6c1ba9..d9e31ac20 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -262,14 +262,14 @@ pub enum MacroCallKind {
 }
 
 impl MacroCallKind {
-    pub fn file_id(&self) -> HirFileId {
+    fn file_id(&self) -> HirFileId {
         match self {
             MacroCallKind::FnLike(ast_id) => ast_id.file_id,
             MacroCallKind::Attr(ast_id, _) => ast_id.file_id,
         }
     }
 
-    pub fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
+    fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
         match self {
             MacroCallKind::FnLike(ast_id) => ast_id.with_value(ast_id.to_node(db).syntax().clone()),
             MacroCallKind::Attr(ast_id, _) => {
@@ -278,7 +278,7 @@ impl MacroCallKind {
         }
     }
 
-    pub fn arg(&self, db: &dyn db::AstDatabase) -> Option<SyntaxNode> {
+    fn arg(&self, db: &dyn db::AstDatabase) -> Option<SyntaxNode> {
         match self {
             MacroCallKind::FnLike(ast_id) => {
                 Some(ast_id.to_node(db).token_tree()?.syntax().clone())
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 78f5e55bb..cdabb359f 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -28,12 +28,11 @@ test_utils = { path = "../test_utils" }
 
 scoped-tls = "1"
 
-chalk-solve = { version = "0.17.0" }
-chalk-ir = { version = "0.17.0" }
-chalk-recursive = { version = "0.17.0" }
+chalk-solve = { version = "0.18.0" }
+chalk-ir = { version = "0.18.0" }
+chalk-recursive = { version = "0.18.0" }
 
 [dev-dependencies]
-insta = "0.16.0"
 expect = { path = "../expect" }
 
 tracing = "0.1"
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index 758d5f5ac..19770e609 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -257,7 +257,12 @@ impl HirDisplay for ApplicationTy {
                 write!(f, ")")?;
                 let ret = sig.ret();
                 if *ret != Ty::unit() {
-                    write!(f, " -> {}", ret.display(f.db))?;
+                    let ret_display = if f.omit_verbose_types() {
+                        ret.display_truncated(f.db, f.max_size)
+                    } else {
+                        ret.display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                 }
             }
             TypeCtor::FnDef(def) => {
@@ -288,7 +293,12 @@ impl HirDisplay for ApplicationTy {
                 write!(f, ")")?;
                 let ret = sig.ret();
                 if *ret != Ty::unit() {
-                    write!(f, " -> {}", ret.display(f.db))?;
+                    let ret_display = if f.omit_verbose_types() {
+                        ret.display_truncated(f.db, f.max_size)
+                    } else {
+                        ret.display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                 }
             }
             TypeCtor::Adt(def_id) => {
@@ -397,7 +407,13 @@ impl HirDisplay for ApplicationTy {
                         f.write_joined(sig.params(), ", ")?;
                         write!(f, "|")?;
                     };
-                    write!(f, " -> {}", sig.ret().display(f.db))?;
+
+                    let ret_display = if f.omit_verbose_types() {
+                        sig.ret().display_truncated(f.db, f.max_size)
+                    } else {
+                        sig.ret().display(f.db)
+                    };
+                    write!(f, " -> {}", ret_display)?;
                 } else {
                     write!(f, "{{closure}}")?;
                 }
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 59a21092e..45bc14c37 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -34,8 +34,8 @@ use crate::{
 };
 
 // These tests compare the inference results for all expressions in a file
-// against snapshots of the expected results using insta. Use cargo-insta to
-// update the snapshots.
+// against snapshots of the expected results using expect. Use
+// `env UPDATE_EXPECT=1 cargo test -p ra_hir_ty` to update the snapshots.
 
 fn setup_tracing() -> tracing::subscriber::DefaultGuard {
     use tracing_subscriber::{layer::SubscriberExt, EnvFilter, Registry};
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 45c4e309e..24c53eb02 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -1,9 +1,9 @@
 use std::fs;
 
-use insta::assert_snapshot;
+use expect::expect;
 use test_utils::project_dir;
 
-use super::{check_types, infer};
+use super::{check_infer, check_types};
 
 #[test]
 fn cfg_impl_def() {
@@ -46,204 +46,204 @@ impl S {
 
 #[test]
 fn infer_macros_expanded() {
-    assert_snapshot!(
-        infer(r#"
-struct Foo(Vec<i32>);
-
-macro_rules! foo {
-    ($($item:expr),*) => {
-            {
-                Foo(vec![$($item,)*])
-            }
-    };
-}
+    check_infer(
+        r#"
+        struct Foo(Vec<i32>);
+
+        macro_rules! foo {
+            ($($item:expr),*) => {
+                    {
+                        Foo(vec![$($item,)*])
+                    }
+            };
+        }
 
-fn main() {
-    let x = foo!(1,2);
-}
-"#),
-        @r###"
-    !0..17 '{Foo(v...,2,])}': Foo
-    !1..4 'Foo': Foo({unknown}) -> Foo
-    !1..16 'Foo(vec![1,2,])': Foo
-    !5..15 'vec![1,2,]': {unknown}
-    155..181 '{     ...,2); }': ()
-    165..166 'x': Foo
-    "###
+        fn main() {
+            let x = foo!(1,2);
+        }
+        "#,
+        expect![[r#"
+            !0..17 '{Foo(v...,2,])}': Foo
+            !1..4 'Foo': Foo({unknown}) -> Foo
+            !1..16 'Foo(vec![1,2,])': Foo
+            !5..15 'vec![1,2,]': {unknown}
+            155..181 '{     ...,2); }': ()
+            165..166 'x': Foo
+        "#]],
     );
 }
 
 #[test]
 fn infer_legacy_textual_scoped_macros_expanded() {
-    assert_snapshot!(
-        infer(r#"
-struct Foo(Vec<i32>);
-
-#[macro_use]
-mod m {
-    macro_rules! foo {
-        ($($item:expr),*) => {
-            {
-                Foo(vec![$($item,)*])
+    check_infer(
+        r#"
+        struct Foo(Vec<i32>);
+
+        #[macro_use]
+        mod m {
+            macro_rules! foo {
+                ($($item:expr),*) => {
+                    {
+                        Foo(vec![$($item,)*])
+                    }
+                };
             }
-        };
-    }
-}
+        }
 
-fn main() {
-    let x = foo!(1,2);
-    let y = crate::foo!(1,2);
-}
-"#),
-        @r###"
-    !0..17 '{Foo(v...,2,])}': Foo
-    !1..4 'Foo': Foo({unknown}) -> Foo
-    !1..16 'Foo(vec![1,2,])': Foo
-    !5..15 'vec![1,2,]': {unknown}
-    194..250 '{     ...,2); }': ()
-    204..205 'x': Foo
-    227..228 'y': {unknown}
-    231..247 'crate:...!(1,2)': {unknown}
-    "###
+        fn main() {
+            let x = foo!(1,2);
+            let y = crate::foo!(1,2);
+        }
+        "#,
+        expect![[r#"
+            !0..17 '{Foo(v...,2,])}': Foo
+            !1..4 'Foo': Foo({unknown}) -> Foo
+            !1..16 'Foo(vec![1,2,])': Foo
+            !5..15 'vec![1,2,]': {unknown}
+            194..250 '{     ...,2); }': ()
+            204..205 'x': Foo
+            227..228 'y': {unknown}
+            231..247 'crate:...!(1,2)': {unknown}
+        "#]],
     );
 }
 
 #[test]
 fn infer_path_qualified_macros_expanded() {
-    assert_snapshot!(
-        infer(r#"
-#[macro_export]
-macro_rules! foo {
-    () => { 42i32 }
-}
+    check_infer(
+        r#"
+        #[macro_export]
+        macro_rules! foo {
+            () => { 42i32 }
+        }
 
-mod m {
-    pub use super::foo as bar;
-}
+        mod m {
+            pub use super::foo as bar;
+        }
 
-fn main() {
-    let x = crate::foo!();
-    let y = m::bar!();
-}
-"#),
-        @r###"
-    !0..5 '42i32': i32
-    !0..5 '42i32': i32
-    110..163 '{     ...!(); }': ()
-    120..121 'x': i32
-    147..148 'y': i32
-    "###
+        fn main() {
+            let x = crate::foo!();
+            let y = m::bar!();
+        }
+        "#,
+        expect![[r#"
+            !0..5 '42i32': i32
+            !0..5 '42i32': i32
+            110..163 '{     ...!(); }': ()
+            120..121 'x': i32
+            147..148 'y': i32
+        "#]],
     );
 }
 
 #[test]
 fn expr_macro_expanded_in_various_places() {
-    assert_snapshot!(
-        infer(r#"
-macro_rules! spam {
-    () => (1isize);
-}
-
-fn spam() {
-    spam!();
-    (spam!());
-    spam!().spam(spam!());
-    for _ in spam!() {}
-    || spam!();
-    while spam!() {}
-    break spam!();
-    return spam!();
-    match spam!() {
-        _ if spam!() => spam!(),
-    }
-    spam!()(spam!());
-    Spam { spam: spam!() };
-    spam!()[spam!()];
-    await spam!();
-    spam!() as usize;
-    &spam!();
-    -spam!();
-    spam!()..spam!();
-    spam!() + spam!();
-}
-"#),
-        @r###"
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    !0..6 '1isize': isize
-    53..456 '{     ...!(); }': ()
-    87..108 'spam!(...am!())': {unknown}
-    114..133 'for _ ...!() {}': ()
-    118..119 '_': {unknown}
-    131..133 '{}': ()
-    138..148 '|| spam!()': || -> isize
-    154..170 'while ...!() {}': ()
-    168..170 '{}': ()
-    175..188 'break spam!()': !
-    194..208 'return spam!()': !
-    214..268 'match ...     }': isize
-    238..239 '_': isize
-    273..289 'spam!(...am!())': {unknown}
-    295..317 'Spam {...m!() }': {unknown}
-    323..339 'spam!(...am!()]': {unknown}
-    364..380 'spam!(... usize': usize
-    386..394 '&spam!()': &isize
-    400..408 '-spam!()': isize
-    414..430 'spam!(...pam!()': {unknown}
-    436..453 'spam!(...pam!()': isize
-    "###
+    check_infer(
+        r#"
+        macro_rules! spam {
+            () => (1isize);
+        }
+
+        fn spam() {
+            spam!();
+            (spam!());
+            spam!().spam(spam!());
+            for _ in spam!() {}
+            || spam!();
+            while spam!() {}
+            break spam!();
+            return spam!();
+            match spam!() {
+                _ if spam!() => spam!(),
+            }
+            spam!()(spam!());
+            Spam { spam: spam!() };
+            spam!()[spam!()];
+            await spam!();
+            spam!() as usize;
+            &spam!();
+            -spam!();
+            spam!()..spam!();
+            spam!() + spam!();
+        }
+        "#,
+        expect![[r#"
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            !0..6 '1isize': isize
+            53..456 '{     ...!(); }': ()
+            87..108 'spam!(...am!())': {unknown}
+            114..133 'for _ ...!() {}': ()
+            118..119 '_': {unknown}
+            131..133 '{}': ()
+            138..148 '|| spam!()': || -> isize
+            154..170 'while ...!() {}': ()
+            168..170 '{}': ()
+            175..188 'break spam!()': !
+            194..208 'return spam!()': !
+            214..268 'match ...     }': isize
+            238..239 '_': isize
+            273..289 'spam!(...am!())': {unknown}
+            295..317 'Spam {...m!() }': {unknown}
+            323..339 'spam!(...am!()]': {unknown}
+            364..380 'spam!(... usize': usize
+            386..394 '&spam!()': &isize
+            400..408 '-spam!()': isize
+            414..430 'spam!(...pam!()': {unknown}
+            436..453 'spam!(...pam!()': isize
+        "#]],
     );
 }
 
 #[test]
 fn infer_type_value_macro_having_same_name() {
-    assert_snapshot!(
-        infer(r#"
-#[macro_export]
-macro_rules! foo {
-    () => {
-        mod foo {
-            pub use super::foo;
+    check_infer(
+        r#"
+        #[macro_export]
+        macro_rules! foo {
+            () => {
+                mod foo {
+                    pub use super::foo;
+                }
+            };
+            ($x:tt) => {
+                $x
+            };
         }
-    };
-    ($x:tt) => {
-        $x
-    };
-}
 
-foo!();
+        foo!();
 
-fn foo() {
-    let foo = foo::foo!(42i32);
-}
-"#),
-        @r###"
-    !0..5 '42i32': i32
-    170..205 '{     ...32); }': ()
-    180..183 'foo': i32
-    "###
+        fn foo() {
+            let foo = foo::foo!(42i32);
+        }
+        "#,
+        expect![[r#"
+            !0..5 '42i32': i32
+            170..205 '{     ...32); }': ()
+            180..183 'foo': i32
+        "#]],
     );
 }
 
@@ -372,50 +372,50 @@ expand!();
 
 #[test]
 fn infer_type_value_non_legacy_macro_use_as() {
-    assert_snapshot!(
-        infer(r#"
-mod m {
-    macro_rules! _foo {
-        ($x:ident) => { type $x = u64; }
-    }
-    pub(crate) use _foo as foo;
-}
+    check_infer(
+        r#"
+        mod m {
+            macro_rules! _foo {
+                ($x:ident) => { type $x = u64; }
+            }
+            pub(crate) use _foo as foo;
+        }
 
-m::foo!(foo);
-use foo as bar;
-fn f() -> bar { 0 }
-fn main() {
-    let _a  = f();
-}
-"#),
-        @r###"
-    158..163 '{ 0 }': u64
-    160..161 '0': u64
-    174..196 '{     ...f(); }': ()
-    184..186 '_a': u64
-    190..191 'f': fn f() -> u64
-    190..193 'f()': u64
-    "###
+        m::foo!(foo);
+        use foo as bar;
+        fn f() -> bar { 0 }
+        fn main() {
+            let _a  = f();
+        }
+        "#,
+        expect![[r#"
+            158..163 '{ 0 }': u64
+            160..161 '0': u64
+            174..196 '{     ...f(); }': ()
+            184..186 '_a': u64
+            190..191 'f': fn f() -> u64
+            190..193 'f()': u64
+        "#]],
     );
 }
 
 #[test]
 fn infer_local_macro() {
-    assert_snapshot!(
-        infer(r#"
-fn main() {
-    macro_rules! foo {
-        () => { 1usize }
-    }
-    let _a  = foo!();
-}
-"#),
-        @r###"
-    !0..6 '1usize': usize
-    10..89 '{     ...!(); }': ()
-    16..65 'macro_...     }': {unknown}
-    74..76 '_a': usize
-    "###
+    check_infer(
+        r#"
+        fn main() {
+            macro_rules! foo {
+                () => { 1usize }
+            }
+            let _a  = foo!();
+        }
+        "#,
+        expect![[r#"
+            !0..6 '1usize': usize
+            10..89 '{     ...!(); }': ()
+            16..65 'macro_...     }': {unknown}
+            74..76 '_a': usize
+        "#]],
     );
 }
 
@@ -446,77 +446,77 @@ macro_rules! bar {
 
 #[test]
 fn infer_builtin_macros_line() {
-    assert_snapshot!(
-        infer(r#"
-#[rustc_builtin_macro]
-macro_rules! line {() => {}}
+    check_infer(
+        r#"
+        #[rustc_builtin_macro]
+        macro_rules! line {() => {}}
 
-fn main() {
-    let x = line!();
-}
-"#),
-        @r###"
-    !0..1 '0': i32
-    63..87 '{     ...!(); }': ()
-    73..74 'x': i32
-    "###
+        fn main() {
+            let x = line!();
+        }
+        "#,
+        expect![[r#"
+            !0..1 '0': i32
+            63..87 '{     ...!(); }': ()
+            73..74 'x': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_builtin_macros_file() {
-    assert_snapshot!(
-        infer(r#"
-#[rustc_builtin_macro]
-macro_rules! file {() => {}}
+    check_infer(
+        r#"
+        #[rustc_builtin_macro]
+        macro_rules! file {() => {}}
 
-fn main() {
-    let x = file!();
-}
-"#),
-        @r###"
-    !0..2 '""': &str
-    63..87 '{     ...!(); }': ()
-    73..74 'x': &str
-    "###
+        fn main() {
+            let x = file!();
+        }
+        "#,
+        expect![[r#"
+            !0..2 '""': &str
+            63..87 '{     ...!(); }': ()
+            73..74 'x': &str
+        "#]],
     );
 }
 
 #[test]
 fn infer_builtin_macros_column() {
-    assert_snapshot!(
-        infer(r#"
-#[rustc_builtin_macro]
-macro_rules! column {() => {}}
+    check_infer(
+        r#"
+        #[rustc_builtin_macro]
+        macro_rules! column {() => {}}
 
-fn main() {
-    let x = column!();
-}
-"#),
-        @r###"
-    !0..1 '0': i32
-    65..91 '{     ...!(); }': ()
-    75..76 'x': i32
-    "###
+        fn main() {
+            let x = column!();
+        }
+        "#,
+        expect![[r#"
+            !0..1 '0': i32
+            65..91 '{     ...!(); }': ()
+            75..76 'x': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_builtin_macros_concat() {
-    assert_snapshot!(
-        infer(r#"
-#[rustc_builtin_macro]
-macro_rules! concat {() => {}}
+    check_infer(
+        r#"
+        #[rustc_builtin_macro]
+        macro_rules! concat {() => {}}
 
-fn main() {
-    let x = concat!("hello", concat!("world", "!"));
-}
-"#),
-        @r###"
-    !0..13 '"helloworld!"': &str
-    65..121 '{     ...")); }': ()
-    75..76 'x': &str
-    "###
+        fn main() {
+            let x = concat!("hello", concat!("world", "!"));
+        }
+        "#,
+        expect![[r#"
+            !0..13 '"helloworld!"': &str
+            65..121 '{     ...")); }': ()
+            75..76 'x': &str
+        "#]],
     );
 }
 
@@ -622,7 +622,7 @@ macro_rules! include {() => {}}
 include!("main.rs");
 
 fn main() {
-    0
+            0
 } //^ i32
 "#,
     );
@@ -630,42 +630,42 @@ fn main() {
 
 #[test]
 fn infer_builtin_macros_concat_with_lazy() {
-    assert_snapshot!(
-        infer(r#"
-macro_rules! hello {() => {"hello"}}
+    check_infer(
+        r#"
+        macro_rules! hello {() => {"hello"}}
 
-#[rustc_builtin_macro]
-macro_rules! concat {() => {}}
+        #[rustc_builtin_macro]
+        macro_rules! concat {() => {}}
 
-fn main() {
-    let x = concat!(hello!(), concat!("world", "!"));
-}
-"#),
-        @r###"
-    !0..13 '"helloworld!"': &str
-    103..160 '{     ...")); }': ()
-    113..114 'x': &str
-    "###
+        fn main() {
+            let x = concat!(hello!(), concat!("world", "!"));
+        }
+        "#,
+        expect![[r#"
+            !0..13 '"helloworld!"': &str
+            103..160 '{     ...")); }': ()
+            113..114 'x': &str
+        "#]],
     );
 }
 
 #[test]
 fn infer_builtin_macros_env() {
-    assert_snapshot!(
-        infer(r#"
-//- /main.rs env:foo=bar
-#[rustc_builtin_macro]
-macro_rules! env {() => {}}
+    check_infer(
+        r#"
+        //- /main.rs env:foo=bar
+        #[rustc_builtin_macro]
+        macro_rules! env {() => {}}
 
-fn main() {
-    let x = env!("foo");
-}
-"#),
-        @r###"
-    !0..22 '"__RA_...TED__"': &str
-    62..90 '{     ...o"); }': ()
-    72..73 'x': &str
-    "###
+        fn main() {
+            let x = env!("foo");
+        }
+        "#,
+        expect![[r#"
+            !0..22 '"__RA_...TED__"': &str
+            62..90 '{     ...o"); }': ()
+            72..73 'x': &str
+        "#]],
     );
 }
 
@@ -763,25 +763,25 @@ fn test() {
 
 #[test]
 fn macro_in_arm() {
-    assert_snapshot!(
-        infer(r#"
-macro_rules! unit {
-    () => { () };
-}
+    check_infer(
+        r#"
+        macro_rules! unit {
+            () => { () };
+        }
 
-fn main() {
-    let x = match () {
-        unit!() => 92u32,
-    };
-}
-"#),
-        @r###"
-    51..110 '{     ...  }; }': ()
-    61..62 'x': u32
-    65..107 'match ...     }': u32
-    71..73 '()': ()
-    84..91 'unit!()': ()
-    95..100 '92u32': u32
-    "###
+        fn main() {
+            let x = match () {
+                unit!() => 92u32,
+            };
+        }
+        "#,
+        expect![[r#"
+            51..110 '{     ...  }; }': ()
+            61..62 'x': u32
+            65..107 'match ...     }': u32
+            71..73 '()': ()
+            84..91 'unit!()': ()
+            95..100 '92u32': u32
+        "#]],
     );
 }
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index 9c8f22314..fa68355aa 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -1,245 +1,245 @@
-use insta::assert_snapshot;
+use expect::expect;
 
-use super::{check_types, infer};
+use super::{check_infer, check_types};
 
 #[test]
 fn infer_slice_method() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "slice"]
-impl<T> [T] {
-    fn foo(&self) -> T {
-        loop {}
-    }
-}
-
-#[lang = "slice_alloc"]
-impl<T> [T] {}
-
-fn test(x: &[u8]) {
-    <[_]>::foo(x);
-}
-"#),
-        @r###"
-    44..48 'self': &[T]
-    55..78 '{     ...     }': T
-    65..72 'loop {}': !
-    70..72 '{}': ()
-    130..131 'x': &[u8]
-    140..162 '{     ...(x); }': ()
-    146..156 '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
-    146..159 '<[_]>::foo(x)': u8
-    157..158 'x': &[u8]
-    "###
+    check_infer(
+        r#"
+        #[lang = "slice"]
+        impl<T> [T] {
+            fn foo(&self) -> T {
+                loop {}
+            }
+        }
+
+        #[lang = "slice_alloc"]
+        impl<T> [T] {}
+
+        fn test(x: &[u8]) {
+            <[_]>::foo(x);
+        }
+        "#,
+        expect![[r#"
+            44..48 'self': &[T]
+            55..78 '{     ...     }': T
+            65..72 'loop {}': !
+            70..72 '{}': ()
+            130..131 'x': &[u8]
+            140..162 '{     ...(x); }': ()
+            146..156 '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
+            146..159 '<[_]>::foo(x)': u8
+            157..158 'x': &[u8]
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_struct() {
-    assert_snapshot!(
-        infer(r#"
-struct A { x: u32 }
-
-impl A {
-    fn new() -> A {
-        A { x: 0 }
-    }
-}
-fn test() {
-    let a = A::new();
-    a.x;
-}
-"#),
-        @r###"
-    48..74 '{     ...     }': A
-    58..68 'A { x: 0 }': A
-    65..66 '0': u32
-    87..121 '{     ...a.x; }': ()
-    97..98 'a': A
-    101..107 'A::new': fn new() -> A
-    101..109 'A::new()': A
-    115..116 'a': A
-    115..118 'a.x': u32
-    "###
+    check_infer(
+        r#"
+        struct A { x: u32 }
+
+        impl A {
+            fn new() -> A {
+                A { x: 0 }
+            }
+        }
+        fn test() {
+            let a = A::new();
+            a.x;
+        }
+        "#,
+        expect![[r#"
+            48..74 '{     ...     }': A
+            58..68 'A { x: 0 }': A
+            65..66 '0': u32
+            87..121 '{     ...a.x; }': ()
+            97..98 'a': A
+            101..107 'A::new': fn new() -> A
+            101..109 'A::new()': A
+            115..116 'a': A
+            115..118 'a.x': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_enum() {
-    assert_snapshot!(
-        infer(r#"
-enum A { B, C }
-
-impl A {
-    pub fn b() -> A {
-        A::B
-    }
-    pub fn c() -> A {
-        A::C
-    }
-}
-fn test() {
-    let a = A::b();
-    a;
-    let c = A::c();
-    c;
-}
-"#),
-        @r###"
-    46..66 '{     ...     }': A
-    56..60 'A::B': A
-    87..107 '{     ...     }': A
-    97..101 'A::C': A
-    120..177 '{     ...  c; }': ()
-    130..131 'a': A
-    134..138 'A::b': fn b() -> A
-    134..140 'A::b()': A
-    146..147 'a': A
-    157..158 'c': A
-    161..165 'A::c': fn c() -> A
-    161..167 'A::c()': A
-    173..174 'c': A
-    "###
+    check_infer(
+        r#"
+        enum A { B, C }
+
+        impl A {
+            pub fn b() -> A {
+                A::B
+            }
+            pub fn c() -> A {
+                A::C
+            }
+        }
+        fn test() {
+            let a = A::b();
+            a;
+            let c = A::c();
+            c;
+        }
+        "#,
+        expect![[r#"
+            46..66 '{     ...     }': A
+            56..60 'A::B': A
+            87..107 '{     ...     }': A
+            97..101 'A::C': A
+            120..177 '{     ...  c; }': ()
+            130..131 'a': A
+            134..138 'A::b': fn b() -> A
+            134..140 'A::b()': A
+            146..147 'a': A
+            157..158 'c': A
+            161..165 'A::c': fn c() -> A
+            161..167 'A::c()': A
+            173..174 'c': A
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_with_modules() {
-    assert_snapshot!(
-        infer(r#"
-mod a {
-    struct A;
-    impl A { pub fn thing() -> A { A {} }}
-}
-
-mod b {
-    struct B;
-    impl B { pub fn thing() -> u32 { 99 }}
-
-    mod c {
-        struct C;
-        impl C { pub fn thing() -> C { C {} }}
-    }
-}
-use b::c;
-
-fn test() {
-    let x = a::A::thing();
-    let y = b::B::thing();
-    let z = c::C::thing();
-}
-"#),
-        @r###"
-    55..63 '{ A {} }': A
-    57..61 'A {}': A
-    125..131 '{ 99 }': u32
-    127..129 '99': u32
-    201..209 '{ C {} }': C
-    203..207 'C {}': C
-    240..324 '{     ...g(); }': ()
-    250..251 'x': A
-    254..265 'a::A::thing': fn thing() -> A
-    254..267 'a::A::thing()': A
-    277..278 'y': u32
-    281..292 'b::B::thing': fn thing() -> u32
-    281..294 'b::B::thing()': u32
-    304..305 'z': C
-    308..319 'c::C::thing': fn thing() -> C
-    308..321 'c::C::thing()': C
-    "###
+    check_infer(
+        r#"
+        mod a {
+            struct A;
+            impl A { pub fn thing() -> A { A {} }}
+        }
+
+        mod b {
+            struct B;
+            impl B { pub fn thing() -> u32 { 99 }}
+
+            mod c {
+                struct C;
+                impl C { pub fn thing() -> C { C {} }}
+            }
+        }
+        use b::c;
+
+        fn test() {
+            let x = a::A::thing();
+            let y = b::B::thing();
+            let z = c::C::thing();
+        }
+        "#,
+        expect![[r#"
+            55..63 '{ A {} }': A
+            57..61 'A {}': A
+            125..131 '{ 99 }': u32
+            127..129 '99': u32
+            201..209 '{ C {} }': C
+            203..207 'C {}': C
+            240..324 '{     ...g(); }': ()
+            250..251 'x': A
+            254..265 'a::A::thing': fn thing() -> A
+            254..267 'a::A::thing()': A
+            277..278 'y': u32
+            281..292 'b::B::thing': fn thing() -> u32
+            281..294 'b::B::thing()': u32
+            304..305 'z': C
+            308..319 'c::C::thing': fn thing() -> C
+            308..321 'c::C::thing()': C
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_generics() {
-    assert_snapshot!(
-        infer(r#"
-struct Gen<T> {
-    val: T
-}
-
-impl<T> Gen<T> {
-    pub fn make(val: T) -> Gen<T> {
-        Gen { val }
-    }
-}
-
-fn test() {
-    let a = Gen::make(0u32);
-}
-"#),
-        @r###"
-    63..66 'val': T
-    81..108 '{     ...     }': Gen<T>
-    91..102 'Gen { val }': Gen<T>
-    97..100 'val': T
-    122..154 '{     ...32); }': ()
-    132..133 'a': Gen<u32>
-    136..145 'Gen::make': fn make<u32>(u32) -> Gen<u32>
-    136..151 'Gen::make(0u32)': Gen<u32>
-    146..150 '0u32': u32
-    "###
+    check_infer(
+        r#"
+        struct Gen<T> {
+            val: T
+        }
+
+        impl<T> Gen<T> {
+            pub fn make(val: T) -> Gen<T> {
+                Gen { val }
+            }
+        }
+
+        fn test() {
+            let a = Gen::make(0u32);
+        }
+        "#,
+        expect![[r#"
+            63..66 'val': T
+            81..108 '{     ...     }': Gen<T>
+            91..102 'Gen { val }': Gen<T>
+            97..100 'val': T
+            122..154 '{     ...32); }': ()
+            132..133 'a': Gen<u32>
+            136..145 'Gen::make': fn make<u32>(u32) -> Gen<u32>
+            136..151 'Gen::make(0u32)': Gen<u32>
+            146..150 '0u32': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_generics_without_args() {
-    assert_snapshot!(
-        infer(r#"
-struct Gen<T> {
-    val: T
-}
-
-impl<T> Gen<T> {
-    pub fn make() -> Gen<T> {
-        loop { }
-    }
-}
-
-fn test() {
-    let a = Gen::<u32>::make();
-}
-"#),
-        @r###"
-    75..99 '{     ...     }': Gen<T>
-    85..93 'loop { }': !
-    90..93 '{ }': ()
-    113..148 '{     ...e(); }': ()
-    123..124 'a': Gen<u32>
-    127..143 'Gen::<...::make': fn make<u32>() -> Gen<u32>
-    127..145 'Gen::<...make()': Gen<u32>
-    "###
+    check_infer(
+        r#"
+        struct Gen<T> {
+            val: T
+        }
+
+        impl<T> Gen<T> {
+            pub fn make() -> Gen<T> {
+                loop { }
+            }
+        }
+
+        fn test() {
+            let a = Gen::<u32>::make();
+        }
+        "#,
+        expect![[r#"
+            75..99 '{     ...     }': Gen<T>
+            85..93 'loop { }': !
+            90..93 '{ }': ()
+            113..148 '{     ...e(); }': ()
+            123..124 'a': Gen<u32>
+            127..143 'Gen::<...::make': fn make<u32>() -> Gen<u32>
+            127..145 'Gen::<...make()': Gen<u32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_method_generics_2_type_params_without_args() {
-    assert_snapshot!(
-        infer(r#"
-struct Gen<T, U> {
-    val: T,
-    val2: U,
-}
-
-impl<T> Gen<u32, T> {
-    pub fn make() -> Gen<u32,T> {
-        loop { }
-    }
-}
-
-fn test() {
-    let a = Gen::<u32, u64>::make();
-}
-"#),
-        @r###"
-    101..125 '{     ...     }': Gen<u32, T>
-    111..119 'loop { }': !
-    116..119 '{ }': ()
-    139..179 '{     ...e(); }': ()
-    149..150 'a': Gen<u32, u64>
-    153..174 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
-    153..176 'Gen::<...make()': Gen<u32, u64>
-    "###
+    check_infer(
+        r#"
+        struct Gen<T, U> {
+            val: T,
+            val2: U,
+        }
+
+        impl<T> Gen<u32, T> {
+            pub fn make() -> Gen<u32,T> {
+                loop { }
+            }
+        }
+
+        fn test() {
+            let a = Gen::<u32, u64>::make();
+        }
+        "#,
+        expect![[r#"
+            101..125 '{     ...     }': Gen<u32, T>
+            111..119 'loop { }': !
+            116..119 '{ }': ()
+            139..179 '{     ...e(); }': ()
+            149..150 'a': Gen<u32, u64>
+            153..174 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
+            153..176 'Gen::<...make()': Gen<u32, u64>
+        "#]],
     );
 }
 
@@ -267,416 +267,416 @@ mod foo {
 #[test]
 fn infer_trait_method_simple() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    assert_snapshot!(
-        infer(r#"
-trait Trait1 {
-    fn method(&self) -> u32;
-}
-struct S1;
-impl Trait1 for S1 {}
-trait Trait2 {
-    fn method(&self) -> i128;
-}
-struct S2;
-impl Trait2 for S2 {}
-fn test() {
-    S1.method(); // -> u32
-    S2.method(); // -> i128
-}
-"#),
-        @r###"
-    30..34 'self': &Self
-    109..113 'self': &Self
-    169..227 '{     ...i128 }': ()
-    175..177 'S1': S1
-    175..186 'S1.method()': u32
-    202..204 'S2': S2
-    202..213 'S2.method()': i128
-    "###
+    check_infer(
+        r#"
+        trait Trait1 {
+            fn method(&self) -> u32;
+        }
+        struct S1;
+        impl Trait1 for S1 {}
+        trait Trait2 {
+            fn method(&self) -> i128;
+        }
+        struct S2;
+        impl Trait2 for S2 {}
+        fn test() {
+            S1.method(); // -> u32
+            S2.method(); // -> i128
+        }
+        "#,
+        expect![[r#"
+            30..34 'self': &Self
+            109..113 'self': &Self
+            169..227 '{     ...i128 }': ()
+            175..177 'S1': S1
+            175..186 'S1.method()': u32
+            202..204 'S2': S2
+            202..213 'S2.method()': i128
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_scoped() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    assert_snapshot!(
-        infer(r#"
-struct S;
-mod foo {
-    pub trait Trait1 {
-        fn method(&self) -> u32;
-    }
-    impl Trait1 for super::S {}
-}
-mod bar {
-    pub trait Trait2 {
-        fn method(&self) -> i128;
-    }
-    impl Trait2 for super::S {}
-}
-
-mod foo_test {
-    use super::S;
-    use super::foo::Trait1;
-    fn test() {
-        S.method(); // -> u32
-    }
-}
-
-mod bar_test {
-    use super::S;
-    use super::bar::Trait2;
-    fn test() {
-        S.method(); // -> i128
-    }
-}
-"#),
-        @r###"
-    62..66 'self': &Self
-    168..172 'self': &Self
-    299..336 '{     ...     }': ()
-    309..310 'S': S
-    309..319 'S.method()': u32
-    415..453 '{     ...     }': ()
-    425..426 'S': S
-    425..435 'S.method()': i128
-    "###
+    check_infer(
+        r#"
+        struct S;
+        mod foo {
+            pub trait Trait1 {
+                fn method(&self) -> u32;
+            }
+            impl Trait1 for super::S {}
+        }
+        mod bar {
+            pub trait Trait2 {
+                fn method(&self) -> i128;
+            }
+            impl Trait2 for super::S {}
+        }
+
+        mod foo_test {
+            use super::S;
+            use super::foo::Trait1;
+            fn test() {
+                S.method(); // -> u32
+            }
+        }
+
+        mod bar_test {
+            use super::S;
+            use super::bar::Trait2;
+            fn test() {
+                S.method(); // -> i128
+            }
+        }
+        "#,
+        expect![[r#"
+            62..66 'self': &Self
+            168..172 'self': &Self
+            299..336 '{     ...     }': ()
+            309..310 'S': S
+            309..319 'S.method()': u32
+            415..453 '{     ...     }': ()
+            425..426 'S': S
+            425..435 'S.method()': i128
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_1() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn method(&self) -> T;
-}
-struct S;
-impl Trait<u32> for S {}
-fn test() {
-    S.method();
-}
-"#),
-        @r###"
-    32..36 'self': &Self
-    91..110 '{     ...d(); }': ()
-    97..98 'S': S
-    97..107 'S.method()': u32
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn method(&self) -> T;
+        }
+        struct S;
+        impl Trait<u32> for S {}
+        fn test() {
+            S.method();
+        }
+        "#,
+        expect![[r#"
+            32..36 'self': &Self
+            91..110 '{     ...d(); }': ()
+            97..98 'S': S
+            97..107 'S.method()': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_more_params() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T1, T2, T3> {
-    fn method1(&self) -> (T1, T2, T3);
-    fn method2(&self) -> (T3, T2, T1);
-}
-struct S1;
-impl Trait<u8, u16, u32> for S1 {}
-struct S2;
-impl<T> Trait<i8, i16, T> for S2 {}
-fn test() {
-    S1.method1(); // u8, u16, u32
-    S1.method2(); // u32, u16, u8
-    S2.method1(); // i8, i16, {unknown}
-    S2.method2(); // {unknown}, i16, i8
-}
-"#),
-        @r###"
-    42..46 'self': &Self
-    81..85 'self': &Self
-    209..360 '{     ..., i8 }': ()
-    215..217 'S1': S1
-    215..227 'S1.method1()': (u8, u16, u32)
-    249..251 'S1': S1
-    249..261 'S1.method2()': (u32, u16, u8)
-    283..285 'S2': S2
-    283..295 'S2.method1()': (i8, i16, {unknown})
-    323..325 'S2': S2
-    323..335 'S2.method2()': ({unknown}, i16, i8)
-    "###
+    check_infer(
+        r#"
+        trait Trait<T1, T2, T3> {
+            fn method1(&self) -> (T1, T2, T3);
+            fn method2(&self) -> (T3, T2, T1);
+        }
+        struct S1;
+        impl Trait<u8, u16, u32> for S1 {}
+        struct S2;
+        impl<T> Trait<i8, i16, T> for S2 {}
+        fn test() {
+            S1.method1(); // u8, u16, u32
+            S1.method2(); // u32, u16, u8
+            S2.method1(); // i8, i16, {unknown}
+            S2.method2(); // {unknown}, i16, i8
+        }
+        "#,
+        expect![[r#"
+            42..46 'self': &Self
+            81..85 'self': &Self
+            209..360 '{     ..., i8 }': ()
+            215..217 'S1': S1
+            215..227 'S1.method1()': (u8, u16, u32)
+            249..251 'S1': S1
+            249..261 'S1.method2()': (u32, u16, u8)
+            283..285 'S2': S2
+            283..295 'S2.method1()': (i8, i16, {unknown})
+            323..325 'S2': S2
+            323..335 'S2.method2()': ({unknown}, i16, i8)
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_method_generic_2() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn method(&self) -> T;
-}
-struct S<T>(T);
-impl<U> Trait<U> for S<U> {}
-fn test() {
-    S(1u32).method();
-}
-"#),
-        @r###"
-    32..36 'self': &Self
-    101..126 '{     ...d(); }': ()
-    107..108 'S': S<u32>(u32) -> S<u32>
-    107..114 'S(1u32)': S<u32>
-    107..123 'S(1u32...thod()': u32
-    109..113 '1u32': u32
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn method(&self) -> T;
+        }
+        struct S<T>(T);
+        impl<U> Trait<U> for S<U> {}
+        fn test() {
+            S(1u32).method();
+        }
+        "#,
+        expect![[r#"
+            32..36 'self': &Self
+            101..126 '{     ...d(); }': ()
+            107..108 'S': S<u32>(u32) -> S<u32>
+            107..114 'S(1u32)': S<u32>
+            107..123 'S(1u32...thod()': u32
+            109..113 '1u32': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method() {
-    assert_snapshot!(
-        infer(r#"
-trait Default {
-    fn default() -> Self;
-}
-struct S;
-impl Default for S {}
-fn test() {
-    let s1: S = Default::default();
-    let s2 = S::default();
-    let s3 = <S as Default>::default();
-}
-"#),
-        @r###"
-    86..192 '{     ...t(); }': ()
-    96..98 's1': S
-    104..120 'Defaul...efault': fn default<S>() -> S
-    104..122 'Defaul...ault()': S
-    132..134 's2': S
-    137..147 'S::default': fn default<S>() -> S
-    137..149 'S::default()': S
-    159..161 's3': S
-    164..187 '<S as ...efault': fn default<S>() -> S
-    164..189 '<S as ...ault()': S
-    "###
+    check_infer(
+        r#"
+        trait Default {
+            fn default() -> Self;
+        }
+        struct S;
+        impl Default for S {}
+        fn test() {
+            let s1: S = Default::default();
+            let s2 = S::default();
+            let s3 = <S as Default>::default();
+        }
+        "#,
+        expect![[r#"
+            86..192 '{     ...t(); }': ()
+            96..98 's1': S
+            104..120 'Defaul...efault': fn default<S>() -> S
+            104..122 'Defaul...ault()': S
+            132..134 's2': S
+            137..147 'S::default': fn default<S>() -> S
+            137..149 'S::default()': S
+            159..161 's3': S
+            164..187 '<S as ...efault': fn default<S>() -> S
+            164..189 '<S as ...ault()': S
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method_generics_1() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn make() -> T;
-}
-struct S;
-impl Trait<u32> for S {}
-struct G<T>;
-impl<T> Trait<T> for G<T> {}
-fn test() {
-    let a = S::make();
-    let b = G::<u64>::make();
-    let c: f64 = G::make();
-}
-"#),
-        @r###"
-    126..210 '{     ...e(); }': ()
-    136..137 'a': u32
-    140..147 'S::make': fn make<S, u32>() -> u32
-    140..149 'S::make()': u32
-    159..160 'b': u64
-    163..177 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
-    163..179 'G::<u6...make()': u64
-    189..190 'c': f64
-    198..205 'G::make': fn make<G<f64>, f64>() -> f64
-    198..207 'G::make()': f64
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn make() -> T;
+        }
+        struct S;
+        impl Trait<u32> for S {}
+        struct G<T>;
+        impl<T> Trait<T> for G<T> {}
+        fn test() {
+            let a = S::make();
+            let b = G::<u64>::make();
+            let c: f64 = G::make();
+        }
+        "#,
+        expect![[r#"
+            126..210 '{     ...e(); }': ()
+            136..137 'a': u32
+            140..147 'S::make': fn make<S, u32>() -> u32
+            140..149 'S::make()': u32
+            159..160 'b': u64
+            163..177 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
+            163..179 'G::<u6...make()': u64
+            189..190 'c': f64
+            198..205 'G::make': fn make<G<f64>, f64>() -> f64
+            198..207 'G::make()': f64
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method_generics_2() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn make<U>() -> (T, U);
-}
-struct S;
-impl Trait<u32> for S {}
-struct G<T>;
-impl<T> Trait<T> for G<T> {}
-fn test() {
-    let a = S::make::<i64>();
-    let b: (_, i64) = S::make();
-    let c = G::<u32>::make::<i64>();
-    let d: (u32, _) = G::make::<i64>();
-    let e: (u32, i64) = G::make();
-}
-"#),
-        @r###"
-    134..312 '{     ...e(); }': ()
-    144..145 'a': (u32, i64)
-    148..162 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
-    148..164 'S::mak...i64>()': (u32, i64)
-    174..175 'b': (u32, i64)
-    188..195 'S::make': fn make<S, u32, i64>() -> (u32, i64)
-    188..197 'S::make()': (u32, i64)
-    207..208 'c': (u32, i64)
-    211..232 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    211..234 'G::<u3...i64>()': (u32, i64)
-    244..245 'd': (u32, i64)
-    258..272 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    258..274 'G::mak...i64>()': (u32, i64)
-    284..285 'e': (u32, i64)
-    300..307 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    300..309 'G::make()': (u32, i64)
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn make<U>() -> (T, U);
+        }
+        struct S;
+        impl Trait<u32> for S {}
+        struct G<T>;
+        impl<T> Trait<T> for G<T> {}
+        fn test() {
+            let a = S::make::<i64>();
+            let b: (_, i64) = S::make();
+            let c = G::<u32>::make::<i64>();
+            let d: (u32, _) = G::make::<i64>();
+            let e: (u32, i64) = G::make();
+        }
+        "#,
+        expect![[r#"
+            134..312 '{     ...e(); }': ()
+            144..145 'a': (u32, i64)
+            148..162 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
+            148..164 'S::mak...i64>()': (u32, i64)
+            174..175 'b': (u32, i64)
+            188..195 'S::make': fn make<S, u32, i64>() -> (u32, i64)
+            188..197 'S::make()': (u32, i64)
+            207..208 'c': (u32, i64)
+            211..232 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
+            211..234 'G::<u3...i64>()': (u32, i64)
+            244..245 'd': (u32, i64)
+            258..272 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
+            258..274 'G::mak...i64>()': (u32, i64)
+            284..285 'e': (u32, i64)
+            300..307 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
+            300..309 'G::make()': (u32, i64)
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method_generics_3() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn make() -> (Self, T);
-}
-struct S<T>;
-impl Trait<i64> for S<i32> {}
-fn test() {
-    let a = S::make();
-}
-"#),
-        @r###"
-    100..126 '{     ...e(); }': ()
-    110..111 'a': (S<i32>, i64)
-    114..121 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
-    114..123 'S::make()': (S<i32>, i64)
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn make() -> (Self, T);
+        }
+        struct S<T>;
+        impl Trait<i64> for S<i32> {}
+        fn test() {
+            let a = S::make();
+        }
+        "#,
+        expect![[r#"
+            100..126 '{     ...e(); }': ()
+            110..111 'a': (S<i32>, i64)
+            114..121 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
+            114..123 'S::make()': (S<i32>, i64)
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method_generics_4() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn make() -> (Self, T);
-}
-struct S<T>;
-impl Trait<i64> for S<u64> {}
-impl Trait<i32> for S<u32> {}
-fn test() {
-    let a: (S<u64>, _) = S::make();
-    let b: (_, i32) = S::make();
-}
-"#),
-        @r###"
-    130..202 '{     ...e(); }': ()
-    140..141 'a': (S<u64>, i64)
-    157..164 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
-    157..166 'S::make()': (S<u64>, i64)
-    176..177 'b': (S<u32>, i32)
-    190..197 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
-    190..199 'S::make()': (S<u32>, i32)
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn make() -> (Self, T);
+        }
+        struct S<T>;
+        impl Trait<i64> for S<u64> {}
+        impl Trait<i32> for S<u32> {}
+        fn test() {
+            let a: (S<u64>, _) = S::make();
+            let b: (_, i32) = S::make();
+        }
+        "#,
+        expect![[r#"
+            130..202 '{     ...e(); }': ()
+            140..141 'a': (S<u64>, i64)
+            157..164 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
+            157..166 'S::make()': (S<u64>, i64)
+            176..177 'b': (S<u32>, i32)
+            190..197 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
+            190..199 'S::make()': (S<u32>, i32)
+        "#]],
     );
 }
 
 #[test]
 fn infer_trait_assoc_method_generics_5() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn make<U>() -> (Self, T, U);
-}
-struct S<T>;
-impl Trait<i64> for S<u64> {}
-fn test() {
-    let a = <S as Trait<i64>>::make::<u8>();
-    let b: (S<u64>, _, _) = Trait::<i64>::make::<u8>();
-}
-"#),
-        @r###"
-    106..210 '{     ...>(); }': ()
-    116..117 'a': (S<u64>, i64, u8)
-    120..149 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-    120..151 '<S as ...<u8>()': (S<u64>, i64, u8)
-    161..162 'b': (S<u64>, i64, u8)
-    181..205 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-    181..207 'Trait:...<u8>()': (S<u64>, i64, u8)
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn make<U>() -> (Self, T, U);
+        }
+        struct S<T>;
+        impl Trait<i64> for S<u64> {}
+        fn test() {
+            let a = <S as Trait<i64>>::make::<u8>();
+            let b: (S<u64>, _, _) = Trait::<i64>::make::<u8>();
+        }
+        "#,
+        expect![[r#"
+            106..210 '{     ...>(); }': ()
+            116..117 'a': (S<u64>, i64, u8)
+            120..149 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+            120..151 '<S as ...<u8>()': (S<u64>, i64, u8)
+            161..162 'b': (S<u64>, i64, u8)
+            181..205 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+            181..207 'Trait:...<u8>()': (S<u64>, i64, u8)
+        "#]],
     );
 }
 
 #[test]
 fn infer_call_trait_method_on_generic_param_1() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait {
-    fn method(&self) -> u32;
-}
-fn test<T: Trait>(t: T) {
-    t.method();
-}
-"#),
-        @r###"
-    29..33 'self': &Self
-    63..64 't': T
-    69..88 '{     ...d(); }': ()
-    75..76 't': T
-    75..85 't.method()': u32
-    "###
+    check_infer(
+        r#"
+        trait Trait {
+            fn method(&self) -> u32;
+        }
+        fn test<T: Trait>(t: T) {
+            t.method();
+        }
+        "#,
+        expect![[r#"
+            29..33 'self': &Self
+            63..64 't': T
+            69..88 '{     ...d(); }': ()
+            75..76 't': T
+            75..85 't.method()': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_call_trait_method_on_generic_param_2() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn method(&self) -> T;
-}
-fn test<U, T: Trait<U>>(t: T) {
-    t.method();
-}
-"#),
-        @r###"
-    32..36 'self': &Self
-    70..71 't': T
-    76..95 '{     ...d(); }': ()
-    82..83 't': T
-    82..92 't.method()': U
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn method(&self) -> T;
+        }
+        fn test<U, T: Trait<U>>(t: T) {
+            t.method();
+        }
+        "#,
+        expect![[r#"
+            32..36 'self': &Self
+            70..71 't': T
+            76..95 '{     ...d(); }': ()
+            82..83 't': T
+            82..92 't.method()': U
+        "#]],
     );
 }
 
 #[test]
 fn infer_with_multiple_trait_impls() {
-    assert_snapshot!(
-        infer(r#"
-trait Into<T> {
-    fn into(self) -> T;
-}
-struct S;
-impl Into<u32> for S {}
-impl Into<u64> for S {}
-fn test() {
-    let x: u32 = S.into();
-    let y: u64 = S.into();
-    let z = Into::<u64>::into(S);
-}
-"#),
-        @r###"
-    28..32 'self': Self
-    110..201 '{     ...(S); }': ()
-    120..121 'x': u32
-    129..130 'S': S
-    129..137 'S.into()': u32
-    147..148 'y': u64
-    156..157 'S': S
-    156..164 'S.into()': u64
-    174..175 'z': u64
-    178..195 'Into::...::into': fn into<S, u64>(S) -> u64
-    178..198 'Into::...nto(S)': u64
-    196..197 'S': S
-    "###
+    check_infer(
+        r#"
+        trait Into<T> {
+            fn into(self) -> T;
+        }
+        struct S;
+        impl Into<u32> for S {}
+        impl Into<u64> for S {}
+        fn test() {
+            let x: u32 = S.into();
+            let y: u64 = S.into();
+            let z = Into::<u64>::into(S);
+        }
+        "#,
+        expect![[r#"
+            28..32 'self': Self
+            110..201 '{     ...(S); }': ()
+            120..121 'x': u32
+            129..130 'S': S
+            129..137 'S.into()': u32
+            147..148 'y': u64
+            156..157 'S': S
+            156..164 'S.into()': u64
+            174..175 'z': u64
+            178..195 'Into::...::into': fn into<S, u64>(S) -> u64
+            178..198 'Into::...nto(S)': u64
+            196..197 'S': S
+        "#]],
     );
 }
 
@@ -1023,31 +1023,31 @@ fn test() { (S {}).method(); }
 
 #[test]
 fn dyn_trait_super_trait_not_in_scope() {
-    assert_snapshot!(
-        infer(r#"
-mod m {
-    pub trait SuperTrait {
-        fn foo(&self) -> u32 { 0 }
-    }
-}
-trait Trait: m::SuperTrait {}
-
-struct S;
-impl m::SuperTrait for S {}
-impl Trait for S {}
-
-fn test(d: &dyn Trait) {
-    d.foo();
-}
-"#),
-        @r###"
-    51..55 'self': &Self
-    64..69 '{ 0 }': u32
-    66..67 '0': u32
-    176..177 'd': &dyn Trait
-    191..207 '{     ...o(); }': ()
-    197..198 'd': &dyn Trait
-    197..204 'd.foo()': u32
-    "###
+    check_infer(
+        r#"
+        mod m {
+            pub trait SuperTrait {
+                fn foo(&self) -> u32 { 0 }
+            }
+        }
+        trait Trait: m::SuperTrait {}
+
+        struct S;
+        impl m::SuperTrait for S {}
+        impl Trait for S {}
+
+        fn test(d: &dyn Trait) {
+            d.foo();
+        }
+        "#,
+        expect![[r#"
+            51..55 'self': &Self
+            64..69 '{ 0 }': u32
+            66..67 '0': u32
+            176..177 'd': &dyn Trait
+            191..207 '{     ...o(); }': ()
+            197..198 'd': &dyn Trait
+            197..204 'd.foo()': u32
+        "#]],
     );
 }
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index f937426bd..39fabf7eb 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -1,561 +1,561 @@
-use insta::assert_snapshot;
+use expect::expect;
 use test_utils::mark;
 
-use super::{infer, infer_with_mismatches};
+use super::{check_infer, check_infer_with_mismatches};
 
 #[test]
 fn infer_pattern() {
-    assert_snapshot!(
-        infer(r#"
-fn test(x: &i32) {
-    let y = x;
-    let &z = x;
-    let a = z;
-    let (c, d) = (1, "hello");
-
-    for (e, f) in some_iter {
-        let g = e;
-    }
-
-    if let [val] = opt {
-        let h = val;
-    }
-
-    let lambda = |a: u64, b, c: i32| { a + b; c };
-
-    let ref ref_to_x = x;
-    let mut mut_x = x;
-    let ref mut mut_ref_to_x = x;
-    let k = mut_ref_to_x;
-}
-"#),
-        @r###"
-    8..9 'x': &i32
-    17..368 '{     ...o_x; }': ()
-    27..28 'y': &i32
-    31..32 'x': &i32
-    42..44 '&z': &i32
-    43..44 'z': i32
-    47..48 'x': &i32
-    58..59 'a': i32
-    62..63 'z': i32
-    73..79 '(c, d)': (i32, &str)
-    74..75 'c': i32
-    77..78 'd': &str
-    82..94 '(1, "hello")': (i32, &str)
-    83..84 '1': i32
-    86..93 '"hello"': &str
-    101..151 'for (e...     }': ()
-    105..111 '(e, f)': ({unknown}, {unknown})
-    106..107 'e': {unknown}
-    109..110 'f': {unknown}
-    115..124 'some_iter': {unknown}
-    125..151 '{     ...     }': ()
-    139..140 'g': {unknown}
-    143..144 'e': {unknown}
-    157..204 'if let...     }': ()
-    164..169 '[val]': [{unknown}]
-    165..168 'val': {unknown}
-    172..175 'opt': [{unknown}]
-    176..204 '{     ...     }': ()
-    190..191 'h': {unknown}
-    194..197 'val': {unknown}
-    214..220 'lambda': |u64, u64, i32| -> i32
-    223..255 '|a: u6...b; c }': |u64, u64, i32| -> i32
-    224..225 'a': u64
-    232..233 'b': u64
-    235..236 'c': i32
-    243..255 '{ a + b; c }': i32
-    245..246 'a': u64
-    245..250 'a + b': u64
-    249..250 'b': u64
-    252..253 'c': i32
-    266..278 'ref ref_to_x': &&i32
-    281..282 'x': &i32
-    292..301 'mut mut_x': &i32
-    304..305 'x': &i32
-    315..335 'ref mu...f_to_x': &mut &i32
-    338..339 'x': &i32
-    349..350 'k': &mut &i32
-    353..365 'mut_ref_to_x': &mut &i32
-    "###
+    check_infer(
+        r#"
+        fn test(x: &i32) {
+            let y = x;
+            let &z = x;
+            let a = z;
+            let (c, d) = (1, "hello");
+
+            for (e, f) in some_iter {
+                let g = e;
+            }
+
+            if let [val] = opt {
+                let h = val;
+            }
+
+            let lambda = |a: u64, b, c: i32| { a + b; c };
+
+            let ref ref_to_x = x;
+            let mut mut_x = x;
+            let ref mut mut_ref_to_x = x;
+            let k = mut_ref_to_x;
+        }
+        "#,
+        expect![[r#"
+            8..9 'x': &i32
+            17..368 '{     ...o_x; }': ()
+            27..28 'y': &i32
+            31..32 'x': &i32
+            42..44 '&z': &i32
+            43..44 'z': i32
+            47..48 'x': &i32
+            58..59 'a': i32
+            62..63 'z': i32
+            73..79 '(c, d)': (i32, &str)
+            74..75 'c': i32
+            77..78 'd': &str
+            82..94 '(1, "hello")': (i32, &str)
+            83..84 '1': i32
+            86..93 '"hello"': &str
+            101..151 'for (e...     }': ()
+            105..111 '(e, f)': ({unknown}, {unknown})
+            106..107 'e': {unknown}
+            109..110 'f': {unknown}
+            115..124 'some_iter': {unknown}
+            125..151 '{     ...     }': ()
+            139..140 'g': {unknown}
+            143..144 'e': {unknown}
+            157..204 'if let...     }': ()
+            164..169 '[val]': [{unknown}]
+            165..168 'val': {unknown}
+            172..175 'opt': [{unknown}]
+            176..204 '{     ...     }': ()
+            190..191 'h': {unknown}
+            194..197 'val': {unknown}
+            214..220 'lambda': |u64, u64, i32| -> i32
+            223..255 '|a: u6...b; c }': |u64, u64, i32| -> i32
+            224..225 'a': u64
+            232..233 'b': u64
+            235..236 'c': i32
+            243..255 '{ a + b; c }': i32
+            245..246 'a': u64
+            245..250 'a + b': u64
+            249..250 'b': u64
+            252..253 'c': i32
+            266..278 'ref ref_to_x': &&i32
+            281..282 'x': &i32
+            292..301 'mut mut_x': &i32
+            304..305 'x': &i32
+            315..335 'ref mu...f_to_x': &mut &i32
+            338..339 'x': &i32
+            349..350 'k': &mut &i32
+            353..365 'mut_ref_to_x': &mut &i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_literal_pattern() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-fn any<T>() -> T { loop {} }
-fn test(x: &i32) {
-    if let "foo" = any() {}
-    if let 1 = any() {}
-    if let 1u32 = any() {}
-    if let 1f32 = any() {}
-    if let 1.0 = any() {}
-    if let true = any() {}
-}
-"#, true),
-        @r###"
-    17..28 '{ loop {} }': T
-    19..26 'loop {}': !
-    24..26 '{}': ()
-    37..38 'x': &i32
-    46..208 '{     ...) {} }': ()
-    52..75 'if let...y() {}': ()
-    59..64 '"foo"': &str
-    59..64 '"foo"': &str
-    67..70 'any': fn any<&str>() -> &str
-    67..72 'any()': &str
-    73..75 '{}': ()
-    80..99 'if let...y() {}': ()
-    87..88 '1': i32
-    87..88 '1': i32
-    91..94 'any': fn any<i32>() -> i32
-    91..96 'any()': i32
-    97..99 '{}': ()
-    104..126 'if let...y() {}': ()
-    111..115 '1u32': u32
-    111..115 '1u32': u32
-    118..121 'any': fn any<u32>() -> u32
-    118..123 'any()': u32
-    124..126 '{}': ()
-    131..153 'if let...y() {}': ()
-    138..142 '1f32': f32
-    138..142 '1f32': f32
-    145..148 'any': fn any<f32>() -> f32
-    145..150 'any()': f32
-    151..153 '{}': ()
-    158..179 'if let...y() {}': ()
-    165..168 '1.0': f64
-    165..168 '1.0': f64
-    171..174 'any': fn any<f64>() -> f64
-    171..176 'any()': f64
-    177..179 '{}': ()
-    184..206 'if let...y() {}': ()
-    191..195 'true': bool
-    191..195 'true': bool
-    198..201 'any': fn any<bool>() -> bool
-    198..203 'any()': bool
-    204..206 '{}': ()
-    "###
+    check_infer_with_mismatches(
+        r#"
+        fn any<T>() -> T { loop {} }
+        fn test(x: &i32) {
+            if let "foo" = any() {}
+            if let 1 = any() {}
+            if let 1u32 = any() {}
+            if let 1f32 = any() {}
+            if let 1.0 = any() {}
+            if let true = any() {}
+        }
+        "#,
+        expect![[r#"
+            17..28 '{ loop {} }': T
+            19..26 'loop {}': !
+            24..26 '{}': ()
+            37..38 'x': &i32
+            46..208 '{     ...) {} }': ()
+            52..75 'if let...y() {}': ()
+            59..64 '"foo"': &str
+            59..64 '"foo"': &str
+            67..70 'any': fn any<&str>() -> &str
+            67..72 'any()': &str
+            73..75 '{}': ()
+            80..99 'if let...y() {}': ()
+            87..88 '1': i32
+            87..88 '1': i32
+            91..94 'any': fn any<i32>() -> i32
+            91..96 'any()': i32
+            97..99 '{}': ()
+            104..126 'if let...y() {}': ()
+            111..115 '1u32': u32
+            111..115 '1u32': u32
+            118..121 'any': fn any<u32>() -> u32
+            118..123 'any()': u32
+            124..126 '{}': ()
+            131..153 'if let...y() {}': ()
+            138..142 '1f32': f32
+            138..142 '1f32': f32
+            145..148 'any': fn any<f32>() -> f32
+            145..150 'any()': f32
+            151..153 '{}': ()
+            158..179 'if let...y() {}': ()
+            165..168 '1.0': f64
+            165..168 '1.0': f64
+            171..174 'any': fn any<f64>() -> f64
+            171..176 'any()': f64
+            177..179 '{}': ()
+            184..206 'if let...y() {}': ()
+            191..195 'true': bool
+            191..195 'true': bool
+            198..201 'any': fn any<bool>() -> bool
+            198..203 'any()': bool
+            204..206 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_range_pattern() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-fn test(x: &i32) {
-    if let 1..76 = 2u32 {}
-    if let 1..=76 = 2u32 {}
-}
-"#, true),
-        @r###"
-    8..9 'x': &i32
-    17..75 '{     ...2 {} }': ()
-    23..45 'if let...u32 {}': ()
-    30..35 '1..76': u32
-    38..42 '2u32': u32
-    43..45 '{}': ()
-    50..73 'if let...u32 {}': ()
-    57..63 '1..=76': u32
-    66..70 '2u32': u32
-    71..73 '{}': ()
-    "###
+    check_infer_with_mismatches(
+        r#"
+        fn test(x: &i32) {
+            if let 1..76 = 2u32 {}
+            if let 1..=76 = 2u32 {}
+        }
+        "#,
+        expect![[r#"
+            8..9 'x': &i32
+            17..75 '{     ...2 {} }': ()
+            23..45 'if let...u32 {}': ()
+            30..35 '1..76': u32
+            38..42 '2u32': u32
+            43..45 '{}': ()
+            50..73 'if let...u32 {}': ()
+            57..63 '1..=76': u32
+            66..70 '2u32': u32
+            71..73 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_ergonomics() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T>(T);
+    check_infer(
+        r#"
+        struct A<T>(T);
 
-fn test() {
-    let A(n) = &A(1);
-    let A(n) = &mut A(1);
-}
-"#),
-    @r###"
-    27..78 '{     ...(1); }': ()
-    37..41 'A(n)': A<i32>
-    39..40 'n': &i32
-    44..49 '&A(1)': &A<i32>
-    45..46 'A': A<i32>(i32) -> A<i32>
-    45..49 'A(1)': A<i32>
-    47..48 '1': i32
-    59..63 'A(n)': A<i32>
-    61..62 'n': &mut i32
-    66..75 '&mut A(1)': &mut A<i32>
-    71..72 'A': A<i32>(i32) -> A<i32>
-    71..75 'A(1)': A<i32>
-    73..74 '1': i32
-    "###
+        fn test() {
+            let A(n) = &A(1);
+            let A(n) = &mut A(1);
+        }
+        "#,
+        expect![[r#"
+            27..78 '{     ...(1); }': ()
+            37..41 'A(n)': A<i32>
+            39..40 'n': &i32
+            44..49 '&A(1)': &A<i32>
+            45..46 'A': A<i32>(i32) -> A<i32>
+            45..49 'A(1)': A<i32>
+            47..48 '1': i32
+            59..63 'A(n)': A<i32>
+            61..62 'n': &mut i32
+            66..75 '&mut A(1)': &mut A<i32>
+            71..72 'A': A<i32>(i32) -> A<i32>
+            71..75 'A(1)': A<i32>
+            73..74 '1': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_ergonomics_ref() {
     mark::check!(match_ergonomics_ref);
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let v = &(1, &2);
-    let (_, &w) = v;
-}
-"#),
-    @r###"
-    10..56 '{     ...= v; }': ()
-    20..21 'v': &(i32, &i32)
-    24..32 '&(1, &2)': &(i32, &i32)
-    25..32 '(1, &2)': (i32, &i32)
-    26..27 '1': i32
-    29..31 '&2': &i32
-    30..31 '2': i32
-    42..49 '(_, &w)': (i32, &i32)
-    43..44 '_': i32
-    46..48 '&w': &i32
-    47..48 'w': i32
-    52..53 'v': &(i32, &i32)
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            let v = &(1, &2);
+            let (_, &w) = v;
+        }
+        "#,
+        expect![[r#"
+            10..56 '{     ...= v; }': ()
+            20..21 'v': &(i32, &i32)
+            24..32 '&(1, &2)': &(i32, &i32)
+            25..32 '(1, &2)': (i32, &i32)
+            26..27 '1': i32
+            29..31 '&2': &i32
+            30..31 '2': i32
+            42..49 '(_, &w)': (i32, &i32)
+            43..44 '_': i32
+            46..48 '&w': &i32
+            47..48 'w': i32
+            52..53 'v': &(i32, &i32)
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_slice() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let slice: &[f64] = &[0.0];
-    match slice {
-        &[] => {},
-        &[a] => {
-            a;
-        },
-        &[b, c] => {
-            b;
-            c;
+    check_infer(
+        r#"
+        fn test() {
+            let slice: &[f64] = &[0.0];
+            match slice {
+                &[] => {},
+                &[a] => {
+                    a;
+                },
+                &[b, c] => {
+                    b;
+                    c;
+                }
+                _ => {}
+            }
         }
-        _ => {}
-    }
-}
-"#),
-    @r###"
-    10..209 '{     ...   } }': ()
-    20..25 'slice': &[f64]
-    36..42 '&[0.0]': &[f64; _]
-    37..42 '[0.0]': [f64; _]
-    38..41 '0.0': f64
-    48..207 'match ...     }': ()
-    54..59 'slice': &[f64]
-    70..73 '&[]': &[f64]
-    71..73 '[]': [f64]
-    77..79 '{}': ()
-    89..93 '&[a]': &[f64]
-    90..93 '[a]': [f64]
-    91..92 'a': f64
-    97..123 '{     ...     }': ()
-    111..112 'a': f64
-    133..140 '&[b, c]': &[f64]
-    134..140 '[b, c]': [f64]
-    135..136 'b': f64
-    138..139 'c': f64
-    144..185 '{     ...     }': ()
-    158..159 'b': f64
-    173..174 'c': f64
-    194..195 '_': &[f64]
-    199..201 '{}': ()
-    "###
+        "#,
+        expect![[r#"
+            10..209 '{     ...   } }': ()
+            20..25 'slice': &[f64]
+            36..42 '&[0.0]': &[f64; _]
+            37..42 '[0.0]': [f64; _]
+            38..41 '0.0': f64
+            48..207 'match ...     }': ()
+            54..59 'slice': &[f64]
+            70..73 '&[]': &[f64]
+            71..73 '[]': [f64]
+            77..79 '{}': ()
+            89..93 '&[a]': &[f64]
+            90..93 '[a]': [f64]
+            91..92 'a': f64
+            97..123 '{     ...     }': ()
+            111..112 'a': f64
+            133..140 '&[b, c]': &[f64]
+            134..140 '[b, c]': [f64]
+            135..136 'b': f64
+            138..139 'c': f64
+            144..185 '{     ...     }': ()
+            158..159 'b': f64
+            173..174 'c': f64
+            194..195 '_': &[f64]
+            199..201 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_string_literal() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-fn test() {
-    let s: &str = "hello";
-    match s {
-        "hello" => {}
-        _ => {}
-    }
-}
-"#, true),
-    @r###"
-    10..98 '{     ...   } }': ()
-    20..21 's': &str
-    30..37 '"hello"': &str
-    43..96 'match ...     }': ()
-    49..50 's': &str
-    61..68 '"hello"': &str
-    61..68 '"hello"': &str
-    72..74 '{}': ()
-    83..84 '_': &str
-    88..90 '{}': ()
-    "###
+    check_infer_with_mismatches(
+        r#"
+        fn test() {
+            let s: &str = "hello";
+            match s {
+                "hello" => {}
+                _ => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            10..98 '{     ...   } }': ()
+            20..21 's': &str
+            30..37 '"hello"': &str
+            43..96 'match ...     }': ()
+            49..50 's': &str
+            61..68 '"hello"': &str
+            61..68 '"hello"': &str
+            72..74 '{}': ()
+            83..84 '_': &str
+            88..90 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_or() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-fn test() {
-    let s: &str = "hello";
-    match s {
-        "hello" | "world" => {}
-        _ => {}
-    }
-}
-"#, true),
-    @r###"
-    10..108 '{     ...   } }': ()
-    20..21 's': &str
-    30..37 '"hello"': &str
-    43..106 'match ...     }': ()
-    49..50 's': &str
-    61..68 '"hello"': &str
-    61..68 '"hello"': &str
-    61..78 '"hello...world"': &str
-    71..78 '"world"': &str
-    71..78 '"world"': &str
-    82..84 '{}': ()
-    93..94 '_': &str
-    98..100 '{}': ()
-    "###
+    check_infer_with_mismatches(
+        r#"
+        fn test() {
+            let s: &str = "hello";
+            match s {
+                "hello" | "world" => {}
+                _ => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            10..108 '{     ...   } }': ()
+            20..21 's': &str
+            30..37 '"hello"': &str
+            43..106 'match ...     }': ()
+            49..50 's': &str
+            61..68 '"hello"': &str
+            61..68 '"hello"': &str
+            61..78 '"hello...world"': &str
+            71..78 '"world"': &str
+            71..78 '"world"': &str
+            82..84 '{}': ()
+            93..94 '_': &str
+            98..100 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_pattern_match_arr() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let arr: [f64; 2] = [0.0, 1.0];
-    match arr {
-        [1.0, a] => {
-            a;
-        },
-        [b, c] => {
-            b;
-            c;
+    check_infer(
+        r#"
+        fn test() {
+            let arr: [f64; 2] = [0.0, 1.0];
+            match arr {
+                [1.0, a] => {
+                    a;
+                },
+                [b, c] => {
+                    b;
+                    c;
+                }
+            }
         }
-    }
-}
-"#),
-    @r###"
-    10..179 '{     ...   } }': ()
-    20..23 'arr': [f64; _]
-    36..46 '[0.0, 1.0]': [f64; _]
-    37..40 '0.0': f64
-    42..45 '1.0': f64
-    52..177 'match ...     }': ()
-    58..61 'arr': [f64; _]
-    72..80 '[1.0, a]': [f64; _]
-    73..76 '1.0': f64
-    73..76 '1.0': f64
-    78..79 'a': f64
-    84..110 '{     ...     }': ()
-    98..99 'a': f64
-    120..126 '[b, c]': [f64; _]
-    121..122 'b': f64
-    124..125 'c': f64
-    130..171 '{     ...     }': ()
-    144..145 'b': f64
-    159..160 'c': f64
-    "###
+        "#,
+        expect![[r#"
+            10..179 '{     ...   } }': ()
+            20..23 'arr': [f64; _]
+            36..46 '[0.0, 1.0]': [f64; _]
+            37..40 '0.0': f64
+            42..45 '1.0': f64
+            52..177 'match ...     }': ()
+            58..61 'arr': [f64; _]
+            72..80 '[1.0, a]': [f64; _]
+            73..76 '1.0': f64
+            73..76 '1.0': f64
+            78..79 'a': f64
+            84..110 '{     ...     }': ()
+            98..99 'a': f64
+            120..126 '[b, c]': [f64; _]
+            121..122 'b': f64
+            124..125 'c': f64
+            130..171 '{     ...     }': ()
+            144..145 'b': f64
+            159..160 'c': f64
+        "#]],
     );
 }
 
 #[test]
 fn infer_adt_pattern() {
-    assert_snapshot!(
-        infer(r#"
-enum E {
-    A { x: usize },
-    B
-}
+    check_infer(
+        r#"
+        enum E {
+            A { x: usize },
+            B
+        }
 
-struct S(u32, E);
+        struct S(u32, E);
 
-fn test() {
-    let e = E::A { x: 3 };
+        fn test() {
+            let e = E::A { x: 3 };
 
-    let S(y, z) = foo;
-    let E::A { x: new_var } = e;
+            let S(y, z) = foo;
+            let E::A { x: new_var } = e;
 
-    match e {
-        E::A { x } => x,
-        E::B if foo => 1,
-        E::B => 10,
-    };
+            match e {
+                E::A { x } => x,
+                E::B if foo => 1,
+                E::B => 10,
+            };
 
-    let ref d @ E::A { .. } = e;
-    d;
-}
-"#),
-        @r###"
-    67..288 '{     ...  d; }': ()
-    77..78 'e': E
-    81..94 'E::A { x: 3 }': E
-    91..92 '3': usize
-    105..112 'S(y, z)': S
-    107..108 'y': u32
-    110..111 'z': E
-    115..118 'foo': S
-    128..147 'E::A {..._var }': E
-    138..145 'new_var': usize
-    150..151 'e': E
-    158..244 'match ...     }': usize
-    164..165 'e': E
-    176..186 'E::A { x }': E
-    183..184 'x': usize
-    190..191 'x': usize
-    201..205 'E::B': E
-    209..212 'foo': bool
-    216..217 '1': usize
-    227..231 'E::B': E
-    235..237 '10': usize
-    255..274 'ref d ...{ .. }': &E
-    263..274 'E::A { .. }': E
-    277..278 'e': E
-    284..285 'd': &E
-    "###
+            let ref d @ E::A { .. } = e;
+            d;
+        }
+        "#,
+        expect![[r#"
+            67..288 '{     ...  d; }': ()
+            77..78 'e': E
+            81..94 'E::A { x: 3 }': E
+            91..92 '3': usize
+            105..112 'S(y, z)': S
+            107..108 'y': u32
+            110..111 'z': E
+            115..118 'foo': S
+            128..147 'E::A {..._var }': E
+            138..145 'new_var': usize
+            150..151 'e': E
+            158..244 'match ...     }': usize
+            164..165 'e': E
+            176..186 'E::A { x }': E
+            183..184 'x': usize
+            190..191 'x': usize
+            201..205 'E::B': E
+            209..212 'foo': bool
+            216..217 '1': usize
+            227..231 'E::B': E
+            235..237 '10': usize
+            255..274 'ref d ...{ .. }': &E
+            263..274 'E::A { .. }': E
+            277..278 'e': E
+            284..285 'd': &E
+        "#]],
     );
 }
 
 #[test]
 fn enum_variant_through_self_in_pattern() {
-    assert_snapshot!(
-        infer(r#"
-enum E {
-    A { x: usize },
-    B(usize),
-    C
-}
+    check_infer(
+        r#"
+        enum E {
+            A { x: usize },
+            B(usize),
+            C
+        }
 
-impl E {
-    fn test() {
-        match (loop {}) {
-            Self::A { x } => { x; },
-            Self::B(x) => { x; },
-            Self::C => {},
-        };
-    }
-}
-"#),
-        @r###"
-    75..217 '{     ...     }': ()
-    85..210 'match ...     }': ()
-    92..99 'loop {}': !
-    97..99 '{}': ()
-    115..128 'Self::A { x }': E
-    125..126 'x': usize
-    132..138 '{ x; }': ()
-    134..135 'x': usize
-    152..162 'Self::B(x)': E
-    160..161 'x': usize
-    166..172 '{ x; }': ()
-    168..169 'x': usize
-    186..193 'Self::C': E
-    197..199 '{}': ()
-    "###
+        impl E {
+            fn test() {
+                match (loop {}) {
+                    Self::A { x } => { x; },
+                    Self::B(x) => { x; },
+                    Self::C => {},
+                };
+            }
+        }
+        "#,
+        expect![[r#"
+            75..217 '{     ...     }': ()
+            85..210 'match ...     }': ()
+            92..99 'loop {}': !
+            97..99 '{}': ()
+            115..128 'Self::A { x }': E
+            125..126 'x': usize
+            132..138 '{ x; }': ()
+            134..135 'x': usize
+            152..162 'Self::B(x)': E
+            160..161 'x': usize
+            166..172 '{ x; }': ()
+            168..169 'x': usize
+            186..193 'Self::C': E
+            197..199 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_generics_in_patterns() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T> {
-    x: T,
-}
+    check_infer(
+        r#"
+        struct A<T> {
+            x: T,
+        }
 
-enum Option<T> {
-    Some(T),
-    None,
-}
+        enum Option<T> {
+            Some(T),
+            None,
+        }
 
-fn test(a1: A<u32>, o: Option<u64>) {
-    let A { x: x2 } = a1;
-    let A::<i64> { x: x3 } = A { x: 1 };
-    match o {
-        Option::Some(t) => t,
-        _ => 1,
-    };
-}
-"#),
-        @r###"
-    78..80 'a1': A<u32>
-    90..91 'o': Option<u64>
-    106..243 '{     ...  }; }': ()
-    116..127 'A { x: x2 }': A<u32>
-    123..125 'x2': u32
-    130..132 'a1': A<u32>
-    142..160 'A::<i6...: x3 }': A<i64>
-    156..158 'x3': i64
-    163..173 'A { x: 1 }': A<i64>
-    170..171 '1': i64
-    179..240 'match ...     }': u64
-    185..186 'o': Option<u64>
-    197..212 'Option::Some(t)': Option<u64>
-    210..211 't': u64
-    216..217 't': u64
-    227..228 '_': Option<u64>
-    232..233 '1': u64
-    "###
+        fn test(a1: A<u32>, o: Option<u64>) {
+            let A { x: x2 } = a1;
+            let A::<i64> { x: x3 } = A { x: 1 };
+            match o {
+                Option::Some(t) => t,
+                _ => 1,
+            };
+        }
+        "#,
+        expect![[r#"
+            78..80 'a1': A<u32>
+            90..91 'o': Option<u64>
+            106..243 '{     ...  }; }': ()
+            116..127 'A { x: x2 }': A<u32>
+            123..125 'x2': u32
+            130..132 'a1': A<u32>
+            142..160 'A::<i6...: x3 }': A<i64>
+            156..158 'x3': i64
+            163..173 'A { x: 1 }': A<i64>
+            170..171 '1': i64
+            179..240 'match ...     }': u64
+            185..186 'o': Option<u64>
+            197..212 'Option::Some(t)': Option<u64>
+            210..211 't': u64
+            216..217 't': u64
+            227..228 '_': Option<u64>
+            232..233 '1': u64
+        "#]],
     );
 }
 
 #[test]
 fn infer_const_pattern() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-enum Option<T> { None }
-use Option::None;
-struct Foo;
-const Bar: usize = 1;
-
-fn test() {
-    let a: Option<u32> = None;
-    let b: Option<i64> = match a {
-        None => None,
-    };
-    let _: () = match () { Foo => Foo }; // Expected mismatch
-    let _: () = match () { Bar => Bar }; // Expected mismatch
-}
-"#, true),
-        @r###"
-    73..74 '1': usize
-    87..309 '{     ...atch }': ()
-    97..98 'a': Option<u32>
-    114..118 'None': Option<u32>
-    128..129 'b': Option<i64>
-    145..182 'match ...     }': Option<i64>
-    151..152 'a': Option<u32>
-    163..167 'None': Option<u32>
-    171..175 'None': Option<i64>
-    192..193 '_': ()
-    200..223 'match ... Foo }': Foo
-    206..208 '()': ()
-    211..214 'Foo': Foo
-    218..221 'Foo': Foo
-    254..255 '_': ()
-    262..285 'match ... Bar }': usize
-    268..270 '()': ()
-    273..276 'Bar': usize
-    280..283 'Bar': usize
-    200..223: expected (), got Foo
-    262..285: expected (), got usize
-    "###
+    check_infer_with_mismatches(
+        r#"
+        enum Option<T> { None }
+        use Option::None;
+        struct Foo;
+        const Bar: usize = 1;
+
+        fn test() {
+            let a: Option<u32> = None;
+            let b: Option<i64> = match a {
+                None => None,
+            };
+            let _: () = match () { Foo => Foo }; // Expected mismatch
+            let _: () = match () { Bar => Bar }; // Expected mismatch
+        }
+        "#,
+        expect![[r#"
+            73..74 '1': usize
+            87..309 '{     ...atch }': ()
+            97..98 'a': Option<u32>
+            114..118 'None': Option<u32>
+            128..129 'b': Option<i64>
+            145..182 'match ...     }': Option<i64>
+            151..152 'a': Option<u32>
+            163..167 'None': Option<u32>
+            171..175 'None': Option<i64>
+            192..193 '_': ()
+            200..223 'match ... Foo }': Foo
+            206..208 '()': ()
+            211..214 'Foo': Foo
+            218..221 'Foo': Foo
+            254..255 '_': ()
+            262..285 'match ... Bar }': usize
+            268..270 '()': ()
+            273..276 'Bar': usize
+            280..283 'Bar': usize
+            200..223: expected (), got Foo
+            262..285: expected (), got usize
+        "#]],
     );
 }
 
 #[test]
 fn infer_guard() {
-    assert_snapshot!(
-        infer(r#"
+    check_infer(
+        r#"
 struct S;
 impl S { fn foo(&self) -> bool { false } }
 
@@ -564,91 +564,93 @@ fn main() {
         s if s.foo() => (),
     }
 }
-    "#), @r###"
-    27..31 'self': &S
-    41..50 '{ false }': bool
-    43..48 'false': bool
-    64..115 '{     ...   } }': ()
-    70..113 'match ...     }': ()
-    76..77 'S': S
-    88..89 's': S
-    93..94 's': S
-    93..100 's.foo()': bool
-    104..106 '()': ()
-    "###)
+        "#,
+        expect![[r#"
+            27..31 'self': &S
+            41..50 '{ false }': bool
+            43..48 'false': bool
+            64..115 '{     ...   } }': ()
+            70..113 'match ...     }': ()
+            76..77 'S': S
+            88..89 's': S
+            93..94 's': S
+            93..100 's.foo()': bool
+            104..106 '()': ()
+    "#]],
+    )
 }
 
 #[test]
 fn match_ergonomics_in_closure_params() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "fn_once"]
-trait FnOnce<Args> {
-    type Output;
-}
+    check_infer(
+        r#"
+        #[lang = "fn_once"]
+        trait FnOnce<Args> {
+            type Output;
+        }
 
-fn foo<T, U, F: FnOnce(T) -> U>(t: T, f: F) -> U { loop {} }
+        fn foo<T, U, F: FnOnce(T) -> U>(t: T, f: F) -> U { loop {} }
 
-fn test() {
-    foo(&(1, "a"), |&(x, y)| x); // normal, no match ergonomics
-    foo(&(1, "a"), |(x, y)| x);
-}
-"#),
-        @r###"
-    93..94 't': T
-    99..100 'f': F
-    110..121 '{ loop {} }': U
-    112..119 'loop {}': !
-    117..119 '{}': ()
-    133..232 '{     ... x); }': ()
-    139..142 'foo': fn foo<&(i32, &str), i32, |&(i32, &str)| -> i32>(&(i32, &str), |&(i32, &str)| -> i32) -> i32
-    139..166 'foo(&(...y)| x)': i32
-    143..152 '&(1, "a")': &(i32, &str)
-    144..152 '(1, "a")': (i32, &str)
-    145..146 '1': i32
-    148..151 '"a"': &str
-    154..165 '|&(x, y)| x': |&(i32, &str)| -> i32
-    155..162 '&(x, y)': &(i32, &str)
-    156..162 '(x, y)': (i32, &str)
-    157..158 'x': i32
-    160..161 'y': &str
-    164..165 'x': i32
-    203..206 'foo': fn foo<&(i32, &str), &i32, |&(i32, &str)| -> &i32>(&(i32, &str), |&(i32, &str)| -> &i32) -> &i32
-    203..229 'foo(&(...y)| x)': &i32
-    207..216 '&(1, "a")': &(i32, &str)
-    208..216 '(1, "a")': (i32, &str)
-    209..210 '1': i32
-    212..215 '"a"': &str
-    218..228 '|(x, y)| x': |&(i32, &str)| -> &i32
-    219..225 '(x, y)': (i32, &str)
-    220..221 'x': &i32
-    223..224 'y': &&str
-    227..228 'x': &i32
-    "###
+        fn test() {
+            foo(&(1, "a"), |&(x, y)| x); // normal, no match ergonomics
+            foo(&(1, "a"), |(x, y)| x);
+        }
+        "#,
+        expect![[r#"
+            93..94 't': T
+            99..100 'f': F
+            110..121 '{ loop {} }': U
+            112..119 'loop {}': !
+            117..119 '{}': ()
+            133..232 '{     ... x); }': ()
+            139..142 'foo': fn foo<&(i32, &str), i32, |&(i32, &str)| -> i32>(&(i32, &str), |&(i32, &str)| -> i32) -> i32
+            139..166 'foo(&(...y)| x)': i32
+            143..152 '&(1, "a")': &(i32, &str)
+            144..152 '(1, "a")': (i32, &str)
+            145..146 '1': i32
+            148..151 '"a"': &str
+            154..165 '|&(x, y)| x': |&(i32, &str)| -> i32
+            155..162 '&(x, y)': &(i32, &str)
+            156..162 '(x, y)': (i32, &str)
+            157..158 'x': i32
+            160..161 'y': &str
+            164..165 'x': i32
+            203..206 'foo': fn foo<&(i32, &str), &i32, |&(i32, &str)| -> &i32>(&(i32, &str), |&(i32, &str)| -> &i32) -> &i32
+            203..229 'foo(&(...y)| x)': &i32
+            207..216 '&(1, "a")': &(i32, &str)
+            208..216 '(1, "a")': (i32, &str)
+            209..210 '1': i32
+            212..215 '"a"': &str
+            218..228 '|(x, y)| x': |&(i32, &str)| -> &i32
+            219..225 '(x, y)': (i32, &str)
+            220..221 'x': &i32
+            223..224 'y': &&str
+            227..228 'x': &i32
+        "#]],
     );
 }
 
 #[test]
 fn slice_tail_pattern() {
-    assert_snapshot!(
-        infer(r#"
-fn foo(params: &[i32]) {
-    match params {
-        [head, tail @ ..] => {
+    check_infer(
+        r#"
+        fn foo(params: &[i32]) {
+            match params {
+                [head, tail @ ..] => {
+                }
+            }
         }
-    }
-}
-"#),
-        @r###"
-    7..13 'params': &[i32]
-    23..92 '{     ...   } }': ()
-    29..90 'match ...     }': ()
-    35..41 'params': &[i32]
-    52..69 '[head,... @ ..]': [i32]
-    53..57 'head': &i32
-    59..68 'tail @ ..': &[i32]
-    66..68 '..': [i32]
-    73..84 '{         }': ()
-    "###
+        "#,
+        expect![[r#"
+            7..13 'params': &[i32]
+            23..92 '{     ...   } }': ()
+            29..90 'match ...     }': ()
+            35..41 'params': &[i32]
+            52..69 '[head,... @ ..]': [i32]
+            53..57 'head': &i32
+            59..68 'tail @ ..': &[i32]
+            66..68 '..': [i32]
+            73..84 '{         }': ()
+        "#]],
     );
 }
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 4367621fc..b9ab0f357 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -1,87 +1,87 @@
-use insta::assert_snapshot;
+use expect::expect;
 use test_utils::mark;
 
-use super::{check_types, infer};
+use super::{check_infer, check_types};
 
 #[test]
 fn bug_484() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-   let x = if true {};
-}
-"#),
-        @r###"
-    10..36 '{    l... {}; }': ()
-    19..20 'x': ()
-    23..33 'if true {}': ()
-    26..30 'true': bool
-    31..33 '{}': ()
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            let x = if true {};
+        }
+        "#,
+        expect![[r#"
+            10..37 '{     ... {}; }': ()
+            20..21 'x': ()
+            24..34 'if true {}': ()
+            27..31 'true': bool
+            32..34 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn no_panic_on_field_of_enum() {
-    assert_snapshot!(
-        infer(r#"
-enum X {}
-
-fn test(x: X) {
-    x.some_field;
-}
-"#),
-        @r###"
-    19..20 'x': X
-    25..46 '{     ...eld; }': ()
-    31..32 'x': X
-    31..43 'x.some_field': {unknown}
-    "###
+    check_infer(
+        r#"
+        enum X {}
+
+        fn test(x: X) {
+            x.some_field;
+        }
+        "#,
+        expect![[r#"
+            19..20 'x': X
+            25..46 '{     ...eld; }': ()
+            31..32 'x': X
+            31..43 'x.some_field': {unknown}
+        "#]],
     );
 }
 
 #[test]
 fn bug_585() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    X {};
-    match x {
-        A::B {} => (),
-        A::Y() => (),
-    }
-}
-"#),
-        @r###"
-    10..88 '{     ...   } }': ()
-    16..20 'X {}': {unknown}
-    26..86 'match ...     }': ()
-    32..33 'x': {unknown}
-    44..51 'A::B {}': {unknown}
-    55..57 '()': ()
-    67..73 'A::Y()': {unknown}
-    77..79 '()': ()
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            X {};
+            match x {
+                A::B {} => (),
+                A::Y() => (),
+            }
+        }
+        "#,
+        expect![[r#"
+            10..88 '{     ...   } }': ()
+            16..20 'X {}': {unknown}
+            26..86 'match ...     }': ()
+            32..33 'x': {unknown}
+            44..51 'A::B {}': {unknown}
+            55..57 '()': ()
+            67..73 'A::Y()': {unknown}
+            77..79 '()': ()
+        "#]],
     );
 }
 
 #[test]
 fn bug_651() {
-    assert_snapshot!(
-        infer(r#"
-fn quux() {
-    let y = 92;
-    1 + y;
-}
-"#),
-        @r###"
-    10..40 '{     ...+ y; }': ()
-    20..21 'y': i32
-    24..26 '92': i32
-    32..33 '1': i32
-    32..37 '1 + y': i32
-    36..37 'y': i32
-    "###
+    check_infer(
+        r#"
+        fn quux() {
+            let y = 92;
+            1 + y;
+        }
+        "#,
+        expect![[r#"
+            10..40 '{     ...+ y; }': ()
+            20..21 'y': i32
+            24..26 '92': i32
+            32..33 '1': i32
+            32..37 '1 + y': i32
+            36..37 'y': i32
+        "#]],
     );
 }
 
@@ -89,78 +89,78 @@ fn quux() {
 fn recursive_vars() {
     mark::check!(type_var_cycles_resolve_completely);
     mark::check!(type_var_cycles_resolve_as_possible);
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let y = unknown;
-    [y, &y];
-}
-"#),
-        @r###"
-    10..47 '{     ...&y]; }': ()
-    20..21 'y': &{unknown}
-    24..31 'unknown': &{unknown}
-    37..44 '[y, &y]': [&&{unknown}; _]
-    38..39 'y': &{unknown}
-    41..43 '&y': &&{unknown}
-    42..43 'y': &{unknown}
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            let y = unknown;
+            [y, &y];
+        }
+        "#,
+        expect![[r#"
+            10..47 '{     ...&y]; }': ()
+            20..21 'y': &{unknown}
+            24..31 'unknown': &{unknown}
+            37..44 '[y, &y]': [&&{unknown}; _]
+            38..39 'y': &{unknown}
+            41..43 '&y': &&{unknown}
+            42..43 'y': &{unknown}
+        "#]],
     );
 }
 
 #[test]
 fn recursive_vars_2() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let x = unknown;
-    let y = unknown;
-    [(x, y), (&y, &x)];
-}
-"#),
-        @r###"
-    10..79 '{     ...x)]; }': ()
-    20..21 'x': &&{unknown}
-    24..31 'unknown': &&{unknown}
-    41..42 'y': &&{unknown}
-    45..52 'unknown': &&{unknown}
-    58..76 '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown}); _]
-    59..65 '(x, y)': (&&&{unknown}, &&&{unknown})
-    60..61 'x': &&{unknown}
-    63..64 'y': &&{unknown}
-    67..75 '(&y, &x)': (&&&{unknown}, &&&{unknown})
-    68..70 '&y': &&&{unknown}
-    69..70 'y': &&{unknown}
-    72..74 '&x': &&&{unknown}
-    73..74 'x': &&{unknown}
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            let x = unknown;
+            let y = unknown;
+            [(x, y), (&y, &x)];
+        }
+        "#,
+        expect![[r#"
+            10..79 '{     ...x)]; }': ()
+            20..21 'x': &&{unknown}
+            24..31 'unknown': &&{unknown}
+            41..42 'y': &&{unknown}
+            45..52 'unknown': &&{unknown}
+            58..76 '[(x, y..., &x)]': [(&&&{unknown}, &&&{unknown}); _]
+            59..65 '(x, y)': (&&&{unknown}, &&&{unknown})
+            60..61 'x': &&{unknown}
+            63..64 'y': &&{unknown}
+            67..75 '(&y, &x)': (&&&{unknown}, &&&{unknown})
+            68..70 '&y': &&&{unknown}
+            69..70 'y': &&{unknown}
+            72..74 '&x': &&&{unknown}
+            73..74 'x': &&{unknown}
+        "#]],
     );
 }
 
 #[test]
 fn infer_std_crash_1() {
     // caused stack overflow, taken from std
-    assert_snapshot!(
-        infer(r#"
-enum Maybe<T> {
-    Real(T),
-    Fake,
-}
+    check_infer(
+        r#"
+        enum Maybe<T> {
+            Real(T),
+            Fake,
+        }
 
-fn write() {
-    match something_unknown {
-        Maybe::Real(ref mut something) => (),
-    }
-}
-"#),
-        @r###"
-    53..138 '{     ...   } }': ()
-    59..136 'match ...     }': ()
-    65..82 'someth...nknown': Maybe<{unknown}>
-    93..123 'Maybe:...thing)': Maybe<{unknown}>
-    105..122 'ref mu...ething': &mut {unknown}
-    127..129 '()': ()
-    "###
+        fn write() {
+            match something_unknown {
+                Maybe::Real(ref mut something) => (),
+            }
+        }
+        "#,
+        expect![[r#"
+            53..138 '{     ...   } }': ()
+            59..136 'match ...     }': ()
+            65..82 'someth...nknown': Maybe<{unknown}>
+            93..123 'Maybe:...thing)': Maybe<{unknown}>
+            105..122 'ref mu...ething': &mut {unknown}
+            127..129 '()': ()
+        "#]],
     );
 }
 
@@ -168,234 +168,235 @@ fn write() {
 fn infer_std_crash_2() {
     mark::check!(type_var_resolves_to_int_var);
     // caused "equating two type variables, ...", taken from std
-    assert_snapshot!(
-        infer(r#"
-fn test_line_buffer() {
-    &[0, b'\n', 1, b'\n'];
-}
-"#),
-        @r###"
-    22..52 '{     ...n']; }': ()
-    28..49 '&[0, b...b'\n']': &[u8; _]
-    29..49 '[0, b'...b'\n']': [u8; _]
-    30..31 '0': u8
-    33..38 'b'\n'': u8
-    40..41 '1': u8
-    43..48 'b'\n'': u8
-    "###
+    check_infer(
+        r#"
+        fn test_line_buffer() {
+            &[0, b'\n', 1, b'\n'];
+        }
+        "#,
+        expect![[r#"
+            22..52 '{     ...n']; }': ()
+            28..49 '&[0, b...b'\n']': &[u8; _]
+            29..49 '[0, b'...b'\n']': [u8; _]
+            30..31 '0': u8
+            33..38 'b'\n'': u8
+            40..41 '1': u8
+            43..48 'b'\n'': u8
+        "#]],
     );
 }
 
 #[test]
 fn infer_std_crash_3() {
     // taken from rustc
-    assert_snapshot!(
-        infer(r#"
-pub fn compute() {
-    match nope!() {
-        SizeSkeleton::Pointer { non_zero: true, tail } => {}
-    }
-}
-"#),
-        @r###"
-    17..107 '{     ...   } }': ()
-    23..105 'match ...     }': ()
-    29..36 'nope!()': {unknown}
-    47..93 'SizeSk...tail }': {unknown}
-    81..85 'true': bool
-    81..85 'true': bool
-    87..91 'tail': {unknown}
-    97..99 '{}': ()
-    "###
+    check_infer(
+        r#"
+        pub fn compute() {
+            match nope!() {
+                SizeSkeleton::Pointer { non_zero: true, tail } => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            17..107 '{     ...   } }': ()
+            23..105 'match ...     }': ()
+            29..36 'nope!()': {unknown}
+            47..93 'SizeSk...tail }': {unknown}
+            81..85 'true': bool
+            81..85 'true': bool
+            87..91 'tail': {unknown}
+            97..99 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_std_crash_4() {
     // taken from rustc
-    assert_snapshot!(
-        infer(r#"
-pub fn primitive_type() {
-    match *self {
-        BorrowedRef { type_: Primitive(p), ..} => {},
-    }
-}
-"#),
-        @r###"
-    24..105 '{     ...   } }': ()
-    30..103 'match ...     }': ()
-    36..41 '*self': {unknown}
-    37..41 'self': {unknown}
-    52..90 'Borrow...), ..}': {unknown}
-    73..85 'Primitive(p)': {unknown}
-    83..84 'p': {unknown}
-    94..96 '{}': ()
-    "###
+    check_infer(
+        r#"
+        pub fn primitive_type() {
+            match *self {
+                BorrowedRef { type_: Primitive(p), ..} => {},
+            }
+        }
+        "#,
+        expect![[r#"
+            24..105 '{     ...   } }': ()
+            30..103 'match ...     }': ()
+            36..41 '*self': {unknown}
+            37..41 'self': {unknown}
+            52..90 'Borrow...), ..}': {unknown}
+            73..85 'Primitive(p)': {unknown}
+            83..84 'p': {unknown}
+            94..96 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn infer_std_crash_5() {
     // taken from rustc
-    assert_snapshot!(
-        infer(r#"
-fn extra_compiler_flags() {
-    for content in doesnt_matter {
-        let name = if doesnt_matter {
-            first
-        } else {
-            &content
-        };
-
-        let content = if ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.contains(&name) {
-            name
-        } else {
-            content
-        };
-    }
-}
-"#),
-        @r###"
-    26..322 '{     ...   } }': ()
-    32..320 'for co...     }': ()
-    36..43 'content': &{unknown}
-    47..60 'doesnt_matter': {unknown}
-    61..320 '{     ...     }': ()
-    75..79 'name': &&{unknown}
-    82..166 'if doe...     }': &&{unknown}
-    85..98 'doesnt_matter': bool
-    99..128 '{     ...     }': &&{unknown}
-    113..118 'first': &&{unknown}
-    134..166 '{     ...     }': &&{unknown}
-    148..156 '&content': &&{unknown}
-    149..156 'content': &{unknown}
-    181..188 'content': &{unknown}
-    191..313 'if ICE...     }': &{unknown}
-    194..231 'ICE_RE..._VALUE': {unknown}
-    194..247 'ICE_RE...&name)': bool
-    241..246 '&name': &&&{unknown}
-    242..246 'name': &&{unknown}
-    248..276 '{     ...     }': &&{unknown}
-    262..266 'name': &&{unknown}
-    282..313 '{     ...     }': &{unknown}
-    296..303 'content': &{unknown}
-    "###
+    check_infer(
+        r#"
+        fn extra_compiler_flags() {
+            for content in doesnt_matter {
+                let name = if doesnt_matter {
+                    first
+                } else {
+                    &content
+                };
+
+                let content = if ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.contains(&name) {
+                    name
+                } else {
+                    content
+                };
+            }
+        }
+        "#,
+        expect![[r#"
+            26..322 '{     ...   } }': ()
+            32..320 'for co...     }': ()
+            36..43 'content': &{unknown}
+            47..60 'doesnt_matter': {unknown}
+            61..320 '{     ...     }': ()
+            75..79 'name': &&{unknown}
+            82..166 'if doe...     }': &&{unknown}
+            85..98 'doesnt_matter': bool
+            99..128 '{     ...     }': &&{unknown}
+            113..118 'first': &&{unknown}
+            134..166 '{     ...     }': &&{unknown}
+            148..156 '&content': &&{unknown}
+            149..156 'content': &{unknown}
+            181..188 'content': &{unknown}
+            191..313 'if ICE...     }': &{unknown}
+            194..231 'ICE_RE..._VALUE': {unknown}
+            194..247 'ICE_RE...&name)': bool
+            241..246 '&name': &&&{unknown}
+            242..246 'name': &&{unknown}
+            248..276 '{     ...     }': &&{unknown}
+            262..266 'name': &&{unknown}
+            282..313 '{     ...     }': &{unknown}
+            296..303 'content': &{unknown}
+        "#]],
     );
 }
 
 #[test]
 fn infer_nested_generics_crash() {
     // another crash found typechecking rustc
-    assert_snapshot!(
-        infer(r#"
-struct Canonical<V> {
-    value: V,
-}
-struct QueryResponse<V> {
-    value: V,
-}
-fn test<R>(query_response: Canonical<QueryResponse<R>>) {
-    &query_response.value;
-}
-"#),
-        @r###"
-    91..105 'query_response': Canonical<QueryResponse<R>>
-    136..166 '{     ...lue; }': ()
-    142..163 '&query....value': &QueryResponse<R>
-    143..157 'query_response': Canonical<QueryResponse<R>>
-    143..163 'query_....value': QueryResponse<R>
-    "###
+    check_infer(
+        r#"
+        struct Canonical<V> {
+            value: V,
+        }
+        struct QueryResponse<V> {
+            value: V,
+        }
+        fn test<R>(query_response: Canonical<QueryResponse<R>>) {
+            &query_response.value;
+        }
+        "#,
+        expect![[r#"
+            91..105 'query_response': Canonical<QueryResponse<R>>
+            136..166 '{     ...lue; }': ()
+            142..163 '&query....value': &QueryResponse<R>
+            143..157 'query_response': Canonical<QueryResponse<R>>
+            143..163 'query_....value': QueryResponse<R>
+        "#]],
     );
 }
 
 #[test]
 fn infer_paren_macro_call() {
-    assert_snapshot!(
-        infer(r#"
-macro_rules! bar { () => {0u32} }
-fn test() {
-    let a = (bar!());
-}
-"#),
-        @r###"
-    !0..4 '0u32': u32
-    44..69 '{     ...()); }': ()
-    54..55 'a': u32
-    "###
+    check_infer(
+        r#"
+        macro_rules! bar { () => {0u32} }
+        fn test() {
+            let a = (bar!());
+        }
+        "#,
+        expect![[r#"
+            !0..4 '0u32': u32
+            44..69 '{     ...()); }': ()
+            54..55 'a': u32
+        "#]],
     );
 }
 
 #[test]
 fn bug_1030() {
-    assert_snapshot!(infer(r#"
-struct HashSet<T, H>;
-struct FxHasher;
-type FxHashSet<T> = HashSet<T, FxHasher>;
+    check_infer(
+        r#"
+        struct HashSet<T, H>;
+        struct FxHasher;
+        type FxHashSet<T> = HashSet<T, FxHasher>;
 
-impl<T, H> HashSet<T, H> {
-    fn default() -> HashSet<T, H> {}
-}
+        impl<T, H> HashSet<T, H> {
+            fn default() -> HashSet<T, H> {}
+        }
 
-pub fn main_loop() {
-    FxHashSet::default();
-}
-"#),
-    @r###"
-    143..145 '{}': ()
-    168..197 '{     ...t(); }': ()
-    174..192 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
-    174..194 'FxHash...ault()': HashSet<{unknown}, FxHasher>
-    "###
+        pub fn main_loop() {
+            FxHashSet::default();
+        }
+        "#,
+        expect![[r#"
+            143..145 '{}': ()
+            168..197 '{     ...t(); }': ()
+            174..192 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
+            174..194 'FxHash...ault()': HashSet<{unknown}, FxHasher>
+        "#]],
     );
 }
 
 #[test]
 fn issue_2669() {
-    assert_snapshot!(
-        infer(
-            r#"trait A {}
-    trait Write {}
-    struct Response<T> {}
-
-    trait D {
-        fn foo();
-    }
+    check_infer(
+        r#"
+        trait A {}
+        trait Write {}
+        struct Response<T> {}
+
+        trait D {
+            fn foo();
+        }
 
-    impl<T:A> D for Response<T> {
-        fn foo() {
-            end();
-            fn end<W: Write>() {
-                let _x: T =  loop {};
+        impl<T:A> D for Response<T> {
+            fn foo() {
+                end();
+                fn end<W: Write>() {
+                    let _x: T =  loop {};
+                }
             }
         }
-    }"#
-        ),
-        @r###"
-    147..262 '{     ...     }': ()
-    161..164 'end': fn end<{unknown}>()
-    161..166 'end()': ()
-    199..252 '{     ...     }': ()
-    221..223 '_x': !
-    230..237 'loop {}': !
-    235..237 '{}': ()
-    "###
+        "#,
+        expect![[r#"
+            119..214 '{     ...     }': ()
+            129..132 'end': fn end<{unknown}>()
+            129..134 'end()': ()
+            163..208 '{     ...     }': ()
+            181..183 '_x': !
+            190..197 'loop {}': !
+            195..197 '{}': ()
+        "#]],
     )
 }
 
 #[test]
 fn issue_2705() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait {}
-fn test() {
-    <Trait<u32>>::foo()
-}
-"#),
-        @r###"
-    25..52 '{     ...oo() }': ()
-    31..48 '<Trait...>::foo': {unknown}
-    31..50 '<Trait...:foo()': ()
-    "###
+    check_infer(
+        r#"
+        trait Trait {}
+        fn test() {
+            <Trait<u32>>::foo()
+        }
+        "#,
+        expect![[r#"
+            25..52 '{     ...oo() }': ()
+            31..48 '<Trait...>::foo': {unknown}
+            31..50 '<Trait...:foo()': ()
+        "#]],
     );
 }
 
@@ -479,25 +480,25 @@ fn main() {
 
 #[test]
 fn issue_3999_slice() {
-    assert_snapshot!(
-        infer(r#"
-fn foo(params: &[usize]) {
-    match params {
-        [ps @ .., _] => {}
-    }
-}
-"#),
-        @r###"
-    7..13 'params': &[usize]
-    25..80 '{     ...   } }': ()
-    31..78 'match ...     }': ()
-    37..43 'params': &[usize]
-    54..66 '[ps @ .., _]': [usize]
-    55..62 'ps @ ..': &[usize]
-    60..62 '..': [usize]
-    64..65 '_': usize
-    70..72 '{}': ()
-    "###
+    check_infer(
+        r#"
+        fn foo(params: &[usize]) {
+            match params {
+                [ps @ .., _] => {}
+            }
+        }
+        "#,
+        expect![[r#"
+            7..13 'params': &[usize]
+            25..80 '{     ...   } }': ()
+            31..78 'match ...     }': ()
+            37..43 'params': &[usize]
+            54..66 '[ps @ .., _]': [usize]
+            55..62 'ps @ ..': &[usize]
+            60..62 '..': [usize]
+            64..65 '_': usize
+            70..72 '{}': ()
+        "#]],
     );
 }
 
@@ -505,334 +506,337 @@ fn foo(params: &[usize]) {
 fn issue_3999_struct() {
     // rust-analyzer should not panic on seeing this malformed
     // record pattern.
-    assert_snapshot!(
-        infer(r#"
-struct Bar {
-    a: bool,
-}
-fn foo(b: Bar) {
-    match b {
-        Bar { a: .. } => {},
-    }
-}
-"#),
-        @r###"
-    35..36 'b': Bar
-    43..95 '{     ...   } }': ()
-    49..93 'match ...     }': ()
-    55..56 'b': Bar
-    67..80 'Bar { a: .. }': Bar
-    76..78 '..': bool
-    84..86 '{}': ()
-    "###
+    check_infer(
+        r#"
+        struct Bar {
+            a: bool,
+        }
+        fn foo(b: Bar) {
+            match b {
+                Bar { a: .. } => {},
+            }
+        }
+        "#,
+        expect![[r#"
+            35..36 'b': Bar
+            43..95 '{     ...   } }': ()
+            49..93 'match ...     }': ()
+            55..56 'b': Bar
+            67..80 'Bar { a: .. }': Bar
+            76..78 '..': bool
+            84..86 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn issue_4235_name_conflicts() {
-    assert_snapshot!(
-        infer(r#"
-struct FOO {}
-static FOO:FOO = FOO {};
+    check_infer(
+        r#"
+        struct FOO {}
+        static FOO:FOO = FOO {};
 
-impl FOO {
-    fn foo(&self) {}
-}
+        impl FOO {
+            fn foo(&self) {}
+        }
 
-fn main() {
-    let a = &FOO;
-    a.foo();
-}
-"#), @r###"
-    31..37 'FOO {}': FOO
-    63..67 'self': &FOO
-    69..71 '{}': ()
-    85..119 '{     ...o(); }': ()
-    95..96 'a': &FOO
-    99..103 '&FOO': &FOO
-    100..103 'FOO': FOO
-    109..110 'a': &FOO
-    109..116 'a.foo()': ()
-    "###
+        fn main() {
+            let a = &FOO;
+            a.foo();
+        }
+        "#,
+        expect![[r#"
+            31..37 'FOO {}': FOO
+            63..67 'self': &FOO
+            69..71 '{}': ()
+            85..119 '{     ...o(); }': ()
+            95..96 'a': &FOO
+            99..103 '&FOO': &FOO
+            100..103 'FOO': FOO
+            109..110 'a': &FOO
+            109..116 'a.foo()': ()
+        "#]],
     );
 }
 
 #[test]
 fn issue_4465_dollar_crate_at_type() {
-    assert_snapshot!(
-        infer(r#"
-pub struct Foo {}
-pub fn anything<T>() -> T {
-    loop {}
-}
-macro_rules! foo {
-    () => {{
-        let r: $crate::Foo = anything();
-        r
-    }};
-}
-fn main() {
-    let _a = foo!();
-}
-"#), @r###"
-    44..59 '{     loop {} }': T
-    50..57 'loop {}': !
-    55..57 '{}': ()
-    !0..31 '{letr:...g();r}': Foo
-    !4..5 'r': Foo
-    !18..26 'anything': fn anything<Foo>() -> Foo
-    !18..28 'anything()': Foo
-    !29..30 'r': Foo
-    163..187 '{     ...!(); }': ()
-    173..175 '_a': Foo
-    "###);
+    check_infer(
+        r#"
+        pub struct Foo {}
+        pub fn anything<T>() -> T {
+            loop {}
+        }
+        macro_rules! foo {
+            () => {{
+                let r: $crate::Foo = anything();
+                r
+            }};
+        }
+        fn main() {
+            let _a = foo!();
+        }
+        "#,
+        expect![[r#"
+            44..59 '{     loop {} }': T
+            50..57 'loop {}': !
+            55..57 '{}': ()
+            !0..31 '{letr:...g();r}': Foo
+            !4..5 'r': Foo
+            !18..26 'anything': fn anything<Foo>() -> Foo
+            !18..28 'anything()': Foo
+            !29..30 'r': Foo
+            163..187 '{     ...!(); }': ()
+            173..175 '_a': Foo
+        "#]],
+    );
 }
 
 #[test]
 fn issue_4053_diesel_where_clauses() {
-    assert_snapshot!(
-        infer(r#"
-trait BoxedDsl<DB> {
-    type Output;
-    fn internal_into_boxed(self) -> Self::Output;
-}
+    check_infer(
+        r#"
+        trait BoxedDsl<DB> {
+            type Output;
+            fn internal_into_boxed(self) -> Self::Output;
+        }
 
-struct SelectStatement<From, Select, Distinct, Where, Order, LimitOffset, GroupBy, Locking> {
-    order: Order,
-}
+        struct SelectStatement<From, Select, Distinct, Where, Order, LimitOffset, GroupBy, Locking> {
+            order: Order,
+        }
 
-trait QueryFragment<DB: Backend> {}
+        trait QueryFragment<DB: Backend> {}
 
-trait Into<T> { fn into(self) -> T; }
+        trait Into<T> { fn into(self) -> T; }
 
-impl<F, S, D, W, O, LOf, DB> BoxedDsl<DB>
-    for SelectStatement<F, S, D, W, O, LOf, G>
-where
-    O: Into<dyn QueryFragment<DB>>,
-{
-    type Output = XXX;
+        impl<F, S, D, W, O, LOf, DB> BoxedDsl<DB>
+            for SelectStatement<F, S, D, W, O, LOf, G>
+        where
+            O: Into<dyn QueryFragment<DB>>,
+        {
+            type Output = XXX;
 
-    fn internal_into_boxed(self) -> Self::Output {
-        self.order.into();
-    }
-}
-"#),
-        @r###"
-    65..69 'self': Self
-    267..271 'self': Self
-    466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
-    488..522 '{     ...     }': ()
-    498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
-    498..508 'self.order': O
-    498..515 'self.o...into()': dyn QueryFragment<DB>
-    "###
+            fn internal_into_boxed(self) -> Self::Output {
+                self.order.into();
+            }
+        }
+        "#,
+        expect![[r#"
+            65..69 'self': Self
+            267..271 'self': Self
+            466..470 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
+            488..522 '{     ...     }': ()
+            498..502 'self': SelectStatement<F, S, D, W, O, LOf, {unknown}, {unknown}>
+            498..508 'self.order': O
+            498..515 'self.o...into()': dyn QueryFragment<DB>
+        "#]],
     );
 }
 
 #[test]
 fn issue_4953() {
-    assert_snapshot!(
-        infer(r#"
-pub struct Foo(pub i64);
-impl Foo {
-    fn test() -> Self { Self(0i64) }
-}
-"#),
-        @r###"
-    58..72 '{ Self(0i64) }': Foo
-    60..64 'Self': Foo(i64) -> Foo
-    60..70 'Self(0i64)': Foo
-    65..69 '0i64': i64
-    "###
+    check_infer(
+        r#"
+        pub struct Foo(pub i64);
+        impl Foo {
+            fn test() -> Self { Self(0i64) }
+        }
+        "#,
+        expect![[r#"
+            58..72 '{ Self(0i64) }': Foo
+            60..64 'Self': Foo(i64) -> Foo
+            60..70 'Self(0i64)': Foo
+            65..69 '0i64': i64
+        "#]],
     );
-    assert_snapshot!(
-        infer(r#"
-pub struct Foo<T>(pub T);
-impl Foo<i64> {
-    fn test() -> Self { Self(0i64) }
-}
-"#),
-        @r###"
-    64..78 '{ Self(0i64) }': Foo<i64>
-    66..70 'Self': Foo<i64>(i64) -> Foo<i64>
-    66..76 'Self(0i64)': Foo<i64>
-    71..75 '0i64': i64
-    "###
+    check_infer(
+        r#"
+        pub struct Foo<T>(pub T);
+        impl Foo<i64> {
+            fn test() -> Self { Self(0i64) }
+        }
+        "#,
+        expect![[r#"
+            64..78 '{ Self(0i64) }': Foo<i64>
+            66..70 'Self': Foo<i64>(i64) -> Foo<i64>
+            66..76 'Self(0i64)': Foo<i64>
+            71..75 '0i64': i64
+        "#]],
     );
 }
 
 #[test]
 fn issue_4931() {
-    assert_snapshot!(
-        infer(r#"
-trait Div<T> {
-    type Output;
-}
+    check_infer(
+        r#"
+        trait Div<T> {
+            type Output;
+        }
 
-trait CheckedDiv: Div<()> {}
+        trait CheckedDiv: Div<()> {}
 
-trait PrimInt: CheckedDiv<Output = ()> {
-    fn pow(self);
-}
+        trait PrimInt: CheckedDiv<Output = ()> {
+            fn pow(self);
+        }
 
-fn check<T: PrimInt>(i: T) {
-    i.pow();
-}
-"#),
-        @r###"
-    117..121 'self': Self
-    148..149 'i': T
-    154..170 '{     ...w(); }': ()
-    160..161 'i': T
-    160..167 'i.pow()': ()
-    "###
+        fn check<T: PrimInt>(i: T) {
+            i.pow();
+        }
+        "#,
+        expect![[r#"
+            117..121 'self': Self
+            148..149 'i': T
+            154..170 '{     ...w(); }': ()
+            160..161 'i': T
+            160..167 'i.pow()': ()
+        "#]],
     );
 }
 
 #[test]
 fn issue_4885() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T> {}
-
-trait Future {
-    type Output;
-}
-trait Foo<R> {
-    type Bar;
-}
-fn foo<R, K>(key: &K) -> impl Future<Output = K::Bar>
-where
-    K: Foo<R>,
-{
-    bar(key)
-}
-fn bar<R, K>(key: &K) -> impl Future<Output = K::Bar>
-where
-    K: Foo<R>,
-{
-}
-"#),
-        @r###"
-    136..139 'key': &K
-    198..214 '{     ...key) }': impl Future<Output = <K as Foo<R>>::Bar>
-    204..207 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar>
-    204..212 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar>
-    208..211 'key': &K
-    228..231 'key': &K
-    290..293 '{ }': ()
-    "###
+    check_infer(
+        r#"
+        #[lang = "coerce_unsized"]
+        pub trait CoerceUnsized<T> {}
+
+        trait Future {
+            type Output;
+        }
+        trait Foo<R> {
+            type Bar;
+        }
+        fn foo<R, K>(key: &K) -> impl Future<Output = K::Bar>
+        where
+            K: Foo<R>,
+        {
+            bar(key)
+        }
+        fn bar<R, K>(key: &K) -> impl Future<Output = K::Bar>
+        where
+            K: Foo<R>,
+        {
+        }
+        "#,
+        expect![[r#"
+            136..139 'key': &K
+            198..214 '{     ...key) }': impl Future<Output = <K as Foo<R>>::Bar>
+            204..207 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar>
+            204..212 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar>
+            208..211 'key': &K
+            228..231 'key': &K
+            290..293 '{ }': ()
+        "#]],
     );
 }
 
 #[test]
 fn issue_4800() {
-    assert_snapshot!(
-        infer(r#"
-trait Debug {}
+    check_infer(
+        r#"
+        trait Debug {}
 
-struct Foo<T>;
+        struct Foo<T>;
 
-type E1<T> = (T, T, T);
-type E2<T> = E1<E1<E1<(T, T, T)>>>;
+        type E1<T> = (T, T, T);
+        type E2<T> = E1<E1<E1<(T, T, T)>>>;
 
-impl Debug for Foo<E2<()>> {}
+        impl Debug for Foo<E2<()>> {}
 
-struct Request;
+        struct Request;
 
-pub trait Future {
-    type Output;
-}
+        pub trait Future {
+            type Output;
+        }
 
-pub struct PeerSet<D>;
+        pub struct PeerSet<D>;
 
-impl<D> Service<Request> for PeerSet<D>
-where
-    D: Discover,
-    D::Key: Debug,
-{
-    type Error = ();
-    type Future = dyn Future<Output = Self::Error>;
+        impl<D> Service<Request> for PeerSet<D>
+        where
+            D: Discover,
+            D::Key: Debug,
+        {
+            type Error = ();
+            type Future = dyn Future<Output = Self::Error>;
 
-    fn call(&mut self) -> Self::Future {
-        loop {}
-    }
-}
+            fn call(&mut self) -> Self::Future {
+                loop {}
+            }
+        }
 
-pub trait Discover {
-    type Key;
-}
+        pub trait Discover {
+            type Key;
+        }
 
-pub trait Service<Request> {
-    type Error;
-    type Future: Future<Output = Self::Error>;
-    fn call(&mut self) -> Self::Future;
-}
-"#),
-        @r###"
-    379..383 'self': &mut PeerSet<D>
-    401..424 '{     ...     }': dyn Future<Output = ()>
-    411..418 'loop {}': !
-    416..418 '{}': ()
-    575..579 'self': &mut Self
-    "###
+        pub trait Service<Request> {
+            type Error;
+            type Future: Future<Output = Self::Error>;
+            fn call(&mut self) -> Self::Future;
+        }
+        "#,
+        expect![[r#"
+            379..383 'self': &mut PeerSet<D>
+            401..424 '{     ...     }': dyn Future<Output = ()>
+            411..418 'loop {}': !
+            416..418 '{}': ()
+            575..579 'self': &mut Self
+        "#]],
     );
 }
 
 #[test]
 fn issue_4966() {
-    assert_snapshot!(
-        infer(r#"
-pub trait IntoIterator {
-    type Item;
-}
+    check_infer(
+        r#"
+        pub trait IntoIterator {
+            type Item;
+        }
 
-struct Repeat<A> { element: A }
+        struct Repeat<A> { element: A }
 
-struct Map<F> { f: F }
+        struct Map<F> { f: F }
 
-struct Vec<T> {}
+        struct Vec<T> {}
 
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-}
+        #[lang = "deref"]
+        pub trait Deref {
+            type Target;
+        }
 
-impl<T> Deref for Vec<T> {
-    type Target = [T];
-}
+        impl<T> Deref for Vec<T> {
+            type Target = [T];
+        }
 
-fn from_iter<A, T: IntoIterator<Item = A>>(iter: T) -> Vec<A> {}
+        fn from_iter<A, T: IntoIterator<Item = A>>(iter: T) -> Vec<A> {}
 
-fn main() {
-    let inner = Map { f: |_: &f64| 0.0 };
-
-    let repeat = Repeat { element: inner };
-
-    let vec = from_iter(repeat);
-
-    vec.foo_bar();
-}
-"#),
-        @r###"
-    270..274 'iter': T
-    289..291 '{}': ()
-    303..447 '{     ...r(); }': ()
-    313..318 'inner': Map<|&f64| -> f64>
-    321..345 'Map { ... 0.0 }': Map<|&f64| -> f64>
-    330..343 '|_: &f64| 0.0': |&f64| -> f64
-    331..332 '_': &f64
-    340..343 '0.0': f64
-    356..362 'repeat': Repeat<Map<|&f64| -> f64>>
-    365..390 'Repeat...nner }': Repeat<Map<|&f64| -> f64>>
-    383..388 'inner': Map<|&f64| -> f64>
-    401..404 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
-    407..416 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>, Repeat<Map<|&f64| -> f64>>>(Repeat<Map<|&f64| -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
-    407..424 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
-    417..423 'repeat': Repeat<Map<|&f64| -> f64>>
-    431..434 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
-    431..444 'vec.foo_bar()': {unknown}
-    "###
+        fn main() {
+            let inner = Map { f: |_: &f64| 0.0 };
+
+            let repeat = Repeat { element: inner };
+
+            let vec = from_iter(repeat);
+
+            vec.foo_bar();
+        }
+        "#,
+        expect![[r#"
+            270..274 'iter': T
+            289..291 '{}': ()
+            303..447 '{     ...r(); }': ()
+            313..318 'inner': Map<|&f64| -> f64>
+            321..345 'Map { ... 0.0 }': Map<|&f64| -> f64>
+            330..343 '|_: &f64| 0.0': |&f64| -> f64
+            331..332 '_': &f64
+            340..343 '0.0': f64
+            356..362 'repeat': Repeat<Map<|&f64| -> f64>>
+            365..390 'Repeat...nner }': Repeat<Map<|&f64| -> f64>>
+            383..388 'inner': Map<|&f64| -> f64>
+            401..404 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
+            407..416 'from_iter': fn from_iter<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>, Repeat<Map<|&f64| -> f64>>>(Repeat<Map<|&f64| -> f64>>) -> Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
+            407..424 'from_i...epeat)': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
+            417..423 'repeat': Repeat<Map<|&f64| -> f64>>
+            431..434 'vec': Vec<IntoIterator::Item<Repeat<Map<|&f64| -> f64>>>>
+            431..444 'vec.foo_bar()': {unknown}
+        "#]],
     );
 }
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 6d3e264af..3fd7d5cd4 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -1,6 +1,6 @@
-use insta::assert_snapshot;
+use expect::expect;
 
-use super::{check_types, infer};
+use super::{check_infer, check_types};
 
 #[test]
 fn infer_box() {
@@ -45,43 +45,44 @@ fn test() {
 
 #[test]
 fn self_in_struct_lit() {
-    assert_snapshot!(infer(
+    check_infer(