6 files changed, 5366 insertions, 5365 deletions

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(
         r#"
-//- /main.rs
-struct S<T> { x: T }
+        //- /main.rs
+        struct S<T> { x: T }
 
-impl S<u32> {
-    fn foo() {
-        Self { x: 1 };
-    }
-}
-"#,
-    ), @r###"
-    49..79 '{     ...     }': ()
-    59..72 'Self { x: 1 }': S<u32>
-    69..70 '1': u32
-    "###);
+        impl S<u32> {
+            fn foo() {
+                Self { x: 1 };
+            }
+        }
+        "#,
+        expect![[r#"
+            49..79 '{     ...     }': ()
+            59..72 'Self { x: 1 }': S<u32>
+            69..70 '1': u32
+        "#]],
+    );
 }
 
 #[test]
 fn type_alias_in_struct_lit() {
-    assert_snapshot!(infer(
+    check_infer(
         r#"
-//- /main.rs
-struct S<T> { x: T }
+        //- /main.rs
+        struct S<T> { x: T }
 
-type SS = S<u32>;
+        type SS = S<u32>;
 
-fn foo() {
-    SS { x: 1 };
-}
-
-"#,
-    ), @r###"
-    50..70 '{     ...1 }; }': ()
-    56..67 'SS { x: 1 }': S<u32>
-    64..65 '1': u32
-    "###);
+        fn foo() {
+            SS { x: 1 };
+        }
+        "#,
+        expect![[r#"
+            50..70 '{     ...1 }; }': ()
+            56..67 'SS { x: 1 }': S<u32>
+            64..65 '1': u32
+        "#]],
+    );
 }
 
 #[test]
@@ -148,1549 +149,1549 @@ fn test() {
 
 #[test]
 fn infer_basics() {
-    assert_snapshot!(
-        infer(r#"
-fn test(a: u32, b: isize, c: !, d: &str) {
-    a;
-    b;
-    c;
-    d;
-    1usize;
-    1isize;
-    "test";
-    1.0f32;
-}"#),
-        @r###"
-    8..9 'a': u32
-    16..17 'b': isize
-    26..27 'c': !
-    32..33 'd': &str
-    41..120 '{     ...f32; }': ()
-    47..48 'a': u32
-    54..55 'b': isize
-    61..62 'c': !
-    68..69 'd': &str
-    75..81 '1usize': usize
-    87..93 '1isize': isize
-    99..105 '"test"': &str
-    111..117 '1.0f32': f32
-    "###
+    check_infer(
+        r#"
+        fn test(a: u32, b: isize, c: !, d: &str) {
+            a;
+            b;
+            c;
+            d;
+            1usize;
+            1isize;
+            "test";
+            1.0f32;
+        }"#,
+        expect![[r#"
+            8..9 'a': u32
+            16..17 'b': isize
+            26..27 'c': !
+            32..33 'd': &str
+            41..120 '{     ...f32; }': ()
+            47..48 'a': u32
+            54..55 'b': isize
+            61..62 'c': !
+            68..69 'd': &str
+            75..81 '1usize': usize
+            87..93 '1isize': isize
+            99..105 '"test"': &str
+            111..117 '1.0f32': f32
+        "#]],
     );
 }
 
 #[test]
 fn infer_let() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    let a = 1isize;
-    let b: usize = 1;
-    let c = b;
-    let d: u32;
-    let e;
-    let f: i32 = e;
-}
-"#),
-        @r###"
-    10..117 '{     ...= e; }': ()
-    20..21 'a': isize
-    24..30 '1isize': isize
-    40..41 'b': usize
-    51..52 '1': usize
-    62..63 'c': usize
-    66..67 'b': usize
-    77..78 'd': u32
-    93..94 'e': i32
-    104..105 'f': i32
-    113..114 'e': i32
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            let a = 1isize;
+            let b: usize = 1;
+            let c = b;
+            let d: u32;
+            let e;
+            let f: i32 = e;
+        }
+        "#,
+        expect![[r#"
+            10..117 '{     ...= e; }': ()
+            20..21 'a': isize
+            24..30 '1isize': isize
+            40..41 'b': usize
+            51..52 '1': usize
+            62..63 'c': usize
+            66..67 'b': usize
+            77..78 'd': u32
+            93..94 'e': i32
+            104..105 'f': i32
+            113..114 'e': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_paths() {
-    assert_snapshot!(
-        infer(r#"
-fn a() -> u32 { 1 }
+    check_infer(
+        r#"
+        fn a() -> u32 { 1 }
 
-mod b {
-    fn c() -> u32 { 1 }
-}
+        mod b {
+            fn c() -> u32 { 1 }
+        }
 
-fn test() {
-    a();
-    b::c();
-}
-"#),
-        @r###"
-    14..19 '{ 1 }': u32
-    16..17 '1': u32
-    47..52 '{ 1 }': u32
-    49..50 '1': u32
-    66..90 '{     ...c(); }': ()
-    72..73 'a': fn a() -> u32
-    72..75 'a()': u32
-    81..85 'b::c': fn c() -> u32
-    81..87 'b::c()': u32
-    "###
+        fn test() {
+            a();
+            b::c();
+        }
+        "#,
+        expect![[r#"
+            14..19 '{ 1 }': u32
+            16..17 '1': u32
+            47..52 '{ 1 }': u32
+            49..50 '1': u32
+            66..90 '{     ...c(); }': ()
+            72..73 'a': fn a() -> u32
+            72..75 'a()': u32
+            81..85 'b::c': fn c() -> u32
+            81..87 'b::c()': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_path_type() {
-    assert_snapshot!(
-        infer(r#"
-struct S;
+    check_infer(
+        r#"
+        struct S;
 
-impl S {
-    fn foo() -> i32 { 1 }
-}
+        impl S {
+            fn foo() -> i32 { 1 }
+        }
 
-fn test() {
-    S::foo();
-    <S>::foo();
-}
-"#),
-        @r###"
-    40..45 '{ 1 }': i32
-    42..43 '1': i32
-    59..92 '{     ...o(); }': ()
-    65..71 'S::foo': fn foo() -> i32
-    65..73 'S::foo()': i32
-    79..87 '<S>::foo': fn foo() -> i32
-    79..89 '<S>::foo()': i32
-    "###
+        fn test() {
+            S::foo();
+            <S>::foo();
+        }
+        "#,
+        expect![[r#"
+            40..45 '{ 1 }': i32
+            42..43 '1': i32
+            59..92 '{     ...o(); }': ()
+            65..71 'S::foo': fn foo() -> i32
+            65..73 'S::foo()': i32
+            79..87 '<S>::foo': fn foo() -> i32
+            79..89 '<S>::foo()': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_struct() {
-    assert_snapshot!(
-        infer(r#"
-struct A {
-    b: B,
-    c: C,
-}
-struct B;
-struct C(usize);
-
-fn test() {
-    let c = C(1);
-    B;
-    let a: A = A { b: B, c: C(1) };
-    a.b;
-    a.c;
-}
-"#),
-        @r###"
-    71..153 '{     ...a.c; }': ()
-    81..82 'c': C
-    85..86 'C': C(usize) -> C
-    85..89 'C(1)': C
-    87..88 '1': usize
-    95..96 'B': B
-    106..107 'a': A
-    113..132 'A { b:...C(1) }': A
-    120..121 'B': B
-    126..127 'C': C(usize) -> C
-    126..130 'C(1)': C
-    128..129 '1': usize
-    138..139 'a': A
-    138..141 'a.b': B
-    147..148 'a': A
-    147..150 'a.c': C
-    "###
+    check_infer(
+        r#"
+        struct A {
+            b: B,
+            c: C,
+        }
+        struct B;
+        struct C(usize);
+
+        fn test() {
+            let c = C(1);
+            B;
+            let a: A = A { b: B, c: C(1) };
+            a.b;
+            a.c;
+        }
+        "#,
+        expect![[r#"
+            71..153 '{     ...a.c; }': ()
+            81..82 'c': C
+            85..86 'C': C(usize) -> C
+            85..89 'C(1)': C
+            87..88 '1': usize
+            95..96 'B': B
+            106..107 'a': A
+            113..132 'A { b:...C(1) }': A
+            120..121 'B': B
+            126..127 'C': C(usize) -> C
+            126..130 'C(1)': C
+            128..129 '1': usize
+            138..139 'a': A
+            138..141 'a.b': B
+            147..148 'a': A
+            147..150 'a.c': C
+        "#]],
     );
 }
 
 #[test]
 fn infer_enum() {
-    assert_snapshot!(
-        infer(r#"
-enum E {
-  V1 { field: u32 },
-  V2
-}
-fn test() {
-  E::V1 { field: 1 };
-  E::V2;
-}"#),
-        @r###"
-    47..81 '{   E:...:V2; }': ()
-    51..69 'E::V1 ...d: 1 }': E
-    66..67 '1': u32
-    73..78 'E::V2': E
-    "###
+    check_infer(
+        r#"
+        enum E {
+            V1 { field: u32 },
+            V2
+        }
+        fn test() {
+            E::V1 { field: 1 };
+            E::V2;
+        }"#,
+        expect![[r#"
+            51..89 '{     ...:V2; }': ()
+            57..75 'E::V1 ...d: 1 }': E
+            72..73 '1': u32
+            81..86 'E::V2': E
+        "#]],
     );
 }
 
 #[test]
 fn infer_union() {
-    assert_snapshot!(
-        infer(r#"
-union MyUnion {
-    foo: u32,
-    bar: f32,
-}
-
-unsafe fn baz(u: MyUnion) {
-    let inner = u.foo;
-}
-"#),
-        @r###"
-    61..62 'u': MyUnion
-    73..99 '{     ...foo; }': ()
-    83..88 'inner': u32
-    91..92 'u': MyUnion
-    91..96 'u.foo': u32
-    "###
+    check_infer(
+        r#"
+        union MyUnion {
+            foo: u32,
+            bar: f32,
+        }
+
+        unsafe fn baz(u: MyUnion) {
+            let inner = u.foo;
+        }
+        "#,
+        expect![[r#"
+            61..62 'u': MyUnion
+            73..99 '{     ...foo; }': ()
+            83..88 'inner': u32
+            91..92 'u': MyUnion
+            91..96 'u.foo': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_refs() {
-    assert_snapshot!(
-        infer(r#"
-fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
-    a;
-    *a;
-    &a;
-    &mut a;
-    b;
-    *b;
-    &b;
-    c;
-    *c;
-    d;
-    *d;
-}
-"#),
-        @r###"
-    8..9 'a': &u32
-    17..18 'b': &mut u32
-    30..31 'c': *const u32
-    45..46 'd': *mut u32
-    58..149 '{     ... *d; }': ()
-    64..65 'a': &u32
-    71..73 '*a': u32
-    72..73 'a': &u32
-    79..81 '&a': &&u32
-    80..81 'a': &u32
-    87..93 '&mut a': &mut &u32
-    92..93 'a': &u32
-    99..100 'b': &mut u32
-    106..108 '*b': u32
-    107..108 'b': &mut u32
-    114..116 '&b': &&mut u32
-    115..116 'b': &mut u32
-    122..123 'c': *const u32
-    129..131 '*c': u32
-    130..131 'c': *const u32
-    137..138 'd': *mut u32
-    144..146 '*d': u32
-    145..146 'd': *mut u32
-    "###
+    check_infer(
+        r#"
+        fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
+            a;
+            *a;
+            &a;
+            &mut a;
+            b;
+            *b;
+            &b;
+            c;
+            *c;
+            d;
+            *d;
+        }
+        "#,
+        expect![[r#"
+            8..9 'a': &u32
+            17..18 'b': &mut u32
+            30..31 'c': *const u32
+            45..46 'd': *mut u32
+            58..149 '{     ... *d; }': ()
+            64..65 'a': &u32
+            71..73 '*a': u32
+            72..73 'a': &u32
+            79..81 '&a': &&u32
+            80..81 'a': &u32
+            87..93 '&mut a': &mut &u32
+            92..93 'a': &u32
+            99..100 'b': &mut u32
+            106..108 '*b': u32
+            107..108 'b': &mut u32
+            114..116 '&b': &&mut u32
+            115..116 'b': &mut u32
+            122..123 'c': *const u32
+            129..131 '*c': u32
+            130..131 'c': *const u32
+            137..138 'd': *mut u32
+            144..146 '*d': u32
+            145..146 'd': *mut u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_raw_ref() {
-    assert_snapshot!(
-        infer(r#"
-fn test(a: i32) {
-    &raw mut a;
-    &raw const a;
-}
-"#),
-        @r###"
-    8..9 'a': i32
-    16..53 '{     ...t a; }': ()
-    22..32 '&raw mut a': *mut i32
-    31..32 'a': i32
-    38..50 '&raw const a': *const i32
-    49..50 'a': i32
-    "###
+    check_infer(
+        r#"
+        fn test(a: i32) {
+            &raw mut a;
+            &raw const a;
+        }
+        "#,
+        expect![[r#"
+            8..9 'a': i32
+            16..53 '{     ...t a; }': ()
+            22..32 '&raw mut a': *mut i32
+            31..32 'a': i32
+            38..50 '&raw const a': *const i32
+            49..50 'a': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_literals() {
-    assert_snapshot!(
-        infer(r##"
-fn test() {
-    5i32;
-    5f32;
-    5f64;
-    "hello";
-    b"bytes";
-    'c';
-    b'b';
-    3.14;
-    5000;
-    false;
-    true;
-    r#"
-        //! doc
-        // non-doc
-        mod foo {}
-        "#;
-    br#"yolo"#;
-}
-"##),
-        @r###"
-    10..220 '{     ...o"#; }': ()
-    16..20 '5i32': i32
-    26..30 '5f32': f32
-    36..40 '5f64': f64
-    46..53 '"hello"': &str
-    59..67 'b"bytes"': &[u8; _]
-    73..76 ''c'': char
-    82..86 'b'b'': u8
-    92..96 '3.14': f64
-    102..106 '5000': i32
-    112..117 'false': bool
-    123..127 'true': bool
-    133..201 'r#"   ...    "#': &str
-    207..217 'br#"yolo"#': &[u8; _]
-    "###
+    check_infer(
+        r##"
+        fn test() {
+            5i32;
+            5f32;
+            5f64;
+            "hello";
+            b"bytes";
+            'c';
+            b'b';
+            3.14;
+            5000;
+            false;
+            true;
+            r#"
+                //! doc
+                // non-doc
+                mod foo {}
+            "#;
+            br#"yolo"#;
+        }
+        "##,
+        expect![[r##"
+            10..216 '{     ...o"#; }': ()
+            16..20 '5i32': i32
+            26..30 '5f32': f32
+            36..40 '5f64': f64
+            46..53 '"hello"': &str
+            59..67 'b"bytes"': &[u8; _]
+            73..76 ''c'': char
+            82..86 'b'b'': u8
+            92..96 '3.14': f64
+            102..106 '5000': i32
+            112..117 'false': bool
+            123..127 'true': bool
+            133..197 'r#"   ...    "#': &str
+            203..213 'br#"yolo"#': &[u8; _]
+        "##]],
     );
 }
 
 #[test]
 fn infer_unary_op() {
-    assert_snapshot!(
-        infer(r#"
-enum SomeType {}
-
-fn test(x: SomeType) {
-    let b = false;
-    let c = !b;
-    let a = 100;
-    let d: i128 = -a;
-    let e = -100;
-    let f = !!!true;
-    let g = !42;
-    let h = !10u32;
-    let j = !a;
-    -3.14;
-    !3;
-    -x;
-    !x;
-    -"hello";
-    !"hello";
-}
-"#),
-        @r###"
-    26..27 'x': SomeType
-    39..271 '{     ...lo"; }': ()
-    49..50 'b': bool
-    53..58 'false': bool
-    68..69 'c': bool
-    72..74 '!b': bool
-    73..74 'b': bool
-    84..85 'a': i128
-    88..91 '100': i128
-    101..102 'd': i128
-    111..113 '-a': i128
-    112..113 'a': i128
-    123..124 'e': i32
-    127..131 '-100': i32
-    128..131 '100': i32
-    141..142 'f': bool
-    145..152 '!!!true': bool
-    146..152 '!!true': bool
-    147..152 '!true': bool
-    148..152 'true': bool
-    162..163 'g': i32
-    166..169 '!42': i32
-    167..169 '42': i32
-    179..180 'h': u32
-    183..189 '!10u32': u32
-    184..189 '10u32': u32
-    199..200 'j': i128
-    203..205 '!a': i128
-    204..205 'a': i128
-    211..216 '-3.14': f64
-    212..216 '3.14': f64
-    222..224 '!3': i32
-    223..224 '3': i32
-    230..232 '-x': {unknown}
-    231..232 'x': SomeType
-    238..240 '!x': {unknown}
-    239..240 'x': SomeType
-    246..254 '-"hello"': {unknown}
-    247..254 '"hello"': &str
-    260..268 '!"hello"': {unknown}
-    261..268 '"hello"': &str
-    "###
+    check_infer(
+        r#"
+        enum SomeType {}
+
+        fn test(x: SomeType) {
+            let b = false;
+            let c = !b;
+            let a = 100;
+            let d: i128 = -a;
+            let e = -100;
+            let f = !!!true;
+            let g = !42;
+            let h = !10u32;
+            let j = !a;
+            -3.14;
+            !3;
+            -x;
+            !x;
+            -"hello";
+            !"hello";
+        }
+        "#,
+        expect![[r#"
+            26..27 'x': SomeType
+            39..271 '{     ...lo"; }': ()
+            49..50 'b': bool
+            53..58 'false': bool
+            68..69 'c': bool
+            72..74 '!b': bool
+            73..74 'b': bool
+            84..85 'a': i128
+            88..91 '100': i128
+            101..102 'd': i128
+            111..113 '-a': i128
+            112..113 'a': i128
+            123..124 'e': i32
+            127..131 '-100': i32
+            128..131 '100': i32
+            141..142 'f': bool
+            145..152 '!!!true': bool
+            146..152 '!!true': bool
+            147..152 '!true': bool
+            148..152 'true': bool
+            162..163 'g': i32
+            166..169 '!42': i32
+            167..169 '42': i32
+            179..180 'h': u32
+            183..189 '!10u32': u32
+            184..189 '10u32': u32
+            199..200 'j': i128
+            203..205 '!a': i128
+            204..205 'a': i128
+            211..216 '-3.14': f64
+            212..216 '3.14': f64
+            222..224 '!3': i32
+            223..224 '3': i32
+            230..232 '-x': {unknown}
+            231..232 'x': SomeType
+            238..240 '!x': {unknown}
+            239..240 'x': SomeType
+            246..254 '-"hello"': {unknown}
+            247..254 '"hello"': &str
+            260..268 '!"hello"': {unknown}
+            261..268 '"hello"': &str
+        "#]],
     );
 }
 
 #[test]
 fn infer_backwards() {
-    assert_snapshot!(
-        infer(r#"
-fn takes_u32(x: u32) {}
-
-struct S { i32_field: i32 }
-
-fn test() -> &mut &f64 {
-    let a = unknown_function();
-    takes_u32(a);
-    let b = unknown_function();
-    S { i32_field: b };
-    let c = unknown_function();
-    &mut &c
-}
-"#),
-        @r###"
-    13..14 'x': u32
-    21..23 '{}': ()
-    77..230 '{     ...t &c }': &mut &f64
-    87..88 'a': u32
-    91..107 'unknow...nction': {unknown}
-    91..109 'unknow...tion()': u32
-    115..124 'takes_u32': fn takes_u32(u32)
-    115..127 'takes_u32(a)': ()
-    125..126 'a': u32
-    137..138 'b': i32
-    141..157 'unknow...nction': {unknown}
-    141..159 'unknow...tion()': i32
-    165..183 'S { i3...d: b }': S
-    180..181 'b': i32
-    193..194 'c': f64
-    197..213 'unknow...nction': {unknown}
-    197..215 'unknow...tion()': f64
-    221..228 '&mut &c': &mut &f64
-    226..228 '&c': &f64
-    227..228 'c': f64
-    "###
+    check_infer(
+        r#"
+        fn takes_u32(x: u32) {}
+
+        struct S { i32_field: i32 }
+
+        fn test() -> &mut &f64 {
+            let a = unknown_function();
+            takes_u32(a);
+            let b = unknown_function();
+            S { i32_field: b };
+            let c = unknown_function();
+            &mut &c
+        }
+        "#,
+        expect![[r#"
+            13..14 'x': u32
+            21..23 '{}': ()
+            77..230 '{     ...t &c }': &mut &f64
+            87..88 'a': u32
+            91..107 'unknow...nction': {unknown}
+            91..109 'unknow...tion()': u32
+            115..124 'takes_u32': fn takes_u32(u32)
+            115..127 'takes_u32(a)': ()
+            125..126 'a': u32
+            137..138 'b': i32
+            141..157 'unknow...nction': {unknown}
+            141..159 'unknow...tion()': i32
+            165..183 'S { i3...d: b }': S
+            180..181 'b': i32
+            193..194 'c': f64
+            197..213 'unknow...nction': {unknown}
+            197..215 'unknow...tion()': f64
+            221..228 '&mut &c': &mut &f64
+            226..228 '&c': &f64
+            227..228 'c': f64
+        "#]],
     );
 }
 
 #[test]
 fn infer_self() {
-    assert_snapshot!(
-        infer(r#"
-struct S;
+    check_infer(
+        r#"
+        struct S;
 
-impl S {
-    fn test(&self) {
-        self;
-    }
-    fn test2(self: &Self) {
-        self;
-    }
-    fn test3() -> Self {
-        S {}
-    }
-    fn test4() -> Self {
-        Self {}
-    }
-}
-"#),
-        @r###"
-    33..37 'self': &S
-    39..60 '{     ...     }': ()
-    49..53 'self': &S
-    74..78 'self': &S
-    87..108 '{     ...     }': ()
-    97..101 'self': &S
-    132..152 '{     ...     }': S
-    142..146 'S {}': S
-    176..199 '{     ...     }': S
-    186..193 'Self {}': S
-    "###
+        impl S {
+            fn test(&self) {
+                self;
+            }
+            fn test2(self: &Self) {
+                self;
+            }
+            fn test3() -> Self {
+                S {}
+            }
+            fn test4() -> Self {
+                Self {}
+            }
+        }
+        "#,
+        expect![[r#"
+            33..37 'self': &S
+            39..60 '{     ...     }': ()
+            49..53 'self': &S
+            74..78 'self': &S
+            87..108 '{     ...     }': ()
+            97..101 'self': &S
+            132..152 '{     ...     }': S
+            142..146 'S {}': S
+            176..199 '{     ...     }': S
+            186..193 'Self {}': S
+        "#]],
     );
 }
 
 #[test]
 fn infer_self_as_path() {
-    assert_snapshot!(
-        infer(r#"
-struct S1;
-struct S2(isize);
-enum E {
-    V1,
-    V2(u32),
-}
-
-impl S1 {
-    fn test() {
-        Self;
-    }
-}
-impl S2 {
-    fn test() {
-        Self(1);
-    }
-}
-impl E {
-    fn test() {
-        Self::V1;
-        Self::V2(1);
-    }
-}
-"#),
-        @r###"
-    86..107 '{     ...     }': ()
-    96..100 'Self': S1
-    134..158 '{     ...     }': ()
-    144..148 'Self': S2(isize) -> S2
-    144..151 'Self(1)': S2
-    149..150 '1': isize
-    184..230 '{     ...     }': ()
-    194..202 'Self::V1': E
-    212..220 'Self::V2': V2(u32) -> E
-    212..223 'Self::V2(1)': E
-    221..222 '1': u32
-    "###
+    check_infer(
+        r#"
+        struct S1;
+        struct S2(isize);
+        enum E {
+            V1,
+            V2(u32),
+        }
+
+        impl S1 {
+            fn test() {
+                Self;
+            }
+        }
+        impl S2 {
+            fn test() {
+                Self(1);
+            }
+        }
+        impl E {
+            fn test() {
+                Self::V1;
+                Self::V2(1);
+            }
+        }
+        "#,
+        expect![[r#"
+            86..107 '{     ...     }': ()
+            96..100 'Self': S1
+            134..158 '{     ...     }': ()
+            144..148 'Self': S2(isize) -> S2
+            144..151 'Self(1)': S2
+            149..150 '1': isize
+            184..230 '{     ...     }': ()
+            194..202 'Self::V1': E
+            212..220 'Self::V2': V2(u32) -> E
+            212..223 'Self::V2(1)': E
+            221..222 '1': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_binary_op() {
-    assert_snapshot!(
-        infer(r#"
-fn f(x: bool) -> i32 {
-    0i32
-}
-
-fn test() -> bool {
-    let x = a && b;
-    let y = true || false;
-    let z = x == y;
-    let t = x != y;
-    let minus_forty: isize = -40isize;
-    let h = minus_forty <= CONST_2;
-    let c = f(z || y) + 5;
-    let d = b;
-    let g = minus_forty ^= i;
-    let ten: usize = 10;
-    let ten_is_eleven = ten == some_num;
-
-    ten < 3
-}
-"#),
-        @r###"
-    5..6 'x': bool
-    21..33 '{     0i32 }': i32
-    27..31 '0i32': i32
-    53..369 '{     ... < 3 }': bool
-    63..64 'x': bool
-    67..68 'a': bool
-    67..73 'a && b': bool
-    72..73 'b': bool
-    83..84 'y': bool
-    87..91 'true': bool
-    87..100 'true || false': bool
-    95..100 'false': bool
-    110..111 'z': bool
-    114..115 'x': bool
-    114..120 'x == y': bool
-    119..120 'y': bool
-    130..131 't': bool
-    134..135 'x': bool
-    134..140 'x != y': bool
-    139..140 'y': bool
-    150..161 'minus_forty': isize
-    171..179 '-40isize': isize
-    172..179 '40isize': isize
-    189..190 'h': bool
-    193..204 'minus_forty': isize
-    193..215 'minus_...ONST_2': bool
-    208..215 'CONST_2': isize
-    225..226 'c': i32
-    229..230 'f': fn f(bool) -> i32
-    229..238 'f(z || y)': i32
-    229..242 'f(z || y) + 5': i32
-    231..232 'z': bool
-    231..237 'z || y': bool
-    236..237 'y': bool
-    241..242 '5': i32
-    252..253 'd': {unknown}
-    256..257 'b': {unknown}
-    267..268 'g': ()
-    271..282 'minus_forty': isize
-    271..287 'minus_...y ^= i': ()
-    286..287 'i': isize
-    297..300 'ten': usize
-    310..312 '10': usize
-    322..335 'ten_is_eleven': bool
-    338..341 'ten': usize
-    338..353 'ten == some_num': bool
-    345..353 'some_num': usize
-    360..363 'ten': usize
-    360..367 'ten < 3': bool
-    366..367 '3': usize
-    "###
+    check_infer(
+        r#"
+        fn f(x: bool) -> i32 {
+            0i32
+        }
+
+        fn test() -> bool {
+            let x = a && b;
+            let y = true || false;
+            let z = x == y;
+            let t = x != y;
+            let minus_forty: isize = -40isize;
+            let h = minus_forty <= CONST_2;
+            let c = f(z || y) + 5;
+            let d = b;
+            let g = minus_forty ^= i;
+            let ten: usize = 10;
+            let ten_is_eleven = ten == some_num;
+
+            ten < 3
+        }
+        "#,
+        expect![[r#"
+            5..6 'x': bool
+            21..33 '{     0i32 }': i32
+            27..31 '0i32': i32
+            53..369 '{     ... < 3 }': bool
+            63..64 'x': bool
+            67..68 'a': bool
+            67..73 'a && b': bool
+            72..73 'b': bool
+            83..84 'y': bool
+            87..91 'true': bool
+            87..100 'true || false': bool
+            95..100 'false': bool
+            110..111 'z': bool
+            114..115 'x': bool
+            114..120 'x == y': bool
+            119..120 'y': bool
+            130..131 't': bool
+            134..135 'x': bool
+            134..140 'x != y': bool
+            139..140 'y': bool
+            150..161 'minus_forty': isize
+            171..179 '-40isize': isize
+            172..179 '40isize': isize
+            189..190 'h': bool
+            193..204 'minus_forty': isize
+            193..215 'minus_...ONST_2': bool
+            208..215 'CONST_2': isize
+            225..226 'c': i32
+            229..230 'f': fn f(bool) -> i32
+            229..238 'f(z || y)': i32
+            229..242 'f(z || y) + 5': i32
+            231..232 'z': bool
+            231..237 'z || y': bool
+            236..237 'y': bool
+            241..242 '5': i32
+            252..253 'd': {unknown}
+            256..257 'b': {unknown}
+            267..268 'g': ()
+            271..282 'minus_forty': isize
+            271..287 'minus_...y ^= i': ()
+            286..287 'i': isize
+            297..300 'ten': usize
+            310..312 '10': usize
+            322..335 'ten_is_eleven': bool
+            338..341 'ten': usize
+            338..353 'ten == some_num': bool
+            345..353 'some_num': usize
+            360..363 'ten': usize
+            360..367 'ten < 3': bool
+            366..367 '3': usize
+        "#]],
     );
 }
 
 #[test]
 fn infer_shift_op() {
-    assert_snapshot!(
-        infer(r#"
-fn test() {
-    1u32 << 5u8;
-    1u32 >> 5u8;
-}
-"#),
-        @r###"
-    10..47 '{     ...5u8; }': ()
-    16..20 '1u32': u32
-    16..27 '1u32 << 5u8': u32
-    24..27 '5u8': u8
-    33..37 '1u32': u32
-    33..44 '1u32 >> 5u8': u32
-    41..44 '5u8': u8
-    "###
+    check_infer(
+        r#"
+        fn test() {
+            1u32 << 5u8;
+            1u32 >> 5u8;
+        }
+        "#,
+        expect![[r#"
+            10..47 '{     ...5u8; }': ()
+            16..20 '1u32': u32
+            16..27 '1u32 << 5u8': u32
+            24..27 '5u8': u8
+            33..37 '1u32': u32
+            33..44 '1u32 >> 5u8': u32
+            41..44 '5u8': u8
+        "#]],
     );
 }
 
 #[test]
 fn infer_field_autoderef() {
-    assert_snapshot!(
-        infer(r#"
-struct A {
-    b: B,
-}
-struct B;
-
-fn test1(a: A) {
-    let a1 = a;
-    a1.b;
-    let a2 = &a;
-    a2.b;
-    let a3 = &mut a;
-    a3.b;
-    let a4 = &&&&&&&a;
-    a4.b;
-    let a5 = &mut &&mut &&mut a;
-    a5.b;
-}
-
-fn test2(a1: *const A, a2: *mut A) {
-    a1.b;
-    a2.b;
-}
-"#),
-        @r###"
-    43..44 'a': A
-    49..212 '{     ...5.b; }': ()
-    59..61 'a1': A
-    64..65 'a': A
-    71..73 'a1': A
-    71..75 'a1.b': B
-    85..87 'a2': &A
-    90..92 '&a': &A
-    91..92 'a': A
-    98..100 'a2': &A
-    98..102 'a2.b': B
-    112..114 'a3': &mut A
-    117..123 '&mut a': &mut A
-    122..123 'a': A
-    129..131 'a3': &mut A
-    129..133 'a3.b': B
-    143..145 'a4': &&&&&&&A
-    148..156 '&&&&&&&a': &&&&&&&A
-    149..156 '&&&&&&a': &&&&&&A
-    150..156 '&&&&&a': &&&&&A
-    151..156 '&&&&a': &&&&A
-    152..156 '&&&a': &&&A
-    153..156 '&&a': &&A
-    154..156 '&a': &A
-    155..156 'a': A
-    162..164 'a4': &&&&&&&A
-    162..166 'a4.b': B
-    176..178 'a5': &mut &&mut &&mut A
-    181..199 '&mut &...&mut a': &mut &&mut &&mut A
-    186..199 '&&mut &&mut a': &&mut &&mut A
-    187..199 '&mut &&mut a': &mut &&mut A
-    192..199 '&&mut a': &&mut A
-    193..199 '&mut a': &mut A
-    198..199 'a': A
-    205..207 'a5': &mut &&mut &&mut A
-    205..209 'a5.b': B
-    223..225 'a1': *const A
-    237..239 'a2': *mut A
-    249..272 '{     ...2.b; }': ()
-    255..257 'a1': *const A
-    255..259 'a1.b': B
-    265..267 'a2': *mut A
-    265..269 'a2.b': B
-    "###
+    check_infer(
+        r#"
+        struct A {
+            b: B,
+        }
+        struct B;
+
+        fn test1(a: A) {
+            let a1 = a;
+            a1.b;
+            let a2 = &a;
+            a2.b;
+            let a3 = &mut a;
+            a3.b;
+            let a4 = &&&&&&&a;
+            a4.b;
+            let a5 = &mut &&mut &&mut a;
+            a5.b;
+        }
+
+        fn test2(a1: *const A, a2: *mut A) {
+            a1.b;
+            a2.b;
+        }
+        "#,
+        expect![[r#"
+            43..44 'a': A
+            49..212 '{     ...5.b; }': ()
+            59..61 'a1': A
+            64..65 'a': A
+            71..73 'a1': A
+            71..75 'a1.b': B
+            85..87 'a2': &A
+            90..92 '&a': &A
+            91..92 'a': A
+            98..100 'a2': &A
+            98..102 'a2.b': B
+            112..114 'a3': &mut A
+            117..123 '&mut a': &mut A
+            122..123 'a': A
+            129..131 'a3': &mut A
+            129..133 'a3.b': B
+            143..145 'a4': &&&&&&&A
+            148..156 '&&&&&&&a': &&&&&&&A
+            149..156 '&&&&&&a': &&&&&&A
+            150..156 '&&&&&a': &&&&&A
+            151..156 '&&&&a': &&&&A
+            152..156 '&&&a': &&&A
+            153..156 '&&a': &&A
+            154..156 '&a': &A
+            155..156 'a': A
+            162..164 'a4': &&&&&&&A
+            162..166 'a4.b': B
+            176..178 'a5': &mut &&mut &&mut A
+            181..199 '&mut &...&mut a': &mut &&mut &&mut A
+            186..199 '&&mut &&mut a': &&mut &&mut A
+            187..199 '&mut &&mut a': &mut &&mut A
+            192..199 '&&mut a': &&mut A
+            193..199 '&mut a': &mut A
+            198..199 'a': A
+            205..207 'a5': &mut &&mut &&mut A
+            205..209 'a5.b': B
+            223..225 'a1': *const A
+            237..239 'a2': *mut A
+            249..272 '{     ...2.b; }': ()
+            255..257 'a1': *const A
+            255..259 'a1.b': B
+            265..267 'a2': *mut A
+            265..269 'a2.b': B
+        "#]],
     );
 }
 
 #[test]
 fn infer_argument_autoderef() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
+    check_infer(
+        r#"
+        #[lang = "deref"]
+        pub trait Deref {
+            type Target;
+            fn deref(&self) -> &Self::Target;
+        }
 
-struct A<T>(T);
+        struct A<T>(T);
 
-impl<T> A<T> {
-    fn foo(&self) -> &T {
-        &self.0
-    }
-}
+        impl<T> A<T> {
+            fn foo(&self) -> &T {
+                &self.0
+            }
+        }
 
-struct B<T>(T);
+        struct B<T>(T);
 
-impl<T> Deref for B<T> {
-    type Target = T;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+        impl<T> Deref for B<T> {
+            type Target = T;
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
 
-fn test() {
-    let t = A::foo(&&B(B(A(42))));
-}
-"#),
-        @r###"
-    67..71 'self': &Self
-    138..142 'self': &A<T>
-    150..173 '{     ...     }': &T
-    160..167 '&self.0': &T
-    161..165 'self': &A<T>
-    161..167 'self.0': T
-    254..258 'self': &B<T>
-    277..300 '{     ...     }': &T
-    287..294 '&self.0': &T
-    288..292 'self': &B<T>
-    288..294 'self.0': T
-    314..352 '{     ...))); }': ()
-    324..325 't': &i32
-    328..334 'A::foo': fn foo<i32>(&A<i32>) -> &i32
-    328..349 'A::foo...42))))': &i32
-    335..348 '&&B(B(A(42)))': &&B<B<A<i32>>>
-    336..348 '&B(B(A(42)))': &B<B<A<i32>>>
-    337..338 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-    337..348 'B(B(A(42)))': B<B<A<i32>>>
-    339..340 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-    339..347 'B(A(42))': B<A<i32>>
-    341..342 'A': A<i32>(i32) -> A<i32>
-    341..346 'A(42)': A<i32>
-    343..345 '42': i32
-    "###
+        fn test() {
+            let t = A::foo(&&B(B(A(42))));
+        }
+        "#,
+        expect![[r#"
+            67..71 'self': &Self
+            138..142 'self': &A<T>
+            150..173 '{     ...     }': &T
+            160..167 '&self.0': &T
+            161..165 'self': &A<T>
+            161..167 'self.0': T
+            254..258 'self': &B<T>
+            277..300 '{     ...     }': &T
+            287..294 '&self.0': &T
+            288..292 'self': &B<T>
+            288..294 'self.0': T
+            314..352 '{     ...))); }': ()
+            324..325 't': &i32
+            328..334 'A::foo': fn foo<i32>(&A<i32>) -> &i32
+            328..349 'A::foo...42))))': &i32
+            335..348 '&&B(B(A(42)))': &&B<B<A<i32>>>
+            336..348 '&B(B(A(42)))': &B<B<A<i32>>>
+            337..338 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+            337..348 'B(B(A(42)))': B<B<A<i32>>>
+            339..340 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+            339..347 'B(A(42))': B<A<i32>>
+            341..342 'A': A<i32>(i32) -> A<i32>
+            341..346 'A(42)': A<i32>
+            343..345 '42': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_method_argument_autoderef() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "deref"]
-pub trait Deref {
-    type Target;
-    fn deref(&self) -> &Self::Target;
-}
+    check_infer(
+        r#"
+        #[lang = "deref"]
+        pub trait Deref {
+            type Target;
+            fn deref(&self) -> &Self::Target;
+        }
 
-struct A<T>(*mut T);
+        struct A<T>(*mut T);
 
-impl<T> A<T> {
-    fn foo(&self, x: &A<T>) -> &T {
-        &*x.0
-    }
-}
+        impl<T> A<T> {
+            fn foo(&self, x: &A<T>) -> &T {
+                &*x.0
+            }
+        }
 
-struct B<T>(T);
+        struct B<T>(T);
 
-impl<T> Deref for B<T> {
-    type Target = T;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+        impl<T> Deref for B<T> {
+            type Target = T;
+            fn deref(&self) -> &Self::Target {
+                &self.0
+            }
+        }
 
-fn test(a: A<i32>) {
-    let t = A(0 as *mut _).foo(&&B(B(a)));
-}
-"#),
-        @r###"
-    67..71 'self': &Self
-    143..147 'self': &A<T>
-    149..150 'x': &A<T>
-    165..186 '{     ...     }': &T
-    175..180 '&*x.0': &T
-    176..180 '*x.0': T
-    177..178 'x': &A<T>
-    177..180 'x.0': *mut T
-    267..271 'self': &B<T>
-    290..313 '{     ...     }': &T
-    300..307 '&self.0': &T
-    301..305 'self': &B<T>
-    301..307 'self.0': T
-    325..326 'a': A<i32>
-    336..382 '{     ...))); }': ()
-    346..347 't': &i32
-    350..351 'A': A<i32>(*mut i32) -> A<i32>
-    350..364 'A(0 as *mut _)': A<i32>
-    350..379 'A(0 as...B(a)))': &i32
-    352..353 '0': i32
-    352..363 '0 as *mut _': *mut i32
-    369..378 '&&B(B(a))': &&B<B<A<i32>>>
-    370..378 '&B(B(a))': &B<B<A<i32>>>
-    371..372 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-    371..378 'B(B(a))': B<B<A<i32>>>
-    373..374 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-    373..377 'B(a)': B<A<i32>>
-    375..376 'a': A<i32>
-    "###
+        fn test(a: A<i32>) {
+            let t = A(0 as *mut _).foo(&&B(B(a)));
+        }
+        "#,
+        expect![[r#"
+            67..71 'self': &Self
+            143..147 'self': &A<T>
+            149..150 'x': &A<T>
+            165..186 '{     ...     }': &T
+            175..180 '&*x.0': &T
+            176..180 '*x.0': T
+            177..178 'x': &A<T>
+            177..180 'x.0': *mut T
+            267..271 'self': &B<T>
+            290..313 '{     ...     }': &T
+            300..307 '&self.0': &T
+            301..305 'self': &B<T>
+            301..307 'self.0': T
+            325..326 'a': A<i32>
+            336..382 '{     ...))); }': ()
+            346..347 't': &i32
+            350..351 'A': A<i32>(*mut i32) -> A<i32>
+            350..364 'A(0 as *mut _)': A<i32>
+            350..379 'A(0 as...B(a)))': &i32
+            352..353 '0': i32
+            352..363 '0 as *mut _': *mut i32
+            369..378 '&&B(B(a))': &&B<B<A<i32>>>
+            370..378 '&B(B(a))': &B<B<A<i32>>>
+            371..372 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+            371..378 'B(B(a))': B<B<A<i32>>>
+            373..374 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+            373..377 'B(a)': B<A<i32>>
+            375..376 'a': A<i32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_in_elseif() {
-    assert_snapshot!(
-        infer(r#"
-struct Foo { field: i32 }
-fn main(foo: Foo) {
-    if true {
-
-    } else if false {
-        foo.field
-    }
-}
-"#),
-        @r###"
-    34..37 'foo': Foo
-    44..108 '{     ...   } }': ()
-    50..106 'if tru...     }': ()
-    53..57 'true': bool
-    58..66 '{      }': ()
-    72..106 'if fal...     }': i32
-    75..80 'false': bool
-    81..106 '{     ...     }': i32
-    91..94 'foo': Foo
-    91..100 'foo.field': i32
-    "###
+    check_infer(
+        r#"
+        struct Foo { field: i32 }
+        fn main(foo: Foo) {
+            if true {
+
+            } else if false {
+                foo.field
+            }
+        }
+        "#,
+        expect![[r#"
+            34..37 'foo': Foo
+            44..108 '{     ...   } }': ()
+            50..106 'if tru...     }': ()
+            53..57 'true': bool
+            58..66 '{      }': ()
+            72..106 'if fal...     }': i32
+            75..80 'false': bool
+            81..106 '{     ...     }': i32
+            91..94 'foo': Foo
+            91..100 'foo.field': i32
+        "#]],
     )
 }
 
 #[test]
 fn infer_if_match_with_return() {
-    assert_snapshot!(
-        infer(r#"
-fn foo() {
-    let _x1 = if true {
-        1
-    } else {
-        return;
-    };
-    let _x2 = if true {
-        2
-    } else {
-        return
-    };
-    let _x3 = match true {
-        true => 3,
-        _ => {
-            return;
-        }
-    };
-    let _x4 = match true {
-        true => 4,
-        _ => return
-    };
-}"#),
-        @r###"
-    9..322 '{     ...  }; }': ()
-    19..22 '_x1': i32
-    25..79 'if tru...     }': i32
-    28..32 'true': bool
-    33..50 '{     ...     }': i32
-    43..44 '1': i32
-    56..79 '{     ...     }': i32
-    66..72 'return': !
-    89..92 '_x2': i32
-    95..148 'if tru...     }': i32
-    98..102 'true': bool
-    103..120 '{     ...     }': i32
-    113..114 '2': i32
-    126..148 '{     ...     }': !
-    136..142 'return': !
-    158..161 '_x3': i32
-    164..246 'match ...     }': i32
-    170..174 'true': bool
-    185..189 'true': bool
-    185..189 'true': bool
-    193..194 '3': i32
-    204..205 '_': bool
-    209..240 '{     ...     }': i32
-    223..229 'return': !
-    256..259 '_x4': i32
-    262..319 'match ...     }': i32
-    268..272 'true': bool
-    283..287 'true': bool
-    283..287 'true': bool
-    291..292 '4': i32
-    302..303 '_': bool
-    307..313 'return': !
-    "###
+    check_infer(
+        r#"
+        fn foo() {
+            let _x1 = if true {
+                1
+            } else {
+                return;
+            };
+            let _x2 = if true {
+                2
+            } else {
+                return
+            };
+            let _x3 = match true {
+                true => 3,
+                _ => {
+                    return;
+                }
+            };
+            let _x4 = match true {
+                true => 4,
+                _ => return
+            };
+        }"#,
+        expect![[r#"
+            9..322 '{     ...  }; }': ()
+            19..22 '_x1': i32
+            25..79 'if tru...     }': i32
+            28..32 'true': bool
+            33..50 '{     ...     }': i32
+            43..44 '1': i32
+            56..79 '{     ...     }': i32
+            66..72 'return': !
+            89..92 '_x2': i32
+            95..148 'if tru...     }': i32
+            98..102 'true': bool
+            103..120 '{     ...     }': i32
+            113..114 '2': i32
+            126..148 '{     ...     }': !
+            136..142 'return': !
+            158..161 '_x3': i32
+            164..246 'match ...     }': i32
+            170..174 'true': bool
+            185..189 'true': bool
+            185..189 'true': bool
+            193..194 '3': i32
+            204..205 '_': bool
+            209..240 '{     ...     }': i32
+            223..229 'return': !
+            256..259 '_x4': i32
+            262..319 'match ...     }': i32
+            268..272 'true': bool
+            283..287 'true': bool
+            283..287 'true': bool
+            291..292 '4': i32
+            302..303 '_': bool
+            307..313 'return': !
+        "#]],
     )
 }
 
 #[test]
 fn infer_inherent_method() {
-    assert_snapshot!(
-        infer(r#"
-struct A;
+    check_infer(
+        r#"
+        struct A;
 
-impl A {
-    fn foo(self, x: u32) -> i32 {}
-}
+        impl A {
+            fn foo(self, x: u32) -> i32 {}
+        }
 
-mod b {
-    impl super::A {
-        fn bar(&self, x: u64) -> i64 {}
-    }
-}
+        mod b {
+            impl super::A {
+                fn bar(&self, x: u64) -> i64 {}
+            }
+        }
 
-fn test(a: A) {
-    a.foo(1);
-    (&a).bar(1);
-    a.bar(1);
-}
-"#),
-        @r###"
-    31..35 'self': A
-    37..38 'x': u32
-    52..54 '{}': ()
-    102..106 'self': &A
-    108..109 'x': u64
-    123..125 '{}': ()
-    143..144 'a': A
-    149..197 '{     ...(1); }': ()
-    155..156 'a': A
-    155..163 'a.foo(1)': i32
-    161..162 '1': u32
-    169..180 '(&a).bar(1)': i64
-    170..172 '&a': &A
-    171..172 'a': A
-    178..179 '1': u64
-    186..187 'a': A
-    186..194 'a.bar(1)': i64
-    192..193 '1': u64
-    "###
+        fn test(a: A) {
+            a.foo(1);
+            (&a).bar(1);
+            a.bar(1);
+        }
+        "#,
+        expect![[r#"
+            31..35 'self': A
+            37..38 'x': u32
+            52..54 '{}': ()
+            102..106 'self': &A
+            108..109 'x': u64
+            123..125 '{}': ()
+            143..144 'a': A
+            149..197 '{     ...(1); }': ()
+            155..156 'a': A
+            155..163 'a.foo(1)': i32
+            161..162 '1': u32
+            169..180 '(&a).bar(1)': i64
+            170..172 '&a': &A
+            171..172 'a': A
+            178..179 '1': u64
+            186..187 'a': A
+            186..194 'a.bar(1)': i64
+            192..193 '1': u64
+        "#]],
     );
 }
 
 #[test]
 fn infer_inherent_method_str() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "str"]
-impl str {
-    fn foo(&self) -> i32 {}
-}
+    check_infer(
+        r#"
+        #[lang = "str"]
+        impl str {
+            fn foo(&self) -> i32 {}
+        }
 
-fn test() {
-    "foo".foo();
-}
-"#),
-        @r###"
-    39..43 'self': &str
-    52..54 '{}': ()
-    68..88 '{     ...o(); }': ()
-    74..79 '"foo"': &str
-    74..85 '"foo".foo()': i32
-    "###
+        fn test() {
+            "foo".foo();
+        }
+        "#,
+        expect![[r#"
+            39..43 'self': &str
+            52..54 '{}': ()
+            68..88 '{     ...o(); }': ()
+            74..79 '"foo"': &str
+            74..85 '"foo".foo()': i32
+        "#]],
     );
 }
 
 #[test]
 fn infer_tuple() {
-    assert_snapshot!(
-        infer(r#"
-fn test(x: &str, y: isize) {
-    let a: (u32, &str) = (1, "a");
-    let b = (a, x);
-    let c = (y, x);
-    let d = (c, x);
-    let e = (1, "e");
-    let f = (e, "d");
-}
-"#),
-        @r###"
-    8..9 'x': &str
-    17..18 'y': isize
-    27..169 '{     ...d"); }': ()
-    37..38 'a': (u32, &str)
-    54..62 '(1, "a")': (u32, &str)
-    55..56 '1': u32
-    58..61 '"a"': &str
-    72..73 'b': ((u32, &str), &str)
-    76..82 '(a, x)': ((u32, &str), &str)
-    77..78 'a': (u32, &str)
-    80..81 'x': &str
-    92..93 'c': (isize, &str)
-    96..102 '(y, x)': (isize, &str)
-    97..98 'y': isize
-    100..101 'x': &str
-    112..113 'd': ((isize, &str), &str)
-    116..122 '(c, x)': ((isize, &str), &str)
-    117..118 'c': (isize, &str)
-    120..121 'x': &str
-    132..133 'e': (i32, &str)
-    136..144 '(1, "e")': (i32, &str)
-    137..138 '1': i32
-    140..143 '"e"': &str
-    154..155 'f': ((i32, &str), &str)
-    158..166 '(e, "d")': ((i32, &str), &str)
-    159..160 'e': (i32, &str)
-    162..165 '"d"': &str
-    "###
+    check_infer(
+        r#"
+        fn test(x: &str, y: isize) {
+            let a: (u32, &str) = (1, "a");
+            let b = (a, x);
+            let c = (y, x);
+            let d = (c, x);
+            let e = (1, "e");
+            let f = (e, "d");
+        }
+        "#,
+        expect![[r#"
+            8..9 'x': &str
+            17..18 'y': isize
+            27..169 '{     ...d"); }': ()
+            37..38 'a': (u32, &str)
+            54..62 '(1, "a")': (u32, &str)
+            55..56 '1': u32
+            58..61 '"a"': &str
+            72..73 'b': ((u32, &str), &str)
+            76..82 '(a, x)': ((u32, &str), &str)
+            77..78 'a': (u32, &str)
+            80..81 'x': &str
+            92..93 'c': (isize, &str)
+            96..102 '(y, x)': (isize, &str)
+            97..98 'y': isize
+            100..101 'x': &str
+            112..113 'd': ((isize, &str), &str)
+            116..122 '(c, x)': ((isize, &str), &str)
+            117..118 'c': (isize, &str)
+            120..121 'x': &str
+            132..133 'e': (i32, &str)
+            136..144 '(1, "e")': (i32, &str)
+            137..138 '1': i32
+            140..143 '"e"': &str
+            154..155 'f': ((i32, &str), &str)
+            158..166 '(e, "d")': ((i32, &str), &str)
+            159..160 'e': (i32, &str)
+            162..165 '"d"': &str
+        "#]],
     );
 }
 
 #[test]
 fn infer_array() {
-    assert_snapshot!(
-        infer(r#"
-fn test(x: &str, y: isize) {
-    let a = [x];
-    let b = [a, a];
-    let c = [b, b];
-
-    let d = [y, 1, 2, 3];
-    let d = [1, y, 2, 3];
-    let e = [y];
-    let f = [d, d];
-    let g = [e, e];
-
-    let h = [1, 2];
-    let i = ["a", "b"];
-
-    let b = [a, ["b"]];
-    let x: [u8; 0] = [];
-}
-"#),
-        @r###"
-    8..9 'x': &str
-    17..18 'y': isize
-    27..292 '{     ... []; }': ()
-    37..38 'a': [&str; _]
-    41..44 '[x]': [&str; _]
-    42..43 'x': &str
-    54..55 'b': [[&str; _]; _]
-    58..64 '[a, a]': [[&str; _]; _]
-    59..60 'a': [&str; _]
-    62..63 'a': [&str; _]
-    74..75 'c': [[[&str; _]; _]; _]
-    78..84 '[b, b]': [[[&str; _]; _]; _]
-    79..80 'b': [[&str; _]; _]
-    82..83 'b': [[&str; _]; _]
-    95..96 'd': [isize; _]
-    99..111 '[y, 1, 2, 3]': [isize; _]
-    100..101 'y': isize
-    103..104 '1': isize
-    106..107 '2': isize
-    109..110 '3': isize
-    121..122 'd': [isize; _]
-    125..137 '[1, y, 2, 3]': [isize; _]
-    126..127 '1': isize
-    129..130 'y': isize
-    132..133 '2': isize
-    135..136 '3': isize
-    147..148 'e': [isize; _]
-    151..154 '[y]': [isize; _]
-    152..153 'y': isize
-    164..165 'f': [[isize; _]; _]
-    168..174 '[d, d]': [[isize; _]; _]
-    169..170 'd': [isize; _]
-    172..173 'd': [isize; _]
-    184..185 'g': [[isize; _]; _]
-    188..194 '[e, e]': [[isize; _]; _]
-    189..190 'e': [isize; _]
-    192..193 'e': [isize; _]
-    205..206 'h': [i32; _]
-    209..215 '[1, 2]': [i32; _]
-    210..211 '1': i32
-    213..214 '2': i32
-    225..226 'i': [&str; _]
-    229..239 '["a", "b"]': [&str; _]
-    230..233 '"a"': &str
-    235..238 '"b"': &str
-    250..251 'b': [[&str; _]; _]
-    254..264 '[a, ["b"]]': [[&str; _]; _]
-    255..256 'a': [&str; _]
-    258..263 '["b"]': [&str; _]
-    259..262 '"b"': &str
-    274..275 'x': [u8; _]
-    287..289 '[]': [u8; _]
-    "###
+    check_infer(
+        r#"
+        fn test(x: &str, y: isize) {
+            let a = [x];
+            let b = [a, a];
+            let c = [b, b];
+
+            let d = [y, 1, 2, 3];
+            let d = [1, y, 2, 3];
+            let e = [y];
+            let f = [d, d];
+            let g = [e, e];
+
+            let h = [1, 2];
+            let i = ["a", "b"];
+
+            let b = [a, ["b"]];
+            let x: [u8; 0] = [];
+        }
+        "#,
+        expect![[r#"
+            8..9 'x': &str
+            17..18 'y': isize
+            27..292 '{     ... []; }': ()
+            37..38 'a': [&str; _]
+            41..44 '[x]': [&str; _]
+            42..43 'x': &str
+            54..55 'b': [[&str; _]; _]
+            58..64 '[a, a]': [[&str; _]; _]
+            59..60 'a': [&str; _]
+            62..63 'a': [&str; _]
+            74..75 'c': [[[&str; _]; _]; _]
+            78..84 '[b, b]': [[[&str; _]; _]; _]
+            79..80 'b': [[&str; _]; _]
+            82..83 'b': [[&str; _]; _]
+            95..96 'd': [isize; _]
+            99..111 '[y, 1, 2, 3]': [isize; _]
+            100..101 'y': isize
+            103..104 '1': isize
+            106..107 '2': isize
+            109..110 '3': isize
+            121..122 'd': [isize; _]
+            125..137 '[1, y, 2, 3]': [isize; _]
+            126..127 '1': isize
+            129..130 'y': isize
+            132..133 '2': isize
+            135..136 '3': isize
+            147..148 'e': [isize; _]
+            151..154 '[y]': [isize; _]
+            152..153 'y': isize
+            164..165 'f': [[isize; _]; _]
+            168..174 '[d, d]': [[isize; _]; _]
+            169..170 'd': [isize; _]
+            172..173 'd': [isize; _]
+            184..185 'g': [[isize; _]; _]
+            188..194 '[e, e]': [[isize; _]; _]
+            189..190 'e': [isize; _]
+            192..193 'e': [isize; _]
+            205..206 'h': [i32; _]
+            209..215 '[1, 2]': [i32; _]
+            210..211 '1': i32
+            213..214 '2': i32
+            225..226 'i': [&str; _]
+            229..239 '["a", "b"]': [&str; _]
+            230..233 '"a"': &str
+            235..238 '"b"': &str
+            250..251 'b': [[&str; _]; _]
+            254..264 '[a, ["b"]]': [[&str; _]; _]
+            255..256 'a': [&str; _]
+            258..263 '["b"]': [&str; _]
+            259..262 '"b"': &str
+            274..275 'x': [u8; _]
+            287..289 '[]': [u8; _]
+        "#]],
     );
 }
 
 #[test]
 fn infer_struct_generics() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T> {
-    x: T,
-}
-
-fn test(a1: A<u32>, i: i32) {
-    a1.x;
-    let a2 = A { x: i };
-    a2.x;
-    let a3 = A::<i128> { x: 1 };
-    a3.x;
-}
-"#),
-        @r###"
-    35..37 'a1': A<u32>
-    47..48 'i': i32
-    55..146 '{     ...3.x; }': ()
-    61..63 'a1': A<u32>
-    61..65 'a1.x': u32
-    75..77 'a2': A<i32>
-    80..90 'A { x: i }': A<i32>
-    87..88 'i': i32
-    96..98 'a2': A<i32>
-    96..100 'a2.x': i32
-    110..112 'a3': A<i128>
-    115..133 'A::<i1...x: 1 }': A<i128>
-    130..131 '1': i128
-    139..141 'a3': A<i128>
-    139..143 'a3.x': i128
-    "###
+    check_infer(
+        r#"
+        struct A<T> {
+            x: T,
+        }
+
+        fn test(a1: A<u32>, i: i32) {
+            a1.x;
+            let a2 = A { x: i };
+            a2.x;
+            let a3 = A::<i128> { x: 1 };
+            a3.x;
+        }
+        "#,
+        expect![[r#"
+            35..37 'a1': A<u32>
+            47..48 'i': i32
+            55..146 '{     ...3.x; }': ()
+            61..63 'a1': A<u32>
+            61..65 'a1.x': u32
+            75..77 'a2': A<i32>
+            80..90 'A { x: i }': A<i32>
+            87..88 'i': i32
+            96..98 'a2': A<i32>
+            96..100 'a2.x': i32
+            110..112 'a3': A<i128>
+            115..133 'A::<i1...x: 1 }': A<i128>
+            130..131 '1': i128
+            139..141 'a3': A<i128>
+            139..143 'a3.x': i128
+        "#]],
     );
 }
 
 #[test]
 fn infer_tuple_struct_generics() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T>(T);
-enum Option<T> { Some(T), None }
-use Option::*;
-
-fn test() {
-    A(42);
-    A(42u128);
-    Some("x");
-    Option::Some("x");
-    None;
-    let x: Option<i64> = None;
-}
-"#),
-        @r###"
-    75..183 '{     ...one; }': ()
-    81..82 'A': A<i32>(i32) -> A<i32>
-    81..86 'A(42)': A<i32>
-    83..85 '42': i32
-    92..93 'A': A<u128>(u128) -> A<u128>
-    92..101 'A(42u128)': A<u128>
-    94..100 '42u128': u128
-    107..111 'Some': Some<&str>(&str) -> Option<&str>
-    107..116 'Some("x")': Option<&str>
-    112..115 '"x"': &str
-    122..134 'Option::Some': Some<&str>(&str) -> Option<&str>
-    122..139 'Option...e("x")': Option<&str>
-    135..138 '"x"': &str
-    145..149 'None': Option<{unknown}>
-    159..160 'x': Option<i64>
-    176..180 'None': Option<i64>
-    "###
+    check_infer(
+        r#"
+        struct A<T>(T);
+        enum Option<T> { Some(T), None }
+        use Option::*;
+
+        fn test() {
+            A(42);
+            A(42u128);
+            Some("x");
+            Option::Some("x");
+            None;
+            let x: Option<i64> = None;
+        }
+        "#,
+        expect![[r#"
+            75..183 '{     ...one; }': ()
+            81..82 'A': A<i32>(i32) -> A<i32>
+            81..86 'A(42)': A<i32>
+            83..85 '42': i32
+            92..93 'A': A<u128>(u128) -> A<u128>
+            92..101 'A(42u128)': A<u128>
+            94..100 '42u128': u128
+            107..111 'Some': Some<&str>(&str) -> Option<&str>
+            107..116 'Some("x")': Option<&str>
+            112..115 '"x"': &str
+            122..134 'Option::Some': Some<&str>(&str) -> Option<&str>
+            122..139 'Option...e("x")': Option<&str>
+            135..138 '"x"': &str
+            145..149 'None': Option<{unknown}>
+            159..160 'x': Option<i64>
+            176..180 'None': Option<i64>
+        "#]],
     );
 }
 
 #[test]
 fn infer_function_generics() {
-    assert_snapshot!(
-        infer(r#"
-fn id<T>(t: T) -> T { t }
+    check_infer(
+        r#"
+        fn id<T>(t: T) -> T { t }
 
-fn test() {
-    id(1u32);
-    id::<i128>(1);
-    let x: u64 = id(1);
-}
-"#),
-        @r###"
-    9..10 't': T
-    20..25 '{ t }': T
-    22..23 't': T
-    37..97 '{     ...(1); }': ()
-    43..45 'id': fn id<u32>(u32) -> u32
-    43..51 'id(1u32)': u32
-    46..50 '1u32': u32
-    57..67 'id::<i128>': fn id<i128>(i128) -> i128
-    57..70 'id::<i128>(1)': i128
-    68..69 '1': i128
-    80..81 'x': u64
-    89..91 'id': fn id<u64>(u64) -> u64
-    89..94 'id(1)': u64
-    92..93 '1': u64
-    "###
+        fn test() {
+            id(1u32);
+            id::<i128>(1);
+            let x: u64 = id(1);
+        }
+        "#,
+        expect![[r#"
+            9..10 't': T
+            20..25 '{ t }': T
+            22..23 't': T
+            37..97 '{     ...(1); }': ()
+            43..45 'id': fn id<u32>(u32) -> u32
+            43..51 'id(1u32)': u32
+            46..50 '1u32': u32
+            57..67 'id::<i128>': fn id<i128>(i128) -> i128
+            57..70 'id::<i128>(1)': i128
+            68..69 '1': i128
+            80..81 'x': u64
+            89..91 'id': fn id<u64>(u64) -> u64
+            89..94 'id(1)': u64
+            92..93 '1': u64
+        "#]],
     );
 }
 
 #[test]
 fn infer_impl_generics_basic() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T1, T2> {
-    x: T1,
-    y: T2,
-}
-impl<Y, X> A<X, Y> {
-    fn x(self) -> X {
-        self.x
-    }
-    fn y(self) -> Y {
-        self.y
-    }
-    fn z<T>(self, t: T) -> (X, Y, T) {
-        (self.x, self.y, t)
-    }
-}
+    check_infer(
+        r#"
+        struct A<T1, T2> {
+            x: T1,
+            y: T2,
+        }
+        impl<Y, X> A<X, Y> {
+            fn x(self) -> X {
+                self.x
+            }
+            fn y(self) -> Y {
+                self.y
+            }
+            fn z<T>(self, t: T) -> (X, Y, T) {
+                (self.x, self.y, t)
+            }
+        }
 
-fn test() -> i128 {
-    let a = A { x: 1u64, y: 1i64 };
-    a.x();
-    a.y();
-    a.z(1i128);
-    a.z::<u128>(1);
-}
-"#),
-        @r###"
-    73..77 'self': A<X, Y>
-    84..106 '{     ...     }': X
-    94..98 'self': A<X, Y>
-    94..100 'self.x': X
-    116..120 'self': A<X, Y>
-    127..149 '{     ...     }': Y
-    137..141 'self': A<X, Y>
-    137..143 'self.y': Y
-    162..166 'self': A<X, Y>
-    168..169 't': T
-    187..222 '{     ...     }': (X, Y, T)
-    197..216 '(self.....y, t)': (X, Y, T)
-    198..202 'self': A<X, Y>
-    198..204 'self.x': X
-    206..210 'self': A<X, Y>
-    206..212 'self.y': Y
-    214..215 't': T
-    244..341 '{     ...(1); }': ()
-    254..255 'a': A<u64, i64>
-    258..280 'A { x:...1i64 }': A<u64, i64>
-    265..269 '1u64': u64
-    274..278 '1i64': i64
-    286..287 'a': A<u64, i64>
-    286..291 'a.x()': u64
-    297..298 'a': A<u64, i64>
-    297..302 'a.y()': i64
-    308..309 'a': A<u64, i64>
-    308..318 'a.z(1i128)': (u64, i64, i128)
-    312..317 '1i128': i128
-    324..325 'a': A<u64, i64>
-    324..338 'a.z::<u128>(1)': (u64, i64, u128)
-    336..337 '1': u128
-    "###
+        fn test() -> i128 {
+            let a = A { x: 1u64, y: 1i64 };
+            a.x();
+            a.y();
+            a.z(1i128);
+            a.z::<u128>(1);
+        }
+        "#,
+        expect![[r#"
+            73..77 'self': A<X, Y>
+            84..106 '{     ...     }': X
+            94..98 'self': A<X, Y>
+            94..100 'self.x': X
+            116..120 'self': A<X, Y>
+            127..149 '{     ...     }': Y
+            137..141 'self': A<X, Y>
+            137..143 'self.y': Y
+            162..166 'self': A<X, Y>
+            168..169 't': T
+            187..222 '{     ...     }': (X, Y, T)
+            197..216 '(self.....y, t)': (X, Y, T)
+            198..202 'self': A<X, Y>
+            198..204 'self.x': X
+            206..210 'self': A<X, Y>
+            206..212 'self.y': Y
+            214..215 't': T
+            244..341 '{     ...(1); }': ()
+            254..255 'a': A<u64, i64>
+            258..280 'A { x:...1i64 }': A<u64, i64>
+            265..269 '1u64': u64
+            274..278 '1i64': i64
+            286..287 'a': A<u64, i64>
+            286..291 'a.x()': u64
+            297..298 'a': A<u64, i64>
+            297..302 'a.y()': i64
+            308..309 'a': A<u64, i64>
+            308..318 'a.z(1i128)': (u64, i64, i128)
+            312..317 '1i128': i128
+            324..325 'a': A<u64, i64>
+            324..338 'a.z::<u128>(1)': (u64, i64, u128)
+            336..337 '1': u128
+        "#]],
     );
 }
 
 #[test]
 fn infer_impl_generics_with_autoderef() {
-    assert_snapshot!(
-        infer(r#"
-enum Option<T> {
-    Some(T),
-    None,
-}
-impl<T> Option<T> {
-    fn as_ref(&self) -> Option<&T> {}
-}
-fn test(o: Option<u32>) {
-    (&o).as_ref();
-    o.as_ref();
-}
-"#),
-        @r###"
-    77..81 'self': &Option<T>
-    97..99 '{}': ()
-    110..111 'o': Option<u32>
-    126..164 '{     ...f(); }': ()
-    132..145 '(&o).as_ref()': Option<&u32>
-    133..135 '&o': &Option<u32>
-    134..135 'o': Option<u32>
-    151..152 'o': Option<u32>
-    151..161 'o.as_ref()': Option<&u32>
-    "###
+    check_infer(
+        r#"
+        enum Option<T> {
+            Some(T),
+            None,
+        }
+        impl<T> Option<T> {
+            fn as_ref(&self) -> Option<&T> {}
+        }
+        fn test(o: Option<u32>) {
+            (&o).as_ref();
+            o.as_ref();
+        }
+        "#,
+        expect![[r#"
+            77..81 'self': &Option<T>
+            97..99 '{}': ()
+            110..111 'o': Option<u32>
+            126..164 '{     ...f(); }': ()
+            132..145 '(&o).as_ref()': Option<&u32>
+            133..135 '&o': &Option<u32>
+            134..135 'o': Option<u32>
+            151..152 'o': Option<u32>
+            151..161 'o.as_ref()': Option<&u32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_generic_chain() {
-    assert_snapshot!(
-        infer(r#"
-struct A<T> {
-    x: T,
-}
-impl<T2> A<T2> {
-    fn x(self) -> T2 {
-        self.x
-    }
-}
-fn id<T>(t: T) -> T { t }
-
-fn test() -> i128 {
-     let x = 1;
-     let y = id(x);
-     let a = A { x: id(y) };
-     let z = id(a.x);
-     let b = A { x: z };
-     b.x()
-}
-"#),
-        @r###"
-    52..56 'self': A<T2>
-    64..86 '{     ...     }': T2
-    74..78 'self': A<T2>
-    74..80 'self.x': T2
-    98..99 't': T
-    109..114 '{ t }': T
-    111..112 't': T
-    134..260 '{     ....x() }': i128
-    145..146 'x': i128
-    149..150 '1': i128
-    161..162 'y': i128
-    165..167 'id': fn id<i128>(i128) -> i128
-    165..170 'id(x)': i128
-    168..169 'x': i128
-    181..182 'a': A<i128>
-    185..199 'A { x: id(y) }': A<i128>
-    192..194 'id': fn id<i128>(i128) -> i128
-    192..197 'id(y)': i128
-    195..196 'y': i128
-    210..211 'z': i128
-    214..216 'id': fn id<i128>(i128) -> i128
-    214..221 'id(a.x)': i128
-    217..218 'a': A<i128>
-    217..220 'a.x': i128
-    232..233 'b': A<i128>
-    236..246 'A { x: z }': A<i128>
-    243..244 'z': i128
-    253..254 'b': A<i128>
-    253..258 'b.x()': i128
-    "###
+    check_infer(
+        r#"
+        struct A<T> {
+            x: T,
+        }
+        impl<T2> A<T2> {
+            fn x(self) -> T2 {
+                self.x
+            }
+        }
+        fn id<T>(t: T) -> T { t }
+
+        fn test() -> i128 {
+            let x = 1;
+            let y = id(x);
+            let a = A { x: id(y) };
+            let z = id(a.x);
+            let b = A { x: z };
+            b.x()
+        }
+        "#,
+        expect![[r#"
+            52..56 'self': A<T2>
+            64..86 '{     ...     }': T2
+            74..78 'self': A<T2>
+            74..80 'self.x': T2
+            98..99 't': T
+            109..114 '{ t }': T
+            111..112 't': T
+            134..254 '{     ....x() }': i128
+            144..145 'x': i128
+            148..149 '1': i128
+            159..160 'y': i128
+            163..165 'id': fn id<i128>(i128) -> i128
+            163..168 'id(x)': i128
+            166..167 'x': i128
+            178..179 'a': A<i128>
+            182..196 'A { x: id(y) }': A<i128>
+            189..191 'id': fn id<i128>(i128) -> i128
+            189..194 'id(y)': i128
+            192..193 'y': i128
+            206..207 'z': i128
+            210..212 'id': fn id<i128>(i128) -> i128
+            210..217 'id(a.x)': i128
+            213..214 'a': A<i128>
+            213..216 'a.x': i128
+            227..228 'b': A<i128>
+            231..241 'A { x: z }': A<i128>
+            238..239 'z': i128
+            247..248 'b': A<i128>
+            247..252 'b.x()': i128
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_const() {
-    assert_snapshot!(
-        infer(r#"
-struct Struct;
+    check_infer(
+        r#"
+        struct Struct;
 
-impl Struct {
-    const FOO: u32 = 1;
-}
+        impl Struct {
+            const FOO: u32 = 1;
+        }
 
-enum Enum {}
+        enum Enum {}
 
-impl Enum {
-    const BAR: u32 = 2;
-}
+        impl Enum {
+            const BAR: u32 = 2;
+        }
 
-trait Trait {
-    const ID: u32;
-}
+        trait Trait {
+            const ID: u32;
+        }
 
-struct TraitTest;
+        struct TraitTest;
 
-impl Trait for TraitTest {
-    const ID: u32 = 5;
-}
+        impl Trait for TraitTest {
+            const ID: u32 = 5;
+        }
 
-fn test() {
-    let x = Struct::FOO;
-    let y = Enum::BAR;
-    let z = TraitTest::ID;
-}
-"#),
-        @r###"
-    51..52 '1': u32
-    104..105 '2': u32
-    212..213 '5': u32
-    228..306 '{     ...:ID; }': ()
-    238..239 'x': u32
-    242..253 'Struct::FOO': u32
-    263..264 'y': u32
-    267..276 'Enum::BAR': u32
-    286..287 'z': u32
-    290..303 'TraitTest::ID': u32
-    "###
+        fn test() {
+            let x = Struct::FOO;
+            let y = Enum::BAR;
+            let z = TraitTest::ID;
+        }
+        "#,
+        expect![[r#"
+            51..52 '1': u32
+            104..105 '2': u32
+            212..213 '5': u32
+            228..306 '{     ...:ID; }': ()
+            238..239 'x': u32
+            242..253 'Struct::FOO': u32
+            263..264 'y': u32
+            267..276 'Enum::BAR': u32
+            286..287 'z': u32
+            290..303 'TraitTest::ID': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_type_alias() {
-    assert_snapshot!(
-        infer(r#"
-struct A<X, Y> { x: X, y: Y }
-type Foo = A<u32, i128>;
-type Bar<T> = A<T, u128>;
-type Baz<U, V> = A<V, U>;
-fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
-    x.x;
-    x.y;
-    y.x;
-    y.y;
-    z.x;
-    z.y;
-}
-"#),
-        @r###"
-    115..116 'x': A<u32, i128>
-    123..124 'y': A<&str, u128>
-    137..138 'z': A<u8, i8>
-    153..210 '{     ...z.y; }': ()
-    159..160 'x': A<u32, i128>
-    159..162 'x.x': u32
-    168..169 'x': A<u32, i128>
-    168..171 'x.y': i128
-    177..178 'y': A<&str, u128>
-    177..180 'y.x': &str
-    186..187 'y': A<&str, u128>
-    186..189 'y.y': u128
-    195..196 'z': A<u8, i8>
-    195..198 'z.x': u8
-    204..205 'z': A<u8, i8>
-    204..207 'z.y': i8
-    "###
+    check_infer(
+        r#"
+        struct A<X, Y> { x: X, y: Y }
+        type Foo = A<u32, i128>;
+        type Bar<T> = A<T, u128>;
+        type Baz<U, V> = A<V, U>;
+        fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
+            x.x;
+            x.y;
+            y.x;
+            y.y;
+            z.x;
+            z.y;
+        }
+        "#,
+        expect![[r#"
+            115..116 'x': A<u32, i128>
+            123..124 'y': A<&str, u128>
+            137..138 'z': A<u8, i8>
+            153..210 '{     ...z.y; }': ()
+            159..160 'x': A<u32, i128>
+            159..162 'x.x': u32
+            168..169 'x': A<u32, i128>
+            168..171 'x.y': i128
+            177..178 'y': A<&str, u128>
+            177..180 'y.x': &str
+            186..187 'y': A<&str, u128>
+            186..189 'y.y': u128
+            195..196 'z': A<u8, i8>
+            195..198 'z.x': u8
+            204..205 'z': A<u8, i8>
+            204..207 'z.y': i8
+        "#]],
     )
 }
 
 #[test]
 fn recursive_type_alias() {
-    assert_snapshot!(
-        infer(r#"
-struct A<X> {}
-type Foo = Foo;
-type Bar = A<Bar>;
-fn test(x: Foo) {}
-"#),
-        @r###"
-    58..59 'x': {unknown}
-    66..68 '{}': ()
-    "###
+    check_infer(
+        r#"
+        struct A<X> {}
+        type Foo = Foo;
+        type Bar = A<Bar>;
+        fn test(x: Foo) {}
+        "#,
+        expect![[r#"
+            58..59 'x': {unknown}
+            66..68 '{}': ()
+        "#]],
     )
 }
 
 #[test]
 fn infer_type_param() {
-    assert_snapshot!(
-        infer(r#"
-fn id<T>(x: T) -> T {
-    x
-}
+    check_infer(
+        r#"
+        fn id<T>(x: T) -> T {
+            x
+        }
 
-fn clone<T>(x: &T) -> T {
-    *x
-}
+        fn clone<T>(x: &T) -> T {
+            *x
+        }
 
-fn test() {
-    let y = 10u32;
-    id(y);
-    let x: bool = clone(z);
-    id::<i128>(1);
-}
-"#),
-        @r###"
-    9..10 'x': T
-    20..29 '{     x }': T
-    26..27 'x': T
-    43..44 'x': &T
-    55..65 '{     *x }': T
-    61..63 '*x': T
-    62..63 'x': &T
-    77..157 '{     ...(1); }': ()
-    87..88 'y': u32
-    91..96 '10u32': u32
-    102..104 'id': fn id<u32>(u32) -> u32
-    102..107 'id(y)': u32
-    105..106 'y': u32
-    117..118 'x': bool
-    127..132 'clone': fn clone<bool>(&bool) -> bool
-    127..135 'clone(z)': bool
-    133..134 'z': &bool
-    141..151 'id::<i128>': fn id<i128>(i128) -> i128
-    141..154 'id::<i128>(1)': i128
-    152..153 '1': i128
-    "###
+        fn test() {
+            let y = 10u32;
+            id(y);
+            let x: bool = clone(z);
+            id::<i128>(1);
+        }
+        "#,
+        expect![[r#"
+            9..10 'x': T
+            20..29 '{     x }': T
+            26..27 'x': T
+            43..44 'x': &T
+            55..65 '{     *x }': T
+            61..63 '*x': T
+            62..63 'x': &T
+            77..157 '{     ...(1); }': ()
+            87..88 'y': u32
+            91..96 '10u32': u32
+            102..104 'id': fn id<u32>(u32) -> u32
+            102..107 'id(y)': u32
+            105..106 'y': u32
+            117..118 'x': bool
+            127..132 'clone': fn clone<bool>(&bool) -> bool
+            127..135 'clone(z)': bool
+            133..134 'z': &bool
+            141..151 'id::<i128>': fn id<i128>(i128) -> i128
+            141..154 'id::<i128>(1)': i128
+            152..153 '1': i128
+        "#]],
     );
 }
 
 #[test]
 fn infer_const() {
-    assert_snapshot!(
-        infer(r#"
-struct Foo;
-impl Foo { const ASSOC_CONST: u32 = 0; }
-const GLOBAL_CONST: u32 = 101;
-fn test() {
-    const LOCAL_CONST: u32 = 99;
-    let x = LOCAL_CONST;
-    let z = GLOBAL_CONST;
-    let id = Foo::ASSOC_CONST;
-}
-"#),
-        @r###"
-    48..49 '0': u32
-    79..82 '101': u32
-    94..212 '{     ...NST; }': ()
-    137..138 'x': u32
-    141..152 'LOCAL_CONST': u32
-    162..163 'z': u32
-    166..178 'GLOBAL_CONST': u32
-    188..190 'id': u32
-    193..209 'Foo::A..._CONST': u32
-    125..127 '99': u32
-    "###
+    check_infer(
+        r#"
+        struct Foo;
+        impl Foo { const ASSOC_CONST: u32 = 0; }
+        const GLOBAL_CONST: u32 = 101;
+        fn test() {
+            const LOCAL_CONST: u32 = 99;
+            let x = LOCAL_CONST;
+            let z = GLOBAL_CONST;
+            let id = Foo::ASSOC_CONST;
+        }
+        "#,
+        expect![[r#"
+            48..49 '0': u32
+            79..82 '101': u32
+            94..212 '{     ...NST; }': ()
+            137..138 'x': u32
+            141..152 'LOCAL_CONST': u32
+            162..163 'z': u32
+            166..178 'GLOBAL_CONST': u32
+            188..190 'id': u32
+            193..209 'Foo::A..._CONST': u32
+            125..127 '99': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_static() {
-    assert_snapshot!(
-        infer(r#"
-static GLOBAL_STATIC: u32 = 101;
-static mut GLOBAL_STATIC_MUT: u32 = 101;
-fn test() {
-    static LOCAL_STATIC: u32 = 99;
-    static mut LOCAL_STATIC_MUT: u32 = 99;
-    let x = LOCAL_STATIC;
-    let y = LOCAL_STATIC_MUT;
-    let z = GLOBAL_STATIC;
-    let w = GLOBAL_STATIC_MUT;
-}
-"#),
-        @r###"
-    28..31 '101': u32
-    69..72 '101': u32
-    84..279 '{     ...MUT; }': ()
-    172..173 'x': u32
-    176..188 'LOCAL_STATIC': u32
-    198..199 'y': u32
-    202..218 'LOCAL_...IC_MUT': u32
-    228..229 'z': u32
-    232..245 'GLOBAL_STATIC': u32
-    255..256 'w': u32
-    259..276 'GLOBAL...IC_MUT': u32
-    117..119 '99': u32
-    160..162 '99': u32
-    "###
+    check_infer(
+        r#"
+        static GLOBAL_STATIC: u32 = 101;
+        static mut GLOBAL_STATIC_MUT: u32 = 101;
+        fn test() {
+            static LOCAL_STATIC: u32 = 99;
+            static mut LOCAL_STATIC_MUT: u32 = 99;
+            let x = LOCAL_STATIC;
+            let y = LOCAL_STATIC_MUT;
+            let z = GLOBAL_STATIC;
+            let w = GLOBAL_STATIC_MUT;
+        }
+        "#,
+        expect![[r#"
+            28..31 '101': u32
+            69..72 '101': u32
+            84..279 '{     ...MUT; }': ()
+            172..173 'x': u32
+            176..188 'LOCAL_STATIC': u32
+            198..199 'y': u32
+            202..218 'LOCAL_...IC_MUT': u32
+            228..229 'z': u32
+            232..245 'GLOBAL_STATIC': u32
+            255..256 'w': u32
+            259..276 'GLOBAL...IC_MUT': u32
+            117..119 '99': u32
+            160..162 '99': u32
+        "#]],
     );
 }
 
@@ -1777,413 +1778,413 @@ fn main() {
 
 #[test]
 fn closure_return() {
-    assert_snapshot!(
-        infer(r#"
-fn foo() -> u32 {
-    let x = || -> usize { return 1; };
-}
-"#),
-        @r###"
-    16..58 '{     ...; }; }': ()
-    26..27 'x': || -> usize
-    30..55 '|| -> ...n 1; }': || -> usize
-    42..55 '{ return 1; }': usize
-    44..52 'return 1': !
-    51..52 '1': usize
-    "###
+    check_infer(
+        r#"
+        fn foo() -> u32 {
+            let x = || -> usize { return 1; };
+        }
+        "#,
+        expect![[r#"
+            16..58 '{     ...; }; }': ()
+            26..27 'x': || -> usize
+            30..55 '|| -> ...n 1; }': || -> usize
+            42..55 '{ return 1; }': usize
+            44..52 'return 1': !
+            51..52 '1': usize
+        "#]],
     );
 }
 
 #[test]
 fn closure_return_unit() {
-    assert_snapshot!(
-        infer(r#"
-fn foo() -> u32 {
-    let x = || { return; };
-}
-"#),
-        @r###"
-    16..47 '{     ...; }; }': ()
-    26..27 'x': || -> ()
-    30..44 '|| { return; }': || -> ()
-    33..44 '{ return; }': ()
-    35..41 'return': !
-    "###
+    check_infer(
+        r#"
+        fn foo() -> u32 {
+            let x = || { return; };
+        }
+        "#,
+        expect![[r#"
+            16..47 '{     ...; }; }': ()
+            26..27 'x': || -> ()
+            30..44 '|| { return; }': || -> ()
+            33..44 '{ return; }': ()
+            35..41 'return': !
+        "#]],
     );
 }
 
 #[test]
 fn closure_return_inferred() {
-    assert_snapshot!(
-        infer(r#"
-fn foo() -> u32 {
-    let x = || { "test" };
-}
-"#),
-        @r###"
-    16..46 '{     ..." }; }': ()
-    26..27 'x': || -> &str
-    30..43 '|| { "test" }': || -> &str
-    33..43 '{ "test" }': &str
-    35..41 '"test"': &str
-    "###
+    check_infer(
+        r#"
+        fn foo() -> u32 {
+            let x = || { "test" };
+        }
+        "#,
+        expect![[r#"
+            16..46 '{     ..." }; }': ()
+            26..27 'x': || -> &str
+            30..43 '|| { "test" }': || -> &str
+            33..43 '{ "test" }': &str
+            35..41 '"test"': &str
+        "#]],
     );
 }
 
 #[test]
 fn fn_pointer_return() {
-    assert_snapshot!(
-        infer(r#"
-struct Vtable {
-    method: fn(),
-}
+    check_infer(
+        r#"
+        struct Vtable {
+            method: fn(),
+        }
 
-fn main() {
-    let vtable = Vtable { method: || {} };
-    let m = vtable.method;
-}
-"#),
-        @r###"
-    47..120 '{     ...hod; }': ()
-    57..63 'vtable': Vtable
-    66..90 'Vtable...| {} }': Vtable
-    83..88 '|| {}': || -> ()
-    86..88 '{}': ()
-    100..101 'm': fn()
-    104..110 'vtable': Vtable
-    104..117 'vtable.method': fn()
-    "###
+        fn main() {
+            let vtable = Vtable { method: || {} };
+            let m = vtable.method;
+        }
+        "#,
+        expect![[r#"
+            47..120 '{     ...hod; }': ()
+            57..63 'vtable': Vtable
+            66..90 'Vtable...| {} }': Vtable
+            83..88 '|| {}': || -> ()
+            86..88 '{}': ()
+            100..101 'm': fn()
+            104..110 'vtable': Vtable
+            104..117 'vtable.method': fn()
+        "#]],
     );
 }
 
 #[test]
 fn effects_smoke_test() {
-    assert_snapshot!(
-        infer(r#"
-fn main() {
-    let x = unsafe { 92 };
-    let y = async { async { () }.await };
-    let z = try { () };
-    let t = 'a: { 92 };
-}
-"#),
-        @r###"
-    10..130 '{     ...2 }; }': ()
-    20..21 'x': i32
-    24..37 'unsafe { 92 }': i32
-    31..37 '{ 92 }': i32
-    33..35 '92': i32
-    47..48 'y': {unknown}
-    57..79 '{ asyn...wait }': {unknown}
-    59..77 'async ....await': {unknown}
-    65..71 '{ () }': ()
-    67..69 '()': ()
-    89..90 'z': {unknown}
-    93..103 'try { () }': {unknown}
-    97..103 '{ () }': ()
-    99..101 '()': ()
-    113..114 't': i32
-    121..127 '{ 92 }': i32
-    123..125 '92': i32
-    "###
+    check_infer(
+        r#"
+        fn main() {
+            let x = unsafe { 92 };
+            let y = async { async { () }.await };
+            let z = try { () };
+            let t = 'a: { 92 };
+        }
+        "#,
+        expect![[r#"
+            10..130 '{     ...2 }; }': ()
+            20..21 'x': i32
+            24..37 'unsafe { 92 }': i32
+            31..37 '{ 92 }': i32
+            33..35 '92': i32
+            47..48 'y': {unknown}
+            57..79 '{ asyn...wait }': {unknown}
+            59..77 'async ....await': {unknown}
+            65..71 '{ () }': ()
+            67..69 '()': ()
+            89..90 'z': {unknown}
+            93..103 'try { () }': {unknown}
+            97..103 '{ () }': ()
+            99..101 '()': ()
+            113..114 't': i32
+            121..127 '{ 92 }': i32
+            123..125 '92': i32
+        "#]],
     )
 }
 
 #[test]
 fn infer_generic_from_later_assignment() {
-    assert_snapshot!(
-        infer(r#"
-enum Option<T> { Some(T), None }
-use Option::*;
+    check_infer(
+        r#"
+        enum Option<T> { Some(T), None }
+        use Option::*;
 
-fn test() {
-    let mut end = None;
-    loop {
-        end = Some(true);
-    }
-}
-"#),
-        @r###"
-    59..129 '{     ...   } }': ()
-    69..76 'mut end': Option<bool>
-    79..83 'None': Option<bool>
-    89..127 'loop {...     }': !
-    94..127 '{     ...     }': ()
-    104..107 'end': Option<bool>
-    104..120 'end = ...(true)': ()
-    110..114 'Some': Some<bool>(bool) -> Option<bool>
-    110..120 'Some(true)': Option<bool>
-    115..119 'true': bool
-    "###
+        fn test() {
+            let mut end = None;
+            loop {
+                end = Some(true);
+            }
+        }
+        "#,
+        expect![[r#"
+            59..129 '{     ...   } }': ()
+            69..76 'mut end': Option<bool>
+            79..83 'None': Option<bool>
+            89..127 'loop {...     }': !
+            94..127 '{     ...     }': ()
+            104..107 'end': Option<bool>
+            104..120 'end = ...(true)': ()
+            110..114 'Some': Some<bool>(bool) -> Option<bool>
+            110..120 'Some(true)': Option<bool>
+            115..119 'true': bool
+        "#]],
     );
 }
 
 #[test]
 fn infer_loop_break_with_val() {
-    assert_snapshot!(
-        infer(r#"
-enum Option<T> { Some(T), None }
-use Option::*;
+    check_infer(
+        r#"
+        enum Option<T> { Some(T), None }
+        use Option::*;
 
-fn test() {
-    let x = loop {
-        if false {
-            break None;
-        }
-
-        break Some(true);
-    };
-}
-"#),
-        @r###"
-    59..168 '{     ...  }; }': ()
-    69..70 'x': Option<bool>
-    73..165 'loop {...     }': Option<bool>
-    78..165 '{     ...     }': ()
-    88..132 'if fal...     }': ()
-    91..96 'false': bool
-    97..132 '{     ...     }': ()
-    111..121 'break None': !
-    117..121 'None': Option<bool>
-    142..158 'break ...(true)': !
-    148..152 'Some': Some<bool>(bool) -> Option<bool>
-    148..158 'Some(true)': Option<bool>
-    153..157 'true': bool
-    "###
+        fn test() {
+            let x = loop {
+                if false {
+                    break None;
+                }
+
+                break Some(true);
+            };
+        }
+        "#,
+        expect![[r#"
+            59..168 '{     ...  }; }': ()
+            69..70 'x': Option<bool>
+            73..165 'loop {...     }': Option<bool>
+            78..165 '{     ...     }': ()
+            88..132 'if fal...     }': ()
+            91..96 'false': bool
+            97..132 '{     ...     }': ()
+            111..121 'break None': !
+            117..121 'None': Option<bool>
+            142..158 'break ...(true)': !
+            148..152 'Some': Some<bool>(bool) -> Option<bool>
+            148..158 'Some(true)': Option<bool>
+            153..157 'true': bool
+        "#]],
     );
 }
 
 #[test]
 fn infer_loop_break_without_val() {
-    assert_snapshot!(
-        infer(r#"
-enum Option<T> { Some(T), None }
-use Option::*;
-
-fn test() {
-    let x = loop {
-        if false {
-            break;
-        }
-    };
-}
-"#),
-        @r###"
-    59..136 '{     ...  }; }': ()
-    69..70 'x': ()
-    73..133 'loop {...     }': ()
-    78..133 '{     ...     }': ()
-    88..127 'if fal...     }': ()
-    91..96 'false': bool
-    97..127 '{     ...     }': ()
-    111..116 'break': !
-    "###
+    check_infer(
+        r#"
+        enum Option<T> { Some(T), None }
+        use Option::*;
+
+        fn test() {
+            let x = loop {
+                if false {
+                    break;
+                }
+            };
+        }
+        "#,
+        expect![[r#"
+            59..136 '{     ...  }; }': ()
+            69..70 'x': ()
+            73..133 'loop {...     }': ()
+            78..133 '{     ...     }': ()
+            88..127 'if fal...     }': ()
+            91..96 'false': bool
+            97..127 '{     ...     }': ()
+            111..116 'break': !
+        "#]],
     );
 }
 
 #[test]
 fn infer_labelled_break_with_val() {
-    assert_snapshot!(
-        infer(r#"
-fn foo() {
-    let _x = || 'outer: loop {
-        let inner = 'inner: loop {
-            let i = Default::default();
-            if (break 'outer i) {
-                loop { break 'inner 5i8; };
-            } else if true {
-                break 'inner 6;
-            }
-            break 7;
-        };
-        break inner < 8;
-    };
-}
-"#),
-        @r###"
-    9..335 '{     ...  }; }': ()
-    19..21 '_x': || -> bool
-    24..332 '|| 'ou...     }': || -> bool
-    27..332 ''outer...     }': bool
-    40..332 '{     ...     }': ()
-    54..59 'inner': i8
-    62..300 ''inner...     }': i8
-    75..300 '{     ...     }': ()
-    93..94 'i': bool
-    97..113 'Defaul...efault': {unknown}
-    97..115 'Defaul...ault()': bool
-    129..269 'if (br...     }': ()
-    133..147 'break 'outer i': !
-    146..147 'i': bool
-    149..208 '{     ...     }': ()
-    167..193 'loop {...5i8; }': !
-    172..193 '{ brea...5i8; }': ()
-    174..190 'break ...er 5i8': !
-    187..190 '5i8': i8
-    214..269 'if tru...     }': ()
-    217..221 'true': bool
-    222..269 '{     ...     }': ()
-    240..254 'break 'inner 6': !
-    253..254 '6': i8
-    282..289 'break 7': !
-    288..289 '7': i8
-    310..325 'break inner < 8': !
-    316..321 'inner': i8
-    316..325 'inner < 8': bool
-    324..325 '8': i8
-    "###
+    check_infer(
+        r#"
+        fn foo() {
+            let _x = || 'outer: loop {
+                let inner = 'inner: loop {
+                    let i = Default::default();
+                    if (break 'outer i) {
+                        loop { break 'inner 5i8; };
+                    } else if true {
+                        break 'inner 6;
+                    }
+                    break 7;
+                };
+                break inner < 8;
+            };
+        }
+        "#,
+        expect![[r#"
+            9..335 '{     ...  }; }': ()
+            19..21 '_x': || -> bool
+            24..332 '|| 'ou...     }': || -> bool
+            27..332 ''outer...     }': bool
+            40..332 '{     ...     }': ()
+            54..59 'inner': i8
+            62..300 ''inner...     }': i8
+            75..300 '{     ...     }': ()
+            93..94 'i': bool
+            97..113 'Defaul...efault': {unknown}
+            97..115 'Defaul...ault()': bool
+            129..269 'if (br...     }': ()
+            133..147 'break 'outer i': !
+            146..147 'i': bool
+            149..208 '{     ...     }': ()
+            167..193 'loop {...5i8; }': !
+            172..193 '{ brea...5i8; }': ()
+            174..190 'break ...er 5i8': !
+            187..190 '5i8': i8
+            214..269 'if tru...     }': ()
+            217..221 'true': bool
+            222..269 '{     ...     }': ()
+            240..254 'break 'inner 6': !
+            253..254 '6': i8
+            282..289 'break 7': !
+            288..289 '7': i8
+            310..325 'break inner < 8': !
+            316..321 'inner': i8
+            316..325 'inner < 8': bool
+            324..325 '8': i8
+        "#]],
     );
 }
 
 #[test]
 fn generic_default() {
-    assert_snapshot!(
-        infer(r#"
-struct Thing<T = ()> { t: T }
-enum OtherThing<T = ()> {
-    One { t: T },
-    Two(T),
-}
-
-fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) {
-    t1.t;
-    t3.t;
-    match t2 {
-        OtherThing::One { t } => { t; },
-        OtherThing::Two(t) => { t; },
-    }
-    match t4 {
-        OtherThing::One { t } => { t; },
-        OtherThing::Two(t) => { t; },
-    }
-}
-"#),
-        @r###"
-    97..99 't1': Thing<()>
-    108..110 't2': OtherThing<()>
-    124..126 't3': Thing<i32>
-    140..142 't4': OtherThing<i32>
-    161..384 '{     ...   } }': ()
-    167..169 't1': Thing<()>
-    167..171 't1.t': ()
-    177..179 't3': Thing<i32>
-    177..181 't3.t': i32
-    187..282 'match ...     }': ()
-    193..195 't2': OtherThing<()>
-    206..227 'OtherT... { t }': OtherThing<()>
-    224..225 't': ()
-    231..237 '{ t; }': ()
-    233..234 't': ()
-    247..265 'OtherT...Two(t)': OtherThing<()>
-    263..264 't': ()
-    269..275 '{ t; }': ()
-    271..272 't': ()
-    287..382 'match ...     }': ()
-    293..295 't4': OtherThing<i32>
-    306..327 'OtherT... { t }': OtherThing<i32>
-    324..325 't': i32
-    331..337 '{ t; }': ()
-    333..334 't': i32
-    347..365 'OtherT...Two(t)': OtherThing<i32>
-    363..364 't': i32
-    369..375 '{ t; }': ()
-    371..372 't': i32
-    "###
+    check_infer(
+        r#"
+        struct Thing<T = ()> { t: T }
+        enum OtherThing<T = ()> {
+            One { t: T },
+            Two(T),
+        }
+
+        fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) {
+            t1.t;
+            t3.t;
+            match t2 {
+                OtherThing::One { t } => { t; },
+                OtherThing::Two(t) => { t; },
+            }
+            match t4 {
+                OtherThing::One { t } => { t; },
+                OtherThing::Two(t) => { t; },
+            }
+        }
+        "#,
+        expect![[r#"
+            97..99 't1': Thing<()>
+            108..110 't2': OtherThing<()>
+            124..126 't3': Thing<i32>
+            140..142 't4': OtherThing<i32>
+            161..384 '{     ...   } }': ()
+            167..169 't1': Thing<()>
+            167..171 't1.t': ()
+            177..179 't3': Thing<i32>
+            177..181 't3.t': i32
+            187..282 'match ...     }': ()
+            193..195 't2': OtherThing<()>
+            206..227 'OtherT... { t }': OtherThing<()>
+            224..225 't': ()
+            231..237 '{ t; }': ()
+            233..234 't': ()
+            247..265 'OtherT...Two(t)': OtherThing<()>
+            263..264 't': ()
+            269..275 '{ t; }': ()
+            271..272 't': ()
+            287..382 'match ...     }': ()
+            293..295 't4': OtherThing<i32>
+            306..327 'OtherT... { t }': OtherThing<i32>
+            324..325 't': i32
+            331..337 '{ t; }': ()
+            333..334 't': i32
+            347..365 'OtherT...Two(t)': OtherThing<i32>
+            363..364 't': i32
+            369..375 '{ t; }': ()
+            371..372 't': i32
+        "#]],
     );
 }
 
 #[test]
 fn generic_default_in_struct_literal() {
-    assert_snapshot!(
-        infer(r#"
-struct Thing<T = ()> { t: T }
-enum OtherThing<T = ()> {
-    One { t: T },
-    Two(T),
-}
+    check_infer(
+        r#"
+        struct Thing<T = ()> { t: T }
+        enum OtherThing<T = ()> {
+            One { t: T },
+            Two(T),
+        }
 
-fn test() {
-    let x = Thing { t: loop {} };
-    let y = Thing { t: () };
-    let z = Thing { t: 1i32 };
-    if let Thing { t } = z {
-        t;
-    }
+        fn test() {
+            let x = Thing { t: loop {} };
+            let y = Thing { t: () };
+            let z = Thing { t: 1i32 };
+            if let Thing { t } = z {
+                t;
+            }
 
-    let a = OtherThing::One { t: 1i32 };
-    let b = OtherThing::Two(1i32);
-}
-"#),
-        @r###"
-    99..319 '{     ...32); }': ()
-    109..110 'x': Thing<!>
-    113..133 'Thing ...p {} }': Thing<!>
-    124..131 'loop {}': !
-    129..131 '{}': ()
-    143..144 'y': Thing<()>
-    147..162 'Thing { t: () }': Thing<()>
-    158..160 '()': ()
-    172..173 'z': Thing<i32>
-    176..193 'Thing ...1i32 }': Thing<i32>
-    187..191 '1i32': i32
-    199..240 'if let...     }': ()
-    206..217 'Thing { t }': Thing<i32>
-    214..215 't': i32
-    220..221 'z': Thing<i32>
-    222..240 '{     ...     }': ()
-    232..233 't': i32
-    250..251 'a': OtherThing<i32>
-    254..281 'OtherT...1i32 }': OtherThing<i32>
-    275..279 '1i32': i32
-    291..292 'b': OtherThing<i32>
-    295..310 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
-    295..316 'OtherT...(1i32)': OtherThing<i32>
-    311..315 '1i32': i32
-    "###
+            let a = OtherThing::One { t: 1i32 };
+            let b = OtherThing::Two(1i32);
+        }
+        "#,
+        expect![[r#"
+            99..319 '{     ...32); }': ()
+            109..110 'x': Thing<!>
+            113..133 'Thing ...p {} }': Thing<!>
+            124..131 'loop {}': !
+            129..131 '{}': ()
+            143..144 'y': Thing<()>
+            147..162 'Thing { t: () }': Thing<()>
+            158..160 '()': ()
+            172..173 'z': Thing<i32>
+            176..193 'Thing ...1i32 }': Thing<i32>
+            187..191 '1i32': i32
+            199..240 'if let...     }': ()
+            206..217 'Thing { t }': Thing<i32>
+            214..215 't': i32
+            220..221 'z': Thing<i32>
+            222..240 '{     ...     }': ()
+            232..233 't': i32
+            250..251 'a': OtherThing<i32>
+            254..281 'OtherT...1i32 }': OtherThing<i32>
+            275..279 '1i32': i32
+            291..292 'b': OtherThing<i32>
+            295..310 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
+            295..316 'OtherT...(1i32)': OtherThing<i32>
+            311..315 '1i32': i32
+        "#]],
     );
 }
 
 #[test]
 fn generic_default_depending_on_other_type_arg() {
-    assert_snapshot!(
-        infer(r#"
-struct Thing<T = u128, F = fn() -> T> { t: T }
-
-fn test(t1: Thing<u32>, t2: Thing) {
-    t1;
-    t2;
-    Thing::<_> { t: 1u32 };
-}
-"#),
-        // FIXME: the {unknown} is a bug
-        @r###"
-    56..58 't1': Thing<u32, fn() -> u32>
-    72..74 't2': Thing<u128, fn() -> u128>
-    83..130 '{     ...2 }; }': ()
-    89..91 't1': Thing<u32, fn() -> u32>
-    97..99 't2': Thing<u128, fn() -> u128>
-    105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}>
-    121..125 '1u32': u32
-    "###
+    // FIXME: the {unknown} is a bug
+    check_infer(
+        r#"
+        struct Thing<T = u128, F = fn() -> T> { t: T }
+
+        fn test(t1: Thing<u32>, t2: Thing) {
+            t1;
+            t2;
+            Thing::<_> { t: 1u32 };
+        }
+        "#,
+        expect![[r#"
+            56..58 't1': Thing<u32, fn() -> u32>
+            72..74 't2': Thing<u128, fn() -> u128>
+            83..130 '{     ...2 }; }': ()
+            89..91 't1': Thing<u32, fn() -> u32>
+            97..99 't2': Thing<u128, fn() -> u128>
+            105..127 'Thing:...1u32 }': Thing<u32, fn() -> {unknown}>
+            121..125 '1u32': u32
+        "#]],
     );
 }
 
 #[test]
 fn generic_default_depending_on_other_type_arg_forward() {
-    assert_snapshot!(
-        infer(r#"
-struct Thing<F = fn() -> T, T = u128> { t: T }
-
-fn test(t1: Thing) {
-    t1;
-}
-"#),
-        // the {unknown} here is intentional, as defaults are not allowed to
-        // refer to type parameters coming later
-        @r###"
-    56..58 't1': Thing<fn() -> {unknown}, u128>
-    67..78 '{     t1; }': ()
-    73..75 't1': Thing<fn() -> {unknown}, u128>
-    "###
+    // the {unknown} here is intentional, as defaults are not allowed to
+    // refer to type parameters coming later
+    check_infer(
+        r#"
+        struct Thing<F = fn() -> T, T = u128> { t: T }
+
+        fn test(t1: Thing) {
+            t1;
+        }
+        "#,
+        expect![[r#"
+            56..58 't1': Thing<fn() -> {unknown}, u128>
+            67..78 '{     t1; }': ()
+            73..75 't1': Thing<fn() -> {unknown}, u128>
+        "#]],
     );
 }
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 27737fa94..d3c4d3f2a 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,7 +1,7 @@
-use insta::assert_snapshot;
+use expect::expect;
 use test_utils::mark;
 
-use super::{check_types, infer, infer_with_mismatches};
+use super::{check_infer, check_infer_with_mismatches, check_types};
 
 #[test]
 fn infer_await() {
@@ -38,7 +38,7 @@ fn infer_async() {
         r#"
 //- /main.rs crate:main deps:core
 async fn foo() -> u64 {
-    128
+            128
 }
 
 fn test() {
@@ -65,7 +65,7 @@ fn infer_desugar_async() {
         r#"
 //- /main.rs crate:main deps:core
 async fn foo() -> u64 {
-    128
+            128
 }
 
 fn test() {
@@ -222,291 +222,291 @@ mod ops {
 
 #[test]
 fn infer_from_bound_1() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {}
-struct S<T>(T);
-impl<U> Trait<U> for S<U> {}
-fn foo<T: Trait<u32>>(t: T) {}
-fn test() {
-    let s = S(unknown);
-    foo(s);
-}
-"#),
-        @r###"
-    85..86 't': T
-    91..93 '{}': ()
-    104..143 '{     ...(s); }': ()
-    114..115 's': S<u32>
-    118..119 'S': S<u32>(u32) -> S<u32>
-    118..128 'S(unknown)': S<u32>
-    120..127 'unknown': u32
-    134..137 'foo': fn foo<S<u32>>(S<u32>)
-    134..140 'foo(s)': ()
-    138..139 's': S<u32>
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {}
+        struct S<T>(T);
+        impl<U> Trait<U> for S<U> {}
+        fn foo<T: Trait<u32>>(t: T) {}
+        fn test() {
+            let s = S(unknown);
+            foo(s);
+        }
+        "#,
+        expect![[r#"
+            85..86 't': T
+            91..93 '{}': ()
+            104..143 '{     ...(s); }': ()
+            114..115 's': S<u32>
+            118..119 'S': S<u32>(u32) -> S<u32>
+            118..128 'S(unknown)': S<u32>
+            120..127 'unknown': u32
+            134..137 'foo': fn foo<S<u32>>(S<u32>)
+            134..140 'foo(s)': ()
+            138..139 's': S<u32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_from_bound_2() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {}
-struct S<T>(T);
-impl<U> Trait<U> for S<U> {}
-fn foo<U, T: Trait<U>>(t: T) -> U {}
-fn test() {
-    let s = S(unknown);
-    let x: u32 = foo(s);
-}
-"#),
-        @r###"
-    86..87 't': T
-    97..99 '{}': ()
-    110..162 '{     ...(s); }': ()
-    120..121 's': S<u32>
-    124..125 'S': S<u32>(u32) -> S<u32>
-    124..134 'S(unknown)': S<u32>
-    126..133 'unknown': u32
-    144..145 'x': u32
-    153..156 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
-    153..159 'foo(s)': u32
-    157..158 's': S<u32>
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {}
+        struct S<T>(T);
+        impl<U> Trait<U> for S<U> {}
+        fn foo<U, T: Trait<U>>(t: T) -> U {}
+        fn test() {
+            let s = S(unknown);
+            let x: u32 = foo(s);
+        }
+        "#,
+        expect![[r#"
+            86..87 't': T
+            97..99 '{}': ()
+            110..162 '{     ...(s); }': ()
+            120..121 's': S<u32>
+            124..125 'S': S<u32>(u32) -> S<u32>
+            124..134 'S(unknown)': S<u32>
+            126..133 'unknown': u32
+            144..145 'x': u32
+            153..156 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
+            153..159 'foo(s)': u32
+            157..158 's': S<u32>
+        "#]],
     );
 }
 
 #[test]
 fn trait_default_method_self_bound_implements_trait() {
     mark::check!(trait_self_implements_self);
-    assert_snapshot!(
-        infer(r#"
-trait Trait {
-    fn foo(&self) -> i64;
-    fn bar(&self) -> {
-        let x = self.foo();
-    }
-}
-"#),
-        @r###"
-    26..30 'self': &Self
-    52..56 'self': &Self
-    61..96 '{     ...     }': ()
-    75..76 'x': i64
-    79..83 'self': &Self
-    79..89 'self.foo()': i64
-    "###
+    check_infer(
+        r#"
+        trait Trait {
+            fn foo(&self) -> i64;
+            fn bar(&self) -> {
+                let x = self.foo();
+            }
+        }
+        "#,
+        expect![[r#"
+            26..30 'self': &Self
+            52..56 'self': &Self
+            61..96 '{     ...     }': ()
+            75..76 'x': i64
+            79..83 'self': &Self
+            79..89 'self.foo()': i64
+        "#]],
     );
 }
 
 #[test]
 fn trait_default_method_self_bound_implements_super_trait() {
-    assert_snapshot!(
-        infer(r#"
-trait SuperTrait {
-    fn foo(&self) -> i64;
-}
-trait Trait: SuperTrait {
-    fn bar(&self) -> {
-        let x = self.foo();
-    }
-}
-"#),
-        @r###"
-    31..35 'self': &Self
-    85..89 'self': &Self
-    94..129 '{     ...     }': ()
-    108..109 'x': i64
-    112..116 'self': &Self
-    112..122 'self.foo()': i64
-    "###
+    check_infer(
+        r#"
+        trait SuperTrait {
+            fn foo(&self) -> i64;
+        }
+        trait Trait: SuperTrait {
+            fn bar(&self) -> {
+                let x = self.foo();
+            }
+        }
+        "#,
+        expect![[r#"
+            31..35 'self': &Self
+            85..89 'self': &Self
+            94..129 '{     ...     }': ()
+            108..109 'x': i64
+            112..116 'self': &Self
+            112..122 'self.foo()': i64
+        "#]],
     );
 }
 
 #[test]
 fn infer_project_associated_type() {
-    assert_snapshot!(
-        infer(r#"
-trait Iterable {
-   type Item;
-}
-struct S;
-impl Iterable for S { type Item = u32; }
-fn test<T: Iterable>() {
-    let x: <S as Iterable>::Item = 1;
-    let y: <T as Iterable>::Item = no_matter;
-    let z: T::Item = no_matter;
-    let a: <T>::Item = no_matter;
-}
-"#),
-        @r###"
-    107..260 '{     ...ter; }': ()
-    117..118 'x': u32
-    144..145 '1': u32
-    155..156 'y': Iterable::Item<T>
-    182..191 'no_matter': Iterable::Item<T>
-    201..202 'z': Iterable::Item<T>
-    214..223 'no_matter': Iterable::Item<T>
-    233..234 'a': Iterable::Item<T>
-    248..257 'no_matter': Iterable::Item<T>
-    "###
+    check_infer(
+        r#"
+        trait Iterable {
+            type Item;
+        }
+        struct S;
+        impl Iterable for S { type Item = u32; }
+        fn test<T: Iterable>() {
+            let x: <S as Iterable>::Item = 1;
+            let y: <T as Iterable>::Item = no_matter;
+            let z: T::Item = no_matter;
+            let a: <T>::Item = no_matter;
+        }
+        "#,
+        expect![[r#"
+            108..261 '{     ...ter; }': ()
+            118..119 'x': u32
+            145..146 '1': u32
+            156..157 'y': Iterable::Item<T>
+            183..192 'no_matter': Iterable::Item<T>
+            202..203 'z': Iterable::Item<T>
+            215..224 'no_matter': Iterable::Item<T>
+            234..235 'a': Iterable::Item<T>
+            249..258 'no_matter': Iterable::Item<T>
+        "#]],
     );
 }
 
 #[test]
 fn infer_return_associated_type() {
-    assert_snapshot!(
-        infer(r#"
-trait Iterable {
-   type Item;
-}
-struct S;
-impl Iterable for S { type Item = u32; }
-fn foo1<T: Iterable>(t: T) -> T::Item {}
-fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
-fn foo3<T: Iterable>(t: T) -> <T>::Item {}
-fn test() {
-    let x = foo1(S);
-    let y = foo2(S);
-    let z = foo3(S);
-}
-"#),
-        @r###"
-    105..106 't': T
-    122..124 '{}': ()
-    146..147 't': T
-    177..179 '{}': ()
-    201..202 't': T
-    220..222 '{}': ()
-    233..299 '{     ...(S); }': ()
-    243..244 'x': u32
-    247..251 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
-    247..254 'foo1(S)': u32
-    252..253 'S': S
-    264..265 'y': u32
-    268..272 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
-    268..275 'foo2(S)': u32
-    273..274 'S': S
-    285..286 'z': u32
-    289..293 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
-    289..296 'foo3(S)': u32
-    294..295 'S': S
-    "###
+    check_infer(
+        r#"
+        trait Iterable {
+            type Item;
+        }
+        struct S;
+        impl Iterable for S { type Item = u32; }
+        fn foo1<T: Iterable>(t: T) -> T::Item {}
+        fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
+        fn foo3<T: Iterable>(t: T) -> <T>::Item {}
+        fn test() {
+            let x = foo1(S);
+            let y = foo2(S);
+            let z = foo3(S);
+        }
+        "#,
+        expect![[r#"
+            106..107 't': T
+            123..125 '{}': ()
+            147..148 't': T
+            178..180 '{}': ()
+            202..203 't': T
+            221..223 '{}': ()
+            234..300 '{     ...(S); }': ()
+            244..245 'x': u32
+            248..252 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
+            248..255 'foo1(S)': u32
+            253..254 'S': S
+            265..266 'y': u32
+            269..273 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
+            269..276 'foo2(S)': u32
+            274..275 'S': S
+            286..287 'z': u32
+            290..294 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
+            290..297 'foo3(S)': u32
+            295..296 'S': S
+        "#]],
     );
 }
 
 #[test]
 fn infer_associated_type_bound() {
-    assert_snapshot!(
-        infer(r#"
-trait Iterable {
-   type Item;
-}
-fn test<T: Iterable<Item=u32>>() {
-    let y: T::Item = unknown;
-}
-"#),
-        @r###"
-    66..99 '{     ...own; }': ()
-    76..77 'y': u32
-    89..96 'unknown': u32
-    "###
+    check_infer(
+        r#"
+        trait Iterable {
+            type Item;
+        }
+        fn test<T: Iterable<Item=u32>>() {
+            let y: T::Item = unknown;
+        }
+        "#,
+        expect![[r#"
+            67..100 '{     ...own; }': ()
+            77..78 'y': u32
+            90..97 'unknown': u32
+        "#]],
     );
 }
 
 #[test]
 fn infer_const_body() {
-    assert_snapshot!(
-        infer(r#"
-const A: u32 = 1 + 1;
-static B: u64 = { let x = 1; x };
-"#),
-        @r###"
-    15..16 '1': u32
-    15..20 '1 + 1': u32
-    19..20 '1': u32
-    38..54 '{ let ...1; x }': u64
-    44..45 'x': u64
-    48..49 '1': u64
-    51..52 'x': u64
-    "###
+    check_infer(
+        r#"
+        const A: u32 = 1 + 1;
+        static B: u64 = { let x = 1; x };
+        "#,
+        expect![[r#"
+            15..16 '1': u32
+            15..20 '1 + 1': u32
+            19..20 '1': u32
+            38..54 '{ let ...1; x }': u64
+            44..45 'x': u64
+            48..49 '1': u64
+            51..52 'x': u64
+        "#]],
     );
 }
 
 #[test]
 fn tuple_struct_fields() {
-    assert_snapshot!(
-        infer(r#"
-struct S(i32, u64);
-fn test() -> u64 {
-    let a = S(4, 6);
-    let b = a.0;
-    a.1
-}
-"#),
-        @r###"
-    37..86 '{     ... a.1 }': u64
-    47..48 'a': S
-    51..52 'S': S(i32, u64) -> S
-    51..58 'S(4, 6)': S
-    53..54 '4': i32
-    56..57 '6': u64
-    68..69 'b': i32
-    72..73 'a': S
-    72..75 'a.0': i32
-    81..82 'a': S
-    81..84 'a.1': u64
-    "###
+    check_infer(
+        r#"
+        struct S(i32, u64);
+        fn test() -> u64 {
+            let a = S(4, 6);
+            let b = a.0;
+            a.1
+        }
+        "#,
+        expect![[r#"
+            37..86 '{     ... a.1 }': u64
+            47..48 'a': S
+            51..52 'S': S(i32, u64) -> S
+            51..58 'S(4, 6)': S
+            53..54 '4': i32
+            56..57 '6': u64
+            68..69 'b': i32
+            72..73 'a': S
+            72..75 'a.0': i32
+            81..82 'a': S
+            81..84 'a.1': u64
+        "#]],
     );
 }
 
 #[test]
 fn tuple_struct_with_fn() {
-    assert_snapshot!(
-        infer(r#"
-struct S(fn(u32) -> u64);
-fn test() -> u64 {
-    let a = S(|i| 2*i);
-    let b = a.0(4);
-    a.0(2)
-}
-"#),
-        @r###"
-    43..101 '{     ...0(2) }': u64
-    53..54 'a': S
-    57..58 'S': S(fn(u32) -> u64) -> S
-    57..67 'S(|i| 2*i)': S
-    59..66 '|i| 2*i': |u32| -> u64
-    60..61 'i': u32
-    63..64 '2': u32
-    63..66 '2*i': u32
-    65..66 'i': u32
-    77..78 'b': u64
-    81..82 'a': S
-    81..84 'a.0': fn(u32) -> u64
-    81..87 'a.0(4)': u64
-    85..86 '4': u32
-    93..94 'a': S
-    93..96 'a.0': fn(u32) -> u64
-    93..99 'a.0(2)': u64
-    97..98 '2': u32
-    "###
+    check_infer(
+        r#"
+        struct S(fn(u32) -> u64);
+        fn test() -> u64 {
+            let a = S(|i| 2*i);
+            let b = a.0(4);
+            a.0(2)
+        }
+        "#,
+        expect![[r#"
+            43..101 '{     ...0(2) }': u64
+            53..54 'a': S
+            57..58 'S': S(fn(u32) -> u64) -> S
+            57..67 'S(|i| 2*i)': S
+            59..66 '|i| 2*i': |u32| -> u64
+            60..61 'i': u32
+            63..64 '2': u32
+            63..66 '2*i': u32
+            65..66 'i': u32
+            77..78 'b': u64
+            81..82 'a': S
+            81..84 'a.0': fn(u32) -> u64
+            81..87 'a.0(4)': u64
+            85..86 '4': u32
+            93..94 'a': S
+            93..96 'a.0': fn(u32) -> u64
+            93..99 'a.0(2)': u64
+            97..98 '2': u32
+        "#]],
     );
 }
 
 #[test]
 fn indexing_arrays() {
-    assert_snapshot!(
-        infer("fn main() { &mut [9][2]; }"),
-        @r###"
-    10..26 '{ &mut...[2]; }': ()
-    12..23 '&mut [9][2]': &mut {unknown}
-    17..20 '[9]': [i32; _]
-    17..23 '[9][2]': {unknown}
-    18..19 '9': i32
-    21..22 '2': i32
-    "###
+    check_infer(
+        "fn main() { &mut [9][2]; }",
+        expect![[r#"
+            10..26 '{ &mut...[2]; }': ()
+            12..23 '&mut [9][2]': &mut {unknown}
+            17..20 '[9]': [i32; _]
+            17..23 '[9][2]': {unknown}
+            18..19 '9': i32
+            21..22 '2': i32
+        "#]],
     )
 }
 
@@ -908,476 +908,475 @@ fn test<T: ApplyL>(t: T) {
 
 #[test]
 fn argument_impl_trait() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Trait<T> {
-    fn foo(&self) -> T;
-    fn foo2(&self) -> i64;
-}
-fn bar(x: impl Trait<u16>) {}
-struct S<T>(T);
-impl<T> Trait<T> for S<T> {}
-
-fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
-    x;
-    y;
-    let z = S(1);
-    bar(z);
-    x.foo();
-    y.foo();
-    z.foo();
-    x.foo2();
-    y.foo2();
-    z.foo2();
-}
-"#, true),
-        @r###"
-    29..33 'self': &Self
-    54..58 'self': &Self
-    77..78 'x': impl Trait<u16>
-    97..99 '{}': ()
-    154..155 'x': impl Trait<u64>
-    174..175 'y': &impl Trait<u32>
-    195..323 '{     ...2(); }': ()
-    201..202 'x': impl Trait<u64>
-    208..209 'y': &impl Trait<u32>
-    219..220 'z': S<u16>
-    223..224 'S': S<u16>(u16) -> S<u16>
-    223..227 'S(1)': S<u16>
-    225..226 '1': u16
-    233..236 'bar': fn bar(S<u16>)
-    233..239 'bar(z)': ()
-    237..238 'z': S<u16>
-    245..246 'x': impl Trait<u64>
-    245..252 'x.foo()': u64
-    258..259 'y': &impl Trait<u32>
-    258..265 'y.foo()': u32
-    271..272 'z': S<u16>
-    271..278 'z.foo()': u16
-    284..285 'x': impl Trait<u64>
-    284..292 'x.foo2()': i64
-    298..299 'y': &impl Trait<u32>
-    298..306 'y.foo2()': i64
-    312..313 'z': S<u16>
-    312..320 'z.foo2()': i64
-    "###
+    check_infer_with_mismatches(
+        r#"
+        trait Trait<T> {
+            fn foo(&self) -> T;
+            fn foo2(&self) -> i64;
+        }
+        fn bar(x: impl Trait<u16>) {}
+        struct S<T>(T);
+        impl<T> Trait<T> for S<T> {}
+
+        fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
+            x;
+            y;
+            let z = S(1);
+            bar(z);
+            x.foo();
+            y.foo();
+            z.foo();
+            x.foo2();
+            y.foo2();
+            z.foo2();
+        }
+        "#,
+        expect![[r#"
+            29..33 'self': &Self
+            54..58 'self': &Self
+            77..78 'x': impl Trait<u16>
+            97..99 '{}': ()
+            154..155 'x': impl Trait<u64>
+            174..175 'y': &impl Trait<u32>
+            195..323 '{     ...2(); }': ()
+            201..202 'x': impl Trait<u64>
+            208..209 'y': &impl Trait<u32>
+            219..220 'z': S<u16>
+            223..224 'S': S<u16>(u16) -> S<u16>
+            223..227 'S(1)': S<u16>
+            225..226 '1': u16
+            233..236 'bar': fn bar(S<u16>)
+            233..239 'bar(z)': ()
+            237..238 'z': S<u16>
+            245..246 'x': impl Trait<u64>
+            245..252 'x.foo()': u64
+            258..259 'y': &impl Trait<u32>
+            258..265 'y.foo()': u32
+            271..272 'z': S<u16>
+            271..278 'z.foo()': u16
+            284..285 'x': impl Trait<u64>
+            284..292 'x.foo2()': i64
+            298..299 'y': &impl Trait<u32>
+            298..306 'y.foo2()': i64
+            312..313 'z': S<u16>
+            312..320 'z.foo2()': i64
+        "#]],
     );
 }
 
 #[test]
 fn argument_impl_trait_type_args_1() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Trait {}
-trait Foo {
-    // this function has an implicit Self param, an explicit type param,
-    // and an implicit impl Trait param!
-    fn bar<T>(x: impl Trait) -> T { loop {} }
-}
-fn foo<T>(x: impl Trait) -> T { loop {} }
-struct S;
-impl Trait for S {}
-struct F;
-impl Foo for F {}
-
-fn test() {
-    Foo::bar(S);
-    <F as Foo>::bar(S);
-    F::bar(S);
-    Foo::bar::<u32>(S);
-    <F as Foo>::bar::<u32>(S);
-
-    foo(S);
-    foo::<u32>(S);
-    foo::<u32, i32>(S); // we should ignore the extraneous i32
-}
-"#, true),
-        @r###"
-    155..156 'x': impl Trait
-    175..186 '{ loop {} }': T
-    177..184 'loop {}': !
-    182..184 '{}': ()
-    199..200 'x': impl Trait
-    219..230 '{ loop {} }': T
-    221..228 'loop {}': !
-    226..228 '{}': ()
-    300..509 '{     ... i32 }': ()
-    306..314 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
-    306..317 'Foo::bar(S)': {unknown}
-    315..316 'S': S
-    323..338 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    323..341 '<F as ...bar(S)': {unknown}
-    339..340 'S': S
-    347..353 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    347..356 'F::bar(S)': {unknown}
-    354..355 'S': S
-    362..377 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
-    362..380 'Foo::b...32>(S)': u32
-    378..379 'S': S
-    386..408 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
-    386..411 '<F as ...32>(S)': u32
-    409..410 'S': S
-    418..421 'foo': fn foo<{unknown}>(S) -> {unknown}
-    418..424 'foo(S)': {unknown}
-    422..423 'S': S
-    430..440 'foo::<u32>': fn foo<u32>(S) -> u32
-    430..443 'foo::<u32>(S)': u32
-    441..442 'S': S
-    449..464 'foo::<u32, i32>': fn foo<u32>(S) -> u32
-    449..467 'foo::<...32>(S)': u32
-    465..466 'S': S
-    "###
+    check_infer_with_mismatches(
+        r#"
+        trait Trait {}
+        trait Foo {
+            // this function has an implicit Self param, an explicit type param,
+            // and an implicit impl Trait param!
+            fn bar<T>(x: impl Trait) -> T { loop {} }
+        }
+        fn foo<T>(x: impl Trait) -> T { loop {} }
+        struct S;
+        impl Trait for S {}
+        struct F;
+        impl Foo for F {}
+
+        fn test() {
+            Foo::bar(S);
+            <F as Foo>::bar(S);
+            F::bar(S);
+            Foo::bar::<u32>(S);
+            <F as Foo>::bar::<u32>(S);
+
+            foo(S);
+            foo::<u32>(S);
+            foo::<u32, i32>(S); // we should ignore the extraneous i32
+        }
+        "#,
+        expect![[r#"
+            155..156 'x': impl Trait
+            175..186 '{ loop {} }': T
+            177..184 'loop {}': !
+            182..184 '{}': ()
+            199..200 'x': impl Trait
+            219..230 '{ loop {} }': T
+            221..228 'loop {}': !
+            226..228 '{}': ()
+            300..509 '{     ... i32 }': ()
+            306..314 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
+            306..317 'Foo::bar(S)': {unknown}
+            315..316 'S': S
+            323..338 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
+            323..341 '<F as ...bar(S)': {unknown}
+            339..340 'S': S
+            347..353 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
+            347..356 'F::bar(S)': {unknown}
+            354..355 'S': S
+            362..377 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
+            362..380 'Foo::b...32>(S)': u32
+            378..379 'S': S
+            386..408 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
+            386..411 '<F as ...32>(S)': u32
+            409..410 'S': S
+            418..421 'foo': fn foo<{unknown}>(S) -> {unknown}
+            418..424 'foo(S)': {unknown}
+            422..423 'S': S
+            430..440 'foo::<u32>': fn foo<u32>(S) -> u32
+            430..443 'foo::<u32>(S)': u32
+            441..442 'S': S
+            449..464 'foo::<u32, i32>': fn foo<u32>(S) -> u32
+            449..467 'foo::<...32>(S)': u32
+            465..466 'S': S
+        "#]],
     );
 }
 
 #[test]
 fn argument_impl_trait_type_args_2() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Trait {}
-struct S;
-impl Trait for S {}
-struct F<T>;
-impl<T> F<T> {
-    fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
-}
+    check_infer_with_mismatches(
+        r#"
+        trait Trait {}
+        struct S;
+        impl Trait for S {}
+        struct F<T>;
+        impl<T> F<T> {
+            fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
+        }
 
-fn test() {
-    F.foo(S);
-    F::<u32>.foo(S);
-    F::<u32>.foo::<i32>(S);
-    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
-}
-"#, true),
-        @r###"
-    87..91 'self': F<T>
-    93..94 'x': impl Trait
-    118..129 '{ loop {} }': (T, U)
-    120..127 'loop {}': !
-    125..127 '{}': ()
-    143..283 '{     ...ored }': ()
-    149..150 'F': F<{unknown}>
-    149..157 'F.foo(S)': ({unknown}, {unknown})
-    155..156 'S': S
-    163..171 'F::<u32>': F<u32>
-    163..178 'F::<u32>.foo(S)': (u32, {unknown})
-    176..177 'S': S
-    184..192 'F::<u32>': F<u32>
-    184..206 'F::<u3...32>(S)': (u32, i32)
-    204..205 'S': S
-    212..220 'F::<u32>': F<u32>
-    212..239 'F::<u3...32>(S)': (u32, i32)
-    237..238 'S': S
-    "###
+        fn test() {
+            F.foo(S);
+            F::<u32>.foo(S);
+            F::<u32>.foo::<i32>(S);
+            F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+        }
+        "#,
+        expect![[r#"
+            87..91 'self': F<T>
+            93..94 'x': impl Trait
+            118..129 '{ loop {} }': (T, U)
+            120..127 'loop {}': !
+            125..127 '{}': ()
+            143..283 '{     ...ored }': ()
+            149..150 'F': F<{unknown}>
+            149..157 'F.foo(S)': ({unknown}, {unknown})
+            155..156 'S': S
+            163..171 'F::<u32>': F<u32>
+            163..178 'F::<u32>.foo(S)': (u32, {unknown})
+            176..177 'S': S
+            184..192 'F::<u32>': F<u32>
+            184..206 'F::<u3...32>(S)': (u32, i32)
+            204..205 'S': S
+            212..220 'F::<u32>': F<u32>
+            212..239 'F::<u3...32>(S)': (u32, i32)
+            237..238 'S': S
+        "#]],
     );
 }
 
 #[test]
 fn argument_impl_trait_to_fn_pointer() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Trait {}
-fn foo(x: impl Trait) { loop {} }
-struct S;
-impl Trait for S {}
+    check_infer_with_mismatches(
+        r#"
+        trait Trait {}
+        fn foo(x: impl Trait) { loop {} }
+        struct S;
+        impl Trait for S {}
 
-fn test() {
-    let f: fn(S) -> () = foo;
-}
-"#, true),
-        @r###"
-    22..23 'x': impl Trait
-    37..48 '{ loop {} }': ()
-    39..46 'loop {}': !
-    44..46 '{}': ()
-    90..123 '{     ...foo; }': ()
-    100..101 'f': fn(S)
-    117..120 'foo': fn foo(S)
-    "###
+        fn test() {
+            let f: fn(S) -> () = foo;
+        }
+        "#,
+        expect![[r#"
+            22..23 'x': impl Trait
+            37..48 '{ loop {} }': ()
+            39..46 'loop {}': !
+            44..46 '{}': ()
+            90..123 '{     ...foo; }': ()
+            100..101 'f': fn(S)
+            117..120 'foo': fn foo(S)
+        "#]],
     );
 }
 
 #[test]
 fn impl_trait() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn foo(&self) -> T;
-    fn foo2(&self) -> i64;
-}
-fn bar() -> impl Trait<u64> {}
-
-fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
-    x;
-    y;
-    let z = bar();
-    x.foo();
-    y.foo();
-    z.foo();
-    x.foo2();
-    y.foo2();
-    z.foo2();
-}
-"#),
-        @r###"
-    29..33 'self': &Self
-    54..58 'self': &Self
-    98..100 '{}': ()
-    110..111 'x': impl Trait<u64>
-    130..131 'y': &impl Trait<u64>
-    151..268 '{     ...2(); }': ()
-    157..158 'x': impl Trait<u64>
-    164..165 'y': &impl Trait<u64>
-    175..176 'z': impl Trait<u64>
-    179..182 'bar': fn bar() -> impl Trait<u64>
-    179..184 'bar()': impl Trait<u64>
-    190..191 'x': impl Trait<u64>
-    190..197 'x.foo()': u64
-    203..204 'y': &impl Trait<u64>
-    203..210 'y.foo()': u64
-    216..217 'z': impl Trait<u64>
-    216..223 'z.foo()': u64
-    229..230 'x': impl Trait<u64>
-    229..237 'x.foo2()': i64
-    243..244 'y': &impl Trait<u64>
-    243..251 'y.foo2()': i64
-    257..258 'z': impl Trait<u64>
-    257..265 'z.foo2()': i64
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn foo(&self) -> T;
+            fn foo2(&self) -> i64;
+        }
+        fn bar() -> impl Trait<u64> {}
+
+        fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
+            x;
+            y;
+            let z = bar();
+            x.foo();
+            y.foo();
+            z.foo();
+            x.foo2();
+            y.foo2();
+            z.foo2();
+        }
+        "#,
+        expect![[r#"
+            29..33 'self': &Self
+            54..58 'self': &Self
+            98..100 '{}': ()
+            110..111 'x': impl Trait<u64>
+            130..131 'y': &impl Trait<u64>
+            151..268 '{     ...2(); }': ()
+            157..158 'x': impl Trait<u64>
+            164..165 'y': &impl Trait<u64>
+            175..176 'z': impl Trait<u64>
+            179..182 'bar': fn bar() -> impl Trait<u64>
+            179..184 'bar()': impl Trait<u64>
+            190..191 'x': impl Trait<u64>
+            190..197 'x.foo()': u64
+            203..204 'y': &impl Trait<u64>
+            203..210 'y.foo()': u64
+            216..217 'z': impl Trait<u64>
+            216..223 'z.foo()': u64
+            229..230 'x': impl Trait<u64>
+            229..237 'x.foo2()': i64
+            243..244 'y': &impl Trait<u64>
+            243..251 'y.foo2()': i64
+            257..258 'z': impl Trait<u64>
+            257..265 'z.foo2()': i64
+        "#]],
     );
 }
 
 #[test]
 fn simple_return_pos_impl_trait() {
     mark::check!(lower_rpit);
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn foo(&self) -> T;
-}
-fn bar() -> impl Trait<u64> { loop {} }
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn foo(&self) -> T;
+        }
+        fn bar() -> impl Trait<u64> { loop {} }
 
-fn test() {
-    let a = bar();
-    a.foo();
-}
-"#),
-        @r###"
-    29..33 'self': &Self
-    71..82 '{ loop {} }': !
-    73..80 'loop {}': !
-    78..80 '{}': ()
-    94..129 '{     ...o(); }': ()
-    104..105 'a': impl Trait<u64>
-    108..111 'bar': fn bar() -> impl Trait<u64>
-    108..113 'bar()': impl Trait<u64>
-    119..120 'a': impl Trait<u64>
-    119..126 'a.foo()': u64
-    "###
+        fn test() {
+            let a = bar();
+            a.foo();
+        }
+        "#,
+        expect![[r#"
+            29..33 'self': &Self
+            71..82 '{ loop {} }': !
+            73..80 'loop {}': !
+            78..80 '{}': ()
+            94..129 '{     ...o(); }': ()
+            104..105 'a': impl Trait<u64>
+            108..111 'bar': fn bar() -> impl Trait<u64>
+            108..113 'bar()': impl Trait<u64>
+            119..120 'a': impl Trait<u64>
+            119..126 'a.foo()': u64
+        "#]],
     );
 }
 
 #[test]
 fn more_return_pos_impl_trait() {
-    assert_snapshot!(
-        infer(r#"
-trait Iterator {
-    type Item;
-    fn next(&mut self) -> Self::Item;
-}
-trait Trait<T> {
-    fn foo(&self) -> T;
-}
-fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} }
-fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} }
-
-fn test() {
-    let (a, b) = bar();
-    a.next().foo();
-    b.foo();
-    let (c, d) = baz(1u128);
-    c.next().foo();
-    d.foo();
-}
-"#),
-        @r###"
-    49..53 'self': &mut Self
-    101..105 'self': &Self
-    184..195 '{ loop {} }': ({unknown}, {unknown})
-    186..193 'loop {}': !
-    191..193 '{}': ()
-    206..207 't': T
-    268..279 '{ loop {} }': ({unknown}, {unknown})
-    270..277 'loop {}': !
-    275..277 '{}': ()
-    291..413 '{     ...o(); }': ()
-    301..307 '(a, b)': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
-    302..303 'a': impl Iterator<Item = impl Trait<u32>>
-    305..306 'b': impl Trait<u64>
-    310..313 'bar': fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
-    310..315 'bar()': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
-    321..322 'a': impl Iterator<Item = impl Trait<u32>>
-    321..329 'a.next()': impl Trait<u32>
-    321..335 'a.next().foo()': u32
-    341..342 'b': impl Trait<u64>
-    341..348 'b.foo()': u64
-    358..364 '(c, d)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
-    359..360 'c': impl Iterator<Item = impl Trait<u128>>
-    362..363 'd': impl Trait<u128>
-    367..370 'baz': fn baz<u128>(u128) -> (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
-    367..377 'baz(1u128)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
-    371..376 '1u128': u128
-    383..384 'c': impl Iterator<Item = impl Trait<u128>>
-    383..391 'c.next()': impl Trait<u128>
-    383..397 'c.next().foo()': u128
-    403..404 'd': impl Trait<u128>
-    403..410 'd.foo()': u128
-    "###
+    check_infer(
+        r#"
+        trait Iterator {
+            type Item;
+            fn next(&mut self) -> Self::Item;
+        }
+        trait Trait<T> {
+            fn foo(&self) -> T;
+        }
+        fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>) { loop {} }
+        fn baz<T>(t: T) -> (impl Iterator<Item = impl Trait<T>>, impl Trait<T>) { loop {} }
+
+        fn test() {
+            let (a, b) = bar();
+            a.next().foo();
+            b.foo();
+            let (c, d) = baz(1u128);
+            c.next().foo();
+            d.foo();
+        }
+        "#,
+        expect![[r#"
+            49..53 'self': &mut Self
+            101..105 'self': &Self
+            184..195 '{ loop {} }': ({unknown}, {unknown})
+            186..193 'loop {}': !
+            191..193 '{}': ()
+            206..207 't': T
+            268..279 '{ loop {} }': ({unknown}, {unknown})
+            270..277 'loop {}': !
+            275..277 '{}': ()
+            291..413 '{     ...o(); }': ()
+            301..307 '(a, b)': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
+            302..303 'a': impl Iterator<Item = impl Trait<u32>>
+            305..306 'b': impl Trait<u64>
+            310..313 'bar': fn bar() -> (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
+            310..315 'bar()': (impl Iterator<Item = impl Trait<u32>>, impl Trait<u64>)
+            321..322 'a': impl Iterator<Item = impl Trait<u32>>
+            321..329 'a.next()': impl Trait<u32>
+            321..335 'a.next().foo()': u32
+            341..342 'b': impl Trait<u64>
+            341..348 'b.foo()': u64
+            358..364 '(c, d)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
+            359..360 'c': impl Iterator<Item = impl Trait<u128>>
+            362..363 'd': impl Trait<u128>
+            367..370 'baz': fn baz<u128>(u128) -> (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
+            367..377 'baz(1u128)': (impl Iterator<Item = impl Trait<u128>>, impl Trait<u128>)
+            371..376 '1u128': u128
+            383..384 'c': impl Iterator<Item = impl Trait<u128>>
+            383..391 'c.next()': impl Trait<u128>
+            383..397 'c.next().foo()': u128
+            403..404 'd': impl Trait<u128>
+            403..410 'd.foo()': u128
+        "#]],
     );
 }
 
 #[test]
 fn dyn_trait() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T> {
-    fn foo(&self) -> T;
-    fn foo2(&self) -> i64;
-}
-fn bar() -> dyn Trait<u64> {}
-
-fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
-    x;
-    y;
-    let z = bar();
-    x.foo();
-    y.foo();
-    z.foo();
-    x.foo2();
-    y.foo2();
-    z.foo2();
-}
-"#),
-        @r###"
-    29..33 'self': &Self
-    54..58 'self': &Self
-    97..99 '{}': ()
-    109..110 'x': dyn Trait<u64>
-    128..129 'y': &dyn Trait<u64>
-    148..265 '{     ...2(); }': ()
-    154..155 'x': dyn Trait<u64>
-    161..162 'y': &dyn Trait<u64>
-    172..173 'z': dyn Trait<u64>
-    176..179 'bar': fn bar() -> dyn Trait<u64>
-    176..181 'bar()': dyn Trait<u64>
-    187..188 'x': dyn Trait<u64>
-    187..194 'x.foo()': u64
-    200..201 'y': &dyn Trait<u64>
-    200..207 'y.foo()': u64
-    213..214 'z': dyn Trait<u64>
-    213..220 'z.foo()': u64
-    226..227 'x': dyn Trait<u64>
-    226..234 'x.foo2()': i64
-    240..241 'y': &dyn Trait<u64>
-    240..248 'y.foo2()': i64
-    254..255 'z': dyn Trait<u64>
-    254..262 'z.foo2()': i64
-    "###
+    check_infer(
+        r#"
+        trait Trait<T> {
+            fn foo(&self) -> T;
+            fn foo2(&self) -> i64;
+        }
+        fn bar() -> dyn Trait<u64> {}
+
+        fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
+            x;
+            y;
+            let z = bar();
+            x.foo();
+            y.foo();
+            z.foo();
+            x.foo2();
+            y.foo2();
+            z.foo2();
+        }
+        "#,
+        expect![[r#"
+            29..33 'self': &Self
+            54..58 'self': &Self
+            97..99 '{}': ()
+            109..110 'x': dyn Trait<u64>
+            128..129 'y': &dyn Trait<u64>
+            148..265 '{     ...2(); }': ()
+            154..155 'x': dyn Trait<u64>
+            161..162 'y': &dyn Trait<u64>
+            172..173 'z': dyn Trait<u64>
+            176..179 'bar': fn bar() -> dyn Trait<u64>
+            176..181 'bar()': dyn Trait<u64>
+            187..188 'x': dyn Trait<u64>
+            187..194 'x.foo()': u64
+            200..201 'y': &dyn Trait<u64>
+            200..207 'y.foo()': u64
+            213..214 'z': dyn Trait<u64>
+            213..220 'z.foo()': u64
+            226..227 'x': dyn Trait<u64>
+            226..234 'x.foo2()': i64
+            240..241 'y': &dyn Trait<u64>
+            240..248 'y.foo2()': i64
+            254..255 'z': dyn Trait<u64>
+            254..262 'z.foo2()': i64
+        "#]],
     );
 }
 
 #[test]
 fn dyn_trait_in_impl() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait<T, U> {
-    fn foo(&self) -> (T, U);
-}
-struct S<T, U> {}
-impl<T, U> S<T, U> {
-    fn bar(&self) -> &dyn Trait<T, U> { loop {} }
-}
-trait Trait2<T, U> {
-    fn baz(&self) -> (T, U);
-}
-impl<T, U> Trait2<T, U> for dyn Trait<T, U> { }
+    check_infer(
+        r#"
+        trait Trait<T, U> {
+            fn foo(&self) -> (T, U);
+        }
+        struct S<T, U> {}
+        impl<T, U> S<T, U> {
+            fn bar(&self) -> &dyn Trait<T, U> { loop {} }
+        }
+        trait Trait2<T, U> {
+            fn baz(&self) -> (T, U);
+        }
+        impl<T, U> Trait2<T, U> for dyn Trait<T, U> { }
 
-fn test(s: S<u32, i32>) {
-    s.bar().baz();
-}
-"#),
-        @r###"
-    32..36 'self': &Self
-    102..106 'self': &S<T, U>
-    128..139 '{ loop {} }': &dyn Trait<T, U>
-    130..137 'loop {}': !
-    135..137 '{}': ()
-    175..179 'self': &Self
-    251..252 's': S<u32, i32>
-    267..289 '{     ...z(); }': ()
-    273..274 's': S<u32, i32>
-    273..280 's.bar()': &dyn Trait<u32, i32>
-    273..286 's.bar().baz()': (u32, i32)
-    "###
+        fn test(s: S<u32, i32>) {
+            s.bar().baz();
+        }
+        "#,
+        expect![[r#"
+            32..36 'self': &Self
+            102..106 'self': &S<T, U>
+            128..139 '{ loop {} }': &dyn Trait<T, U>
+            130..137 'loop {}': !
+            135..137 '{}': ()
+            175..179 'self': &Self
+            251..252 's': S<u32, i32>
+            267..289 '{     ...z(); }': ()
+            273..274 's': S<u32, i32>
+            273..280 's.bar()': &dyn Trait<u32, i32>
+            273..286 's.bar().baz()': (u32, i32)
+        "#]],
     );
 }
 
 #[test]
 fn dyn_trait_bare() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait {
-    fn foo(&self) -> u64;
-}
-fn bar() -> Trait {}
-
-fn test(x: Trait, y: &Trait) -> u64 {
-    x;
-    y;
-    let z = bar();
-    x.foo();
-    y.foo();
-    z.foo();
-}
-"#),
-        @r###"
-    26..30 'self': &Self
-    60..62 '{}': ()
-    72..73 'x': dyn Trait
-    82..83 'y': &dyn Trait
-    100..175 '{     ...o(); }': ()
-    106..107 'x': dyn Trait
-    113..114 'y': &dyn Trait
-    124..125 'z': dyn Trait
-    128..131 'bar': fn bar() -> dyn Trait
-    128..133 'bar()': dyn Trait
-    139..140 'x': dyn Trait
-    139..146 'x.foo()': u64
-    152..153 'y': &dyn Trait
-    152..159 'y.foo()': u64
-    165..166 'z': dyn Trait
-    165..172 'z.foo()': u64
-    "###
+    check_infer(
+        r#"
+        trait Trait {
+            fn foo(&self) -> u64;
+        }
+        fn bar() -> Trait {}
+
+        fn test(x: Trait, y: &Trait) -> u64 {
+            x;
+            y;
+            let z = bar();
+            x.foo();
+            y.foo();
+            z.foo();
+        }
+        "#,
+        expect![[r#"
+            26..30 'self': &Self
+            60..62 '{}': ()
+            72..73 'x': dyn Trait
+            82..83 'y': &dyn Trait
+            100..175 '{     ...o(); }': ()
+            106..107 'x': dyn Trait
+            113..114 'y': &dyn Trait
+            124..125 'z': dyn Trait
+            128..131 'bar': fn bar() -> dyn Trait
+            128..133 'bar()': dyn Trait
+            139..140 'x': dyn Trait
+            139..146 'x.foo()': u64
+            152..153 'y': &dyn Trait
+            152..159 'y.foo()': u64
+            165..166 'z': dyn Trait
+            165..172 'z.foo()': u64
+        "#]],
     );
 }
 
 #[test]
 fn weird_bounds() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait {}
-fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {
-}
-"#),
-        @r###"
-    23..24 'a': impl Trait + {error}
-    50..51 'b': impl {error}
-    69..70 'c': impl Trait
-    86..87 'd': impl {error}
-    107..108 'e': impl {error}
-    123..124 'f': impl Trait + {error}
-    147..150 '{ }': ()
-    "###
+    check_infer(
+        r#"
+        trait Trait {}
+        fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {}
+        "#,
+        expect![[r#"
+            23..24 'a': impl Trait + {error}
+            50..51 'b': impl {error}
+            69..70 'c': impl Trait
+            86..87 'd': impl {error}
+            107..108 'e': impl {error}
+            123..124 'f': impl Trait + {error}
+            147..149 '{}': ()
+        "#]],
     );
 }
 
@@ -1399,66 +1398,66 @@ fn test(x: (impl Trait + UnknownTrait)) {
 
 #[test]
 fn assoc_type_bindings() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait {
-    type Type;
-}
-
-fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
-fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
-fn set<T: Trait<Type = u64>>(t: T) -> T {t}
+    check_infer(
+        r#"
+        trait Trait {
+            type Type;
+        }
 
-struct S<T>;
-impl<T> Trait for S<T> { type Type = T; }
-
-fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
-    get(x);
-    get2(x);
-    get(y);
-    get2(y);
-    get(set(S));
-    get2(set(S));
-    get2(S::<str>);
-}
-"#),
-        @r###"
-    49..50 't': T
-    77..79 '{}': ()
-    111..112 't': T
-    122..124 '{}': ()
-    154..155 't': T
-    165..168 '{t}': T
-    166..167 't': T
-    256..257 'x': T
-    262..263 'y': impl Trait<Type = i64>
-    289..397 '{     ...r>); }': ()
-    295..298 'get': fn get<T>(T) -> <T as Trait>::Type
-    295..301 'get(x)': u32
-    299..300 'x': T
-    307..311 'get2': fn get2<u32, T>(T) -> u32
-    307..314 'get2(x)': u32
-    312..313 'x': T
-    320..323 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
-    320..326 'get(y)': i64
-    324..325 'y': impl Trait<Type = i64>
-    332..336 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
-    332..339 'get2(y)': i64
-    337..338 'y': impl Trait<Type = i64>
-    345..348 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
-    345..356 'get(set(S))': u64
-    349..352 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    349..355 'set(S)': S<u64>
-    353..354 'S': S<u64>
-    362..366 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    362..374 'get2(set(S))': u64
-    367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    367..373 'set(S)': S<u64>
-    371..372 'S': S<u64>
-    380..384 'get2': fn get2<str, S<str>>(S<str>) -> str
-    380..394 'get2(S::<str>)': str
-    385..393 'S::<str>': S<str>
-    "###
+        fn get<T: Trait>(t: T) -> <T as Trait>::Type {}
+        fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
+        fn set<T: Trait<Type = u64>>(t: T) -> T {t}
+
+        struct S<T>;
+        impl<T> Trait for S<T> { type Type = T; }
+
+        fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
+            get(x);
+            get2(x);
+            get(y);
+            get2(y);
+            get(set(S));
+            get2(set(S));
+            get2(S::<str>);
+        }
+        "#,
+        expect![[r#"
+            49..50 't': T
+            77..79 '{}': ()
+            111..112 't': T
+            122..124 '{}': ()
+            154..155 't': T
+            165..168 '{t}': T
+            166..167 't': T
+            256..257 'x': T
+            262..263 'y': impl Trait<Type = i64>
+            289..397 '{     ...r>); }': ()
+            295..298 'get': fn get<T>(T) -> <T as Trait>::Type
+            295..301 'get(x)': u32
+            299..300 'x': T
+            307..311 'get2': fn get2<u32, T>(T) -> u32
+            307..314 'get2(x)': u32
+            312..313 'x': T
+            320..323 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
+            320..326 'get(y)': i64
+            324..325 'y': impl Trait<Type = i64>
+            332..336 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
+            332..339 'get2(y)': i64
+            337..338 'y': impl Trait<Type = i64>
+            345..348 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
+            345..356 'get(set(S))': u64
+            349..352 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            349..355 'set(S)': S<u64>
+            353..354 'S': S<u64>
+            362..366 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+            362..374 'get2(set(S))': u64
+            367..370 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            367..373 'set(S)': S<u64>
+            371..372 'S': S<u64>
+            380..384 'get2': fn get2<str, S<str>>(S<str>) -> str
+            380..394 'get2(S::<str>)': str
+            385..393 'S::<str>': S<str>
+        "#]],
     );
 }
 
@@ -1506,27 +1505,27 @@ mod iter {
 
 #[test]
 fn projection_eq_within_chalk() {
-    assert_snapshot!(
-        infer(r#"
-trait Trait1 {
-    type Type;
-}
-trait Trait2<T> {
-    fn foo(self) -> T;
-}
-impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
+    check_infer(
+        r#"
+        trait Trait1 {
+            type Type;
+        }
+        trait Trait2<T> {
+            fn foo(self) -> T;
+        }
+        impl<T, U> Trait2<T> for U where U: Trait1<Type = T> {}
 
-fn test<T: Trait1<Type = u32>>(x: T) {
-    x.foo();
-}
-"#),
-        @r###"
-    61..65 'self': Self
-    163..164 'x': T
-    169..185 '{     ...o(); }': ()
-    175..176 'x': T
-    175..182 'x.foo()': u32
-    "###
+        fn test<T: Trait1<Type = u32>>(x: T) {
+            x.foo();
+        }
+        "#,
+        expect![[r#"
+            61..65 'self': Self
+            163..164 'x': T
+            169..185 '{     ...o(); }': ()
+            175..176 'x': T
+            175..182 'x.foo()': u32
+        "#]],
     );
 }
 
@@ -1549,445 +1548,445 @@ fn test<T: foo::Trait>(x: T) {
 
 #[test]
 fn super_trait_method_resolution() {
-    assert_snapshot!(
-        infer(r#"
-mod foo {
-    trait SuperTrait {
-        fn foo(&self) -> u32 {}
-    }
-}
-trait Trait1: foo::SuperTrait {}
-trait Trait2 where Self: foo::SuperTrait {}
+    check_infer(
+        r#"
+        mod foo {
+            trait SuperTrait {
+                fn foo(&self) -> u32 {}
+            }
+        }
+        trait Trait1: foo::SuperTrait {}
+        trait Trait2 where Self: foo::SuperTrait {}
 
-fn test<T: Trait1, U: Trait2>(x: T, y: U) {
-    x.foo();
-    y.foo();
-}
-"#),
-        @r###"
-    49..53 'self': &Self
-    62..64 '{}': ()
-    181..182 'x': T
-    187..188 'y': U
-    193..222 '{     ...o(); }': ()
-    199..200 'x': T
-    199..206 'x.foo()': u32
-    212..213 'y': U
-    212..219 'y.foo()': u32
-    "###
+        fn test<T: Trait1, U: Trait2>(x: T, y: U) {
+            x.foo();
+            y.foo();
+        }
+        "#,
+        expect![[r#"
+            49..53 'self': &Self
+            62..64 '{}': ()
+            181..182 'x': T
+            187..188 'y': U
+            193..222 '{     ...o(); }': ()
+            199..200 'x': T
+            199..206 'x.foo()': u32
+            212..213 'y': U
+            212..219 'y.foo()': u32
+        "#]],
     );
 }
 
 #[test]
 fn super_trait_impl_trait_method_resolution() {
-    assert_snapshot!(
-        infer(r#"
-mod foo {
-    trait SuperTrait {
-        fn foo(&self) -> u32 {}
-    }
-}
-trait Trait1: foo::SuperTrait {}
+    check_infer(
+        r#"
+        mod foo {
+            trait SuperTrait {
+                fn foo(&self) -> u32 {}
+            }
+        }
+        trait Trait1: foo::SuperTrait {}
 
-fn test(x: &impl Trait1) {
-    x.foo();
-}
-"#),
-        @r###"
-    49..53 'self': &Self
-    62..64 '{}': ()
-    115..116 'x': &impl Trait1
-    132..148 '{     ...o(); }': ()
-    138..139 'x': &impl Trait1
-    138..145 'x.foo()': u32
-    "###
+        fn test(x: &impl Trait1) {
+            x.foo();
+        }
+        "#,
+        expect![[r#"
+            49..53 'self': &Self
+            62..64 '{}': ()
+            115..116 'x': &impl Trait1
+            132..148 '{     ...o(); }': ()
+            138..139 'x': &impl Trait1
+            138..145 'x.foo()': u32
+        "#]],
     );
 }
 
 #[test]
 fn super_trait_cycle() {
     // This just needs to not crash
-    assert_snapshot!(
-        infer(r#"
-trait A: B {}
-trait B: A {}
+    check_infer(
+        r#"
+        trait A: B {}
+        trait B: A {}
 
-fn test<T: A>(x: T) {
-    x.foo();
-}
-"#),
-        @r###"
-    43..44 'x': T
-    49..65 '{     ...o(); }': ()
-    55..56 'x': T
-    55..62 'x.foo()': {unknown}
-    "###
+        fn test<T: A>(x: T) {
+            x.foo();
+        }
+        "#,
+        expect![[r#"
+            43..44 'x': T
+            49..65 '{     ...o(); }': ()
+            55..56 'x': T
+            55..62 'x.foo()': {unknown}
+        "#]],
     );
 }
 
 #[test]
 fn super_trait_assoc_type_bounds() {
-    assert_snapshot!(
-        infer(r#"
-trait SuperTrait { type Type; }
-trait Trait where Self: SuperTrait {}
+    check_infer(
+        r#"
+        trait SuperTrait { type Type; }
+        trait Trait where Self: SuperTrait {}
 
-fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
-fn set<T: Trait<Type = u64>>(t: T) -> T {t}
+        fn get2<U, T: Trait<Type = U>>(t: T) -> U {}
+        fn set<T: Trait<Type = u64>>(t: T) -> T {t}
 
-struct S<T>;
-impl<T> SuperTrait for S<T> { type Type = T; }
-impl<T> Trait for S<T> {}
+        struct S<T>;
+        impl<T> SuperTrait for S<T> { type Type = T; }
+        impl<T> Trait for S<T> {}
 
-fn test() {
-    get2(set(S));
-}
-"#),
-        @r###"
-    102..103 't': T
-    113..115 '{}': ()
-    145..146 't': T
-    156..159 '{t}': T
-    157..158 't': T
-    258..279 '{     ...S)); }': ()
-    264..268 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    264..276 'get2(set(S))': u64
-    269..272 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    269..275 'set(S)': S<u64>
-    273..274 'S': S<u64>
-    "###
+        fn test() {
+            get2(set(S));
+        }
+        "#,
+        expect![[r#"
+            102..103 't': T
+            113..115 '{}': ()
+            145..146 't': T
+            156..159 '{t}': T
+            157..158 't': T
+            258..279 '{     ...S)); }': ()
+            264..268 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+            264..276 'get2(set(S))': u64
+            269..272 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+            269..275 'set(S)': S<u64>
+            273..274 'S': S<u64>
+        "#]],
     );
 }
 
 #[test]
 fn fn_trait() {
-    assert_snapshot!(
-        infer(r#"
-trait FnOnce<Args> {
-    type Output;
+    check_infer(
+        r#"
+        trait FnOnce<Args> {
+            type Output;
 
-    fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
-}
+            fn call_once(self, args: Args) -> <Self as FnOnce<Args>>::Output;
+        }
 
-fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
-    f.call_once((1, 2));
-}
-"#),
-        @r###"
-    56..60 'self': Self
-    62..66 'args': Args
-    149..150 'f': F
-    155..183 '{     ...2)); }': ()
-    161..162 'f': F
-    161..180 'f.call...1, 2))': u128
-    173..179 '(1, 2)': (u32, u64)
-    174..175 '1': u32
-    177..178 '2': u64
-    "###
+        fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
+            f.call_once((1, 2));
+        }
+        "#,
+        expect![[r#"
+            56..60 'self': Self
+            62..66 'args': Args
+            149..150 'f': F
+            155..183 '{     ...2)); }': ()
+            161..162 'f': F
+            161..180 'f.call...1, 2))': u128
+            173..179 '(1, 2)': (u32, u64)
+            174..175 '1': u32
+            177..178 '2': u64
+        "#]],
     );
 }
 
 #[test]
 fn fn_ptr_and_item() {
-    assert_snapshot!(
-        infer(r#"
-#[lang="fn_once"]
-trait FnOnce<Args> {
-    type Output;
+    check_infer(
+        r#"
+        #[lang="fn_once"]
+        trait FnOnce<Args> {
+            type Output;
 
-    fn call_once(self, args: Args) -> Self::Output;
-}
+            fn call_once(self, args: Args) -> Self::Output;
+        }
 
-trait Foo<T> {
-    fn foo(&self) -> T;
-}
+        trait Foo<T> {
+            fn foo(&self) -> T;
+        }
 
-struct Bar<T>(T);
+        struct Bar<T>(T);
 
-impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> {
-    fn foo(&self) -> (A1, R) {}
-}
+        impl<A1, R, F: FnOnce(A1) -> R> Foo<(A1, R)> for Bar<F> {
+            fn foo(&self) -> (A1, R) {}
+        }
 
-enum Opt<T> { None, Some(T) }
-impl<T> Opt<T> {
-    fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> {}
-}
+        enum Opt<T> { None, Some(T) }
+        impl<T> Opt<T> {
+            fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Opt<U> {}
+        }
 
-fn test() {
-    let bar: Bar<fn(u8) -> u32>;
-    bar.foo();
-
-    let opt: Opt<u8>;
-    let f: fn(u8) -> u32;
-    opt.map(f);
-}
-"#),
-        @r###"
-    74..78 'self': Self
-    80..84 'args': Args
-    139..143 'self': &Self
-    243..247 'self': &Bar<F>
-    260..262 '{}': ()
-    346..350 'self': Opt<T>
-    352..353 'f': F
-    368..370 '{}': ()
-    384..500 '{     ...(f); }': ()
-    394..397 'bar': Bar<fn(u8) -> u32>
-    423..426 'bar': Bar<fn(u8) -> u32>
-    423..432 'bar.foo()': (u8, u32)
-    443..446 'opt': Opt<u8>
-    465..466 'f': fn(u8) -> u32
-    487..490 'opt': Opt<u8>
-    487..497 'opt.map(f)': Opt<u32>
-    495..496 'f': fn(u8) -> u32
-    "###
+        fn test() {
+            let bar: Bar<fn(u8) -> u32>;
+            bar.foo();
+
+            let opt: Opt<u8>;
+            let f: fn(u8) -> u32;
+            opt.map(f);
+        }
+        "#,
+        expect![[r#"
+            74..78 'self': Self
+            80..84 'args': Args
+            139..143 'self': &Self
+            243..247 'self': &Bar<F>
+            260..262 '{}': ()
+            346..350 'self': Opt<T>
+            352..353 'f': F
+            368..370 '{}': ()
+            384..500 '{     ...(f); }': ()
+            394..397 'bar': Bar<fn(u8) -> u32>
+            423..426 'bar': Bar<fn(u8) -> u32>
+            423..432 'bar.foo()': (u8, u32)
+            443..446 'opt': Opt<u8>
+            465..466 'f': fn(u8) -> u32
+            487..490 'opt': Opt<u8>
+            487..497 'opt.map(f)': Opt<u32>
+            495..496 'f': fn(u8) -> u32
+        "#]],
     );
 }
 
 #[test]
 fn fn_trait_deref_with_ty_default() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "deref"]
-trait Deref {
-    type Target;
+    check_infer(
+        r#"
+        #[lang = "deref"]
+        trait Deref {
+            type Target;
 
-    fn deref(&self) -> &Self::Target;
-}
+            fn deref(&self) -> &Self::Target;
+        }
 
-#[lang="fn_once"]
-trait FnOnce<Args> {
-    type Output;
+        #[lang="fn_once"]
+        trait FnOnce<Args> {
+            type Output;
 
-    fn call_once(self, args: Args) -> Self::Output;
-}
+            fn call_once(self, args: Args) -> Self::Output;
+        }
 
-struct Foo;
+        struct Foo;
 
-impl Foo {
-    fn foo(&self) -> usize {}
-}
+        impl Foo {
+            fn foo(&self) -> usize {}
+        }
 
-struct Lazy<T, F = fn() -> T>(F);
+        struct Lazy<T, F = fn() -> T>(F);
 
-impl<T, F> Lazy<T, F> {
-    pub fn new(f: F) -> Lazy<T, F> {}
-}
+        impl<T, F> Lazy<T, F> {
+            pub fn new(f: F) -> Lazy<T, F> {}
+        }
 
-impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
-    type Target = T;
-}
+        impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
+            type Target = T;
+        }
 
-fn test() {
-    let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
-    let r1 = lazy1.foo();
-
-    fn make_foo_fn() -> Foo {}
-    let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
-    let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
-    let r2 = lazy2.foo();
-}
-"#),
-        @r###"
-    64..68 'self': &Self
-    165..169 'self': Self
-    171..175 'args': Args
-    239..243 'self': &Foo
-    254..256 '{}': ()
-    334..335 'f': F
-    354..356 '{}': ()
-    443..689 '{     ...o(); }': ()
-    453..458 'lazy1': Lazy<Foo, || -> Foo>
-    475..484 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo>
-    475..492 'Lazy::...| Foo)': Lazy<Foo, || -> Foo>
-    485..491 '|| Foo': || -> Foo
-    488..491 'Foo': Foo
-    502..504 'r1': usize
-    507..512 'lazy1': Lazy<Foo, || -> Foo>
-    507..518 'lazy1.foo()': usize
-    560..575 'make_foo_fn_ptr': fn() -> Foo
-    591..602 'make_foo_fn': fn make_foo_fn() -> Foo
-    612..617 'lazy2': Lazy<Foo, fn() -> Foo>
-    634..643 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
-    634..660 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
-    644..659 'make_foo_fn_ptr': fn() -> Foo
-    670..672 'r2': usize
-    675..680 'lazy2': Lazy<Foo, fn() -> Foo>
-    675..686 'lazy2.foo()': usize
-    549..551 '{}': ()
-    "###
+        fn test() {
+            let lazy1: Lazy<Foo, _> = Lazy::new(|| Foo);
+            let r1 = lazy1.foo();
+
+            fn make_foo_fn() -> Foo {}
+            let make_foo_fn_ptr: fn() -> Foo = make_foo_fn;
+            let lazy2: Lazy<Foo, _> = Lazy::new(make_foo_fn_ptr);
+            let r2 = lazy2.foo();
+        }
+        "#,
+        expect![[r#"
+            64..68 'self': &Self
+            165..169 'self': Self
+            171..175 'args': Args
+            239..243 'self': &Foo
+            254..256 '{}': ()
+            334..335 'f': F
+            354..356 '{}': ()
+            443..689 '{     ...o(); }': ()
+            453..458 'lazy1': Lazy<Foo, || -> Foo>
+            475..484 'Lazy::new': fn new<Foo, || -> Foo>(|| -> Foo) -> Lazy<Foo, || -> Foo>
+            475..492 'Lazy::...| Foo)': Lazy<Foo, || -> Foo>
+            485..491 '|| Foo': || -> Foo
+            488..491 'Foo': Foo
+            502..504 'r1': usize
+            507..512 'lazy1': Lazy<Foo, || -> Foo>
+            507..518 'lazy1.foo()': usize
+            560..575 'make_foo_fn_ptr': fn() -> Foo
+            591..602 'make_foo_fn': fn make_foo_fn() -> Foo
+            612..617 'lazy2': Lazy<Foo, fn() -> Foo>
+            634..643 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
+            634..660 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
+            644..659 'make_foo_fn_ptr': fn() -> Foo
+            670..672 'r2': usize
+            675..680 'lazy2': Lazy<Foo, fn() -> Foo>
+            675..686 'lazy2.foo()': usize
+            549..551 '{}': ()
+        "#]],
     );
 }
 
 #[test]
 fn closure_1() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "fn_once"]
-trait FnOnce<Args> {
-    type Output;
-}
+    check_infer(
+        r#"
+        #[lang = "fn_once"]
+        trait FnOnce<Args> {
+            type Output;
+        }
 
-enum Option<T> { Some(T), None }
-impl<T> Option<T> {
-    fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {}
-}
+        enum Option<T> { Some(T), None }
+        impl<T> Option<T> {
+            fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {}
+        }
 
-fn test() {
-    let x = Option::Some(1u32);
-    x.map(|v| v + 1);
-    x.map(|_v| 1u64);
-    let y: Option<i64> = x.map(|_v| 1);
-}
-"#),
-        @r###"
-    147..151 'self': Option<T>
-    153..154 'f': F
-    172..174 '{}': ()
-    188..307 '{     ... 1); }': ()
-    198..199 'x': Option<u32>
-    202..214 'Option::Some': Some<u32>(u32) -> Option<u32>
-    202..220 'Option...(1u32)': Option<u32>
-    215..219 '1u32': u32
-    226..227 'x': Option<u32>
-    226..242 'x.map(...v + 1)': Option<u32>
-    232..241 '|v| v + 1': |u32| -> u32
-    233..234 'v': u32
-    236..237 'v': u32
-    236..241 'v + 1': u32
-    240..241 '1': u32
-    248..249 'x': Option<u32>
-    248..264 'x.map(... 1u64)': Option<u64>
-    254..263 '|_v| 1u64': |u32| -> u64
-    255..257 '_v': u32
-    259..263 '1u64': u64
-    274..275 'y': Option<i64>
-    291..292 'x': Option<u32>
-    291..304 'x.map(|_v| 1)': Option<i64>
-    297..303 '|_v| 1': |u32| -> i64
-    298..300 '_v': u32
-    302..303 '1': i64
-    "###
+        fn test() {
+            let x = Option::Some(1u32);
+            x.map(|v| v + 1);
+            x.map(|_v| 1u64);
+            let y: Option<i64> = x.map(|_v| 1);
+        }
+        "#,
+        expect![[r#"
+            147..151 'self': Option<T>
+            153..154 'f': F
+            172..174 '{}': ()
+            188..307 '{     ... 1); }': ()
+            198..199 'x': Option<u32>
+            202..214 'Option::Some': Some<u32>(u32) -> Option<u32>
+            202..220 'Option...(1u32)': Option<u32>
+            215..219 '1u32': u32
+            226..227 'x': Option<u32>
+            226..242 'x.map(...v + 1)': Option<u32>
+            232..241 '|v| v + 1': |u32| -> u32
+            233..234 'v': u32
+            236..237 'v': u32
+            236..241 'v + 1': u32
+            240..241 '1': u32
+            248..249 'x': Option<u32>
+            248..264 'x.map(... 1u64)': Option<u64>
+            254..263 '|_v| 1u64': |u32| -> u64
+            255..257 '_v': u32
+            259..263 '1u64': u64
+            274..275 'y': Option<i64>
+            291..292 'x': Option<u32>
+            291..304 'x.map(|_v| 1)': Option<i64>
+            297..303 '|_v| 1': |u32| -> i64
+            298..300 '_v': u32
+            302..303 '1': i64
+        "#]],
     );
 }
 
 #[test]
 fn closure_2() {
-    assert_snapshot!(
-        infer(r#"
-trait FnOnce<Args> {
-    type Output;
-}
+    check_infer(
+        r#"
+        trait FnOnce<Args> {
+            type Output;
+        }
 
-fn test<F: FnOnce(u32) -> u64>(f: F) {
-    f(1);
-    let g = |v| v + 1;
-    g(1u64);
-    let h = |v| 1u128 + v;
-}
-"#),
-        @r###"
-    72..73 'f': F
-    78..154 '{     ...+ v; }': ()
-    84..85 'f': F
-    84..88 'f(1)': {unknown}
-    86..87 '1': i32
-    98..99 'g': |u64| -> i32
-    102..111 '|v| v + 1': |u64| -> i32
-    103..104 'v': u64
-    106..107 'v': u64
-    106..111 'v + 1': i32
-    110..111 '1': i32
-    117..118 'g': |u64| -> i32
-    117..124 'g(1u64)': i32
-    119..123 '1u64': u64
-    134..135 'h': |u128| -> u128
-    138..151 '|v| 1u128 + v': |u128| -> u128
-    139..140 'v': u128
-    142..147 '1u128': u128
-    142..151 '1u128 + v': u128
-    150..151 'v': u128
-    "###
+        fn test<F: FnOnce(u32) -> u64>(f: F) {
+            f(1);
+            let g = |v| v + 1;
+            g(1u64);
+            let h = |v| 1u128 + v;
+        }
+        "#,
+        expect![[r#"
+            72..73 'f': F
+            78..154 '{     ...+ v; }': ()
+            84..85 'f': F
+            84..88 'f(1)': {unknown}
+            86..87 '1': i32
+            98..99 'g': |u64| -> i32
+            102..111 '|v| v + 1': |u64| -> i32
+            103..104 'v': u64
+            106..107 'v': u64
+            106..111 'v + 1': i32
+            110..111 '1': i32
+            117..118 'g': |u64| -> i32
+            117..124 'g(1u64)': i32
+            119..123 '1u64': u64
+            134..135 'h': |u128| -> u128
+            138..151 '|v| 1u128 + v': |u128| -> u128
+            139..140 'v': u128
+            142..147 '1u128': u128
+            142..151 '1u128 + v': u128
+            150..151 'v': u128
+        "#]],
     );
 }
 
 #[test]
 fn closure_as_argument_inference_order() {
-    assert_snapshot!(
-        infer(r#"
-#[lang = "fn_once"]
-trait FnOnce<Args> {
-    type Output;
-}
+    check_infer(
+        r#"
+        #[lang = "fn_once"]
+        trait FnOnce<Args> {
+            type Output;
+        }
 
-fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U {}
-fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U {}
+        fn foo1<T, U, F: FnOnce(T) -> U>(x: T, f: F) -> U {}
+        fn foo2<T, U, F: FnOnce(T) -> U>(f: F, x: T) -> U {}
 
-struct S;
-impl S {
-    fn method(self) -> u64;
+        struct S;
+        impl S {
+            fn method(self) -> u64;
 
-    fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U {}
-    fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U {}
-}
+            fn foo1<T, U, F: FnOnce(T) -> U>(self, x: T, f: F) -> U {}
+            fn foo2<T, U, F: FnOnce(T) -> U>(self, f: F, x: T) -> U {}
+        }
 
-fn test() {
-    let x1 = foo1(S, |s| s.method());
-    let x2 = foo2(|s| s.method(), S);
-    let x3 = S.foo1(S, |s| s.method());
-    let x4 = S.foo2(|s| s.method(), S);
-}
-"#),
-        @r###"
-    94..95 'x': T
-    100..101 'f': F
-    111..113 '{}': ()
-    147..148 'f': F
-    153..154 'x': T
-    164..166 '{}': ()
-    201..205 'self': S
-    253..257 'self': S
-    259..260 'x': T
-    265..266 'f': F
-    276..278 '{}': ()
-    316..320 'self': S
-    322..323 'f': F
-    328..329 'x': T
-    339..341 '{}': ()
-    355..514 '{     ... S); }': ()
-    365..367 'x1': u64
-    370..374 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
-    370..393 'foo1(S...hod())': u64
-    375..376 'S': S
-    378..392 '|s| s.method()': |S| -> u64
-    379..380 's': S
-    382..383 's': S
-    382..392 's.method()': u64
-    403..405 'x2': u64
-    408..412 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
-    408..431 'foo2(|...(), S)': u64
-    413..427 '|s| s.method()': |S| -> u64
-    414..415 's': S
-    417..418 's': S
-    417..427 's.method()': u64
-    429..430 'S': S
-    441..443 'x3': u64
-    446..447 'S': S
-    446..471 'S.foo1...hod())': u64
-    453..454 'S': S
-    456..470 '|s| s.method()': |S| -> u64
-    457..458 's': S
-    460..461 's': S
-    460..470 's.method()': u64
-    481..483 'x4': u64
-    486..487 'S': S
-    486..511 'S.foo2...(), S)': u64
-    493..507 '|s| s.method()': |S| -> u64
-    494..495 's': S
-    497..498 's': S
-    497..507 's.method()': u64
-    509..510 'S': S
-    "###
+        fn test() {
+            let x1 = foo1(S, |s| s.method());
+            let x2 = foo2(|s| s.method(), S);
+            let x3 = S.foo1(S, |s| s.method());
+            let x4 = S.foo2(|s| s.method(), S);
+        }
+        "#,
+        expect![[r#"
+            94..95 'x': T
+            100..101 'f': F
+            111..113 '{}': ()
+            147..148 'f': F
+            153..154 'x': T
+            164..166 '{}': ()
+            201..205 'self': S
+            253..257 'self': S
+            259..260 'x': T
+            265..266 'f': F
+            276..278 '{}': ()
+            316..320 'self': S
+            322..323 'f': F
+            328..329 'x': T
+            339..341 '{}': ()
+            355..514 '{     ... S); }': ()
+            365..367 'x1': u64
+            370..374 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
+            370..393 'foo1(S...hod())': u64
+            375..376 'S': S
+            378..392 '|s| s.method()': |S| -> u64
+            379..380 's': S
+            382..383 's': S
+            382..392 's.method()': u64
+            403..405 'x2': u64
+            408..412 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
+            408..431 'foo2(|...(), S)': u64
+            413..427 '|s| s.method()': |S| -> u64
+            414..415 's': S
+            417..418 's': S
+            417..427 's.method()': u64
+            429..430 'S': S
+            441..443 'x3': u64
+            446..447 'S': S
+            446..471 'S.foo1...hod())': u64
+            453..454 'S': S
+            456..470 '|s| s.method()': |S| -> u64
+            457..458 's': S
+            460..461 's': S
+            460..470 's.method()': u64
+            481..483 'x4': u64
+            486..487 'S': S
+            486..511 'S.foo2...(), S)': u64
+            493..507 '|s| s.method()': |S| -> u64
+            494..495 's': S
+            497..498 's': S
+            497..507 's.method()': u64
+            509..510 'S': S
+        "#]],
     );
 }
 
@@ -2056,43 +2055,44 @@ fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
 
 #[test]
 fn unselected_projection_on_impl_self() {
-    assert_snapshot!(infer(
+    check_infer(
         r#"
-//- /main.rs
-trait Trait {
-    type Item;
+        //- /main.rs
+        trait Trait {
+            type Item;
 
-    fn f(&self, x: Self::Item);
-}
+            fn f(&self, x: Self::Item);
+        }
 
-struct S;
+        struct S;
 
-impl Trait for S {
-    type Item = u32;
-    fn f(&self, x: Self::Item) { let y = x; }
-}
+        impl Trait for S {
+            type Item = u32;
+            fn f(&self, x: Self::Item) { let y = x; }
+        }
 
-struct S2;
+        struct S2;
 
-impl Trait for S2 {
-    type Item = i32;
-    fn f(&self, x: <Self>::Item) { let y = x; }
-}
-"#,
-    ), @r###"
-    40..44 'self': &Self
-    46..47 'x': Trait::Item<Self>
-    126..130 'self': &S
-    132..133 'x': u32
-    147..161 '{ let y = x; }': ()
-    153..154 'y': u32
-    157..158 'x': u32
-    228..232 'self': &S2
-    234..235 'x': i32
-    251..265 '{ let y = x; }': ()
-    257..258 'y': i32
-    261..262 'x': i32
-    "###);
+        impl Trait for S2 {
+            type Item = i32;
+            fn f(&self, x: <Self>::Item) { let y = x; }
+        }
+        "#,
+        expect![[r#"
+            40..44 'self': &Self
+            46..47 'x': Trait::Item<Self>
+            126..130 'self': &S
+            132..133 'x': u32
+            147..161 '{ let y = x; }': ()
+            153..154 'y': u32
+            157..158 'x': u32
+            228..232 'self': &S2
+            234..235 'x': i32
+            251..265 '{ let y = x; }': ()
+            257..258 'y': i32
+            261..262 'x': i32
+        "#]],
+    );
 }
 
 #[test]
@@ -2261,170 +2261,170 @@ fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
 
 #[test]
 fn proc_macro_server_types() {
-    assert_snapshot!(
-        infer(r#"
-macro_rules! with_api {
-    ($S:ident, $self:ident, $m:ident) => {
-        $m! {
-            TokenStream {
-                fn new() -> $S::TokenStream;
-            },
-            Group {
-            },
-        }
-    };
-}
-macro_rules! associated_item {
-    (type TokenStream) =>
-        (type TokenStream: 'static;);
-    (type Group) =>
-        (type Group: 'static;);
-    ($($item:tt)*) => ($($item)*;)
-}
-macro_rules! declare_server_traits {
-    ($($name:ident {
-        $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
-    }),* $(,)?) => {
-        pub trait Types {
-            $(associated_item!(type $name);)*
-        }
-
-        $(pub trait $name: Types {
-            $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)*
-        })*
-
-        pub trait Server: Types $(+ $name)* {}
-        impl<S: Types $(+ $name)*> Server for S {}
-    }
-}
+    check_infer(
+        r#"
+        macro_rules! with_api {
+            ($S:ident, $self:ident, $m:ident) => {
+                $m! {
+                    TokenStream {
+                        fn new() -> $S::TokenStream;
+                    },
+                    Group {
+                    },
+                }
+            };
+        }
+        macro_rules! associated_item {
+            (type TokenStream) =>
+                (type TokenStream: 'static;);
+            (type Group) =>
+                (type Group: 'static;);
+            ($($item:tt)*) => ($($item)*;)
+        }
+        macro_rules! declare_server_traits {
+            ($($name:ident {
+                $(fn $method:ident($($arg:ident: $arg_ty:ty),* $(,)?) $(-> $ret_ty:ty)?;)*
+            }),* $(,)?) => {
+                pub trait Types {
+                    $(associated_item!(type $name);)*
+                }
 
-with_api!(Self, self_, declare_server_traits);
-struct G {}
-struct T {}
-struct Rustc;
-impl Types for Rustc {
-    type TokenStream = T;
-    type Group = G;
-}
+                $(pub trait $name: Types {
+                    $(associated_item!(fn $method($($arg: $arg_ty),*) $(-> $ret_ty)?);)*
+                })*
 
-fn make<T>() -> T { loop {} }
-impl TokenStream for Rustc {
-    fn new() -> Self::TokenStream {
-        let group: Self::Group = make();
-        make()
-    }
-}
-"#),
-        @r###"
-    1061..1072 '{ loop {} }': T
-    1063..1070 'loop {}': !
-    1068..1070 '{}': ()
-    1136..1199 '{     ...     }': T
-    1150..1155 'group': G
-    1171..1175 'make': fn make<G>() -> G
-    1171..1177 'make()': G
-    1187..1191 'make': fn make<T>() -> T
-    1187..1193 'make()': T
-    "###
+                pub trait Server: Types $(+ $name)* {}
+                impl<S: Types $(+ $name)*> Server for S {}
+            }
+        }
+
+        with_api!(Self, self_, declare_server_traits);
+        struct G {}
+        struct T {}
+        struct Rustc;
+        impl Types for Rustc {
+            type TokenStream = T;
+            type Group = G;
+        }
+
+        fn make<T>() -> T { loop {} }
+        impl TokenStream for Rustc {
+            fn new() -> Self::TokenStream {
+                let group: Self::Group = make();
+                make()
+            }
+        }
+        "#,
+        expect![[r#"
+            1061..1072 '{ loop {} }': T
+            1063..1070 'loop {}': !
+            1068..1070 '{}': ()
+            1136..1199 '{     ...     }': T
+            1150..1155 'group': G
+            1171..1175 'make': fn make<G>() -> G
+            1171..1177 'make()': G
+            1187..1191 'make': fn make<T>() -> T
+            1187..1193 'make()': T
+        "#]],
     );
 }
 
 #[test]
 fn unify_impl_trait() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Trait<T> {}
+    check_infer_with_mismatches(
+        r#"
+        trait Trait<T> {}
+
+        fn foo(x: impl Trait<u32>) { loop {} }
+        fn bar<T>(x: impl Trait<T>) -> T { loop {} }
+
+        struct S<T>(T);
+        impl<T> Trait<T> for S<T> {}
+
+        fn default<T>() -> T { loop {} }
 
-fn foo(x: impl Trait<u32>) { loop {} }
-fn bar<T>(x: impl Trait<T>) -> T { loop {} }
-
-struct S<T>(T);
-impl<T> Trait<T> for S<T> {}
-
-fn default<T>() -> T { loop {} }
-
-fn test() -> impl Trait<i32> {
-    let s1 = S(default());
-    foo(s1);
-    let x: i32 = bar(S(default()));
-    S(default())
-}
-"#, true),
-        @r###"
-    26..27 'x': impl Trait<u32>
-    46..57 '{ loop {} }': ()
-    48..55 'loop {}': !
-    53..55 '{}': ()
-    68..69 'x': impl Trait<T>
-    91..102 '{ loop {} }': T
-    93..100 'loop {}': !
-    98..100 '{}': ()
-    171..182 '{ loop {} }': T
-    173..180 'loop {}': !
-    178..180 '{}': ()
-    213..309 '{     ...t()) }': S<{unknown}>
-    223..225 's1': S<u32>
-    228..229 'S': S<u32>(u32) -> S<u32>
-    228..240 'S(default())': S<u32>
-    230..237 'default': fn default<u32>() -> u32
-    230..239 'default()': u32
-    246..249 'foo': fn foo(S<u32>)
-    246..253 'foo(s1)': ()
-    250..252 's1': S<u32>
-    263..264 'x': i32
-    272..275 'bar': fn bar<i32>(S<i32>) -> i32
-    272..289 'bar(S(...lt()))': i32
-    276..277 'S': S<i32>(i32) -> S<i32>
-    276..288 'S(default())': S<i32>
-    278..285 'default': fn default<i32>() -> i32
-    278..287 'default()': i32
-    295..296 'S': S<{unknown}>({unknown}) -> S<{unknown}>
-    295..307 'S(default())': S<{unknown}>
-    297..304 'default': fn default<{unknown}>() -> {unknown}
-    297..306 'default()': {unknown}
-    "###
+        fn test() -> impl Trait<i32> {
+            let s1 = S(default());
+            foo(s1);
+            let x: i32 = bar(S(default()));
+            S(default())
+        }
+        "#,
+        expect![[r#"
+            26..27 'x': impl Trait<u32>
+            46..57 '{ loop {} }': ()
+            48..55 'loop {}': !
+            53..55 '{}': ()
+            68..69 'x': impl Trait<T>
+            91..102 '{ loop {} }': T
+            93..100 'loop {}': !
+            98..100 '{}': ()
+            171..182 '{ loop {} }': T
+            173..180 'loop {}': !
+            178..180 '{}': ()
+            213..309 '{     ...t()) }': S<{unknown}>
+            223..225 's1': S<u32>
+            228..229 'S': S<u32>(u32) -> S<u32>
+            228..240 'S(default())': S<u32>
+            230..237 'default': fn default<u32>() -> u32
+            230..239 'default()': u32
+            246..249 'foo': fn foo(S<u32>)
+            246..253 'foo(s1)': ()
+            250..252 's1': S<u32>
+            263..264 'x': i32
+            272..275 'bar': fn bar<i32>(S<i32>) -> i32
+            272..289 'bar(S(...lt()))': i32
+            276..277 'S': S<i32>(i32) -> S<i32>
+            276..288 'S(default())': S<i32>
+            278..285 'default': fn default<i32>() -> i32
+            278..287 'default()': i32
+            295..296 'S': S<{unknown}>({unknown}) -> S<{unknown}>
+            295..307 'S(default())': S<{unknown}>
+            297..304 'default': fn default<{unknown}>() -> {unknown}
+            297..306 'default()': {unknown}
+        "#]],
     );
 }
 
 #[test]
 fn assoc_types_from_bounds() {
-    assert_snapshot!(
-        infer(r#"
-//- /main.rs
-#[lang = "fn_once"]
-trait FnOnce<Args> {
-    type Output;
-}
+    check_infer(
+        r#"
+        //- /main.rs
+        #[lang = "fn_once"]
+        trait FnOnce<Args> {
+            type Output;
+        }
 
-trait T {
-    type O;
-}
+        trait T {
+            type O;
+        }
 
-impl T for () {
-    type O = ();
-}
+        impl T for () {
+            type O = ();
+        }
 
-fn f<X, F>(_v: F)
-where
-    X: T,
-    F: FnOnce(&X::O),
-{ }
+        fn f<X, F>(_v: F)
+        where
+            X: T,
+            F: FnOnce(&X::O),
+        { }
 
-fn main() {
-    f::<(), _>(|z| { z; });
-}
-"#),
-        @r###"
-    133..135 '_v': F
-    178..181 '{ }': ()
-    193..224 '{     ... }); }': ()
-    199..209 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
-    199..221 'f::<()... z; })': ()
-    210..220 '|z| { z; }': |&()| -> ()
-    211..212 'z': &()
-    214..220 '{ z; }': ()
-    216..217 'z': &()
-    "###
+        fn main() {
+            f::<(), _>(|z| { z; });
+        }
+        "#,
+        expect![[r#"
+            133..135 '_v': F
+            178..181 '{ }': ()
+            193..224 '{     ... }); }': ()
+            199..209 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
+            199..221 'f::<()... z; })': ()
+            210..220 '|z| { z; }': |&()| -> ()
+            211..212 'z': &()
+            214..220 '{ z; }': ()
+            216..217 'z': &()
+        "#]],
     );
 }
 
@@ -2497,120 +2497,120 @@ fn test() {
 
 #[test]
 fn iterator_chain() {
-    assert_snapshot!(
-        infer(r#"
-//- /main.rs
-#[lang = "fn_once"]
-trait FnOnce<Args> {
-    type Output;
-}
-#[lang = "fn_mut"]
-trait FnMut<Args>: FnOnce<Args> { }
+    check_infer(
+        r#"
+        //- /main.rs
+        #[lang = "fn_once"]
+        trait FnOnce<Args> {
+            type Output;
+        }
+        #[lang = "fn_mut"]
+        trait FnMut<Args>: FnOnce<Args> { }
 
-enum Option<T> { Some(T), None }
-use Option::*;
+        enum Option<T> { Some(T), None }
+        use Option::*;
 
-pub trait Iterator {
-    type Item;
+        pub trait Iterator {
+            type Item;
 
-    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
-    where
-        F: FnMut(Self::Item) -> Option<B>,
-    { loop {} }
+            fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
+            where
+                F: FnMut(Self::Item) -> Option<B>,
+            { loop {} }
 
-    fn for_each<F>(self, f: F)
-    where
-        F: FnMut(Self::Item),
-    { loop {} }
-}
+            fn for_each<F>(self, f: F)
+            where
+                F: FnMut(Self::Item),
+            { loop {} }
+        }
 
-pub trait IntoIterator {
-    type Item;
-    type IntoIter: Iterator<Item = Self::Item>;
-    fn into_iter(self) -> Self::IntoIter;
-}
+        pub trait IntoIterator {
+            type Item;
+            type IntoIter: Iterator<Item = Self::Item>;
+            fn into_iter(self) -> Self::IntoIter;
+        }
 
-pub struct FilterMap<I, F> { }
-impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
-where
-    F: FnMut(I::Item) -> Option<B>,
-{
-    type Item = B;
-}
+        pub struct FilterMap<I, F> { }
+        impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
+        where
+            F: FnMut(I::Item) -> Option<B>,
+        {
+            type Item = B;
+        }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: Iterator> IntoIterator for I {
-    type Item = I::Item;
-    type IntoIter = I;
+        #[stable(feature = "rust1", since = "1.0.0")]
+        impl<I: Iterator> IntoIterator for I {
+            type Item = I::Item;
+            type IntoIter = I;
 
-    fn into_iter(self) -> I {
-        self
-    }
-}
+            fn into_iter(self) -> I {
+                self
+            }
+        }
 
-struct Vec<T> {}
-impl<T> Vec<T> {
-    fn new() -> Self { loop {} }
-}
+        struct Vec<T> {}
+        impl<T> Vec<T> {
+            fn new() -> Self { loop {} }
+        }
 
-impl<T> IntoIterator for Vec<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-}
+        impl<T> IntoIterator for Vec<T> {
+            type Item = T;
+            type IntoIter = IntoIter<T>;
+        }
 
-pub struct IntoIter<T> { }
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-}
+        pub struct IntoIter<T> { }
+        impl<T> Iterator for IntoIter<T> {
+            type Item = T;
+        }
 
-fn main() {
-    Vec::<i32>::new().into_iter()
-      .filter_map(|x| if x > 0 { Some(x as u32) } else { None })
-      .for_each(|y| { y; });
-}
-"#),
-        @r###"
-    226..230 'self': Self
-    232..233 'f': F
-    317..328 '{ loop {} }': FilterMap<Self, F>
-    319..326 'loop {}': !
-    324..326 '{}': ()
-    349..353 'self': Self
-    355..356 'f': F
-    405..416 '{ loop {} }': ()
-    407..414 'loop {}': !
-    412..414 '{}': ()
-    525..529 'self': Self
-    854..858 'self': I
-    865..885 '{     ...     }': I
-    875..879 'self': I
-    944..955 '{ loop {} }': Vec<T>
-    946..953 'loop {}': !
-    951..953 '{}': ()
-    1142..1273 '{     ... }); }': ()
-    1148..1163 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
-    1148..1165 'Vec::<...:new()': Vec<i32>
-    1148..1177 'Vec::<...iter()': IntoIter<i32>
-    1148..1242 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
-    1148..1270 'Vec::<... y; })': ()
-    1196..1241 '|x| if...None }': |i32| -> Option<u32>
-    1197..1198 'x': i32
-    1200..1241 'if x >...None }': Option<u32>
-    1203..1204 'x': i32
-    1203..1208 'x > 0': bool
-    1207..1208 '0': i32
-    1209..1227 '{ Some...u32) }': Option<u32>
-    1211..1215 'Some': Some<u32>(u32) -> Option<u32>
-    1211..1225 'Some(x as u32)': Option<u32>
-    1216..1217 'x': i32
-    1216..1224 'x as u32': u32
-    1233..1241 '{ None }': Option<u32>
-    1235..1239 'None': Option<u32>
-    1259..1269 '|y| { y; }': |u32| -> ()
-    1260..1261 'y': u32
-    1263..1269 '{ y; }': ()
-    1265..1266 'y': u32
-    "###
+        fn main() {
+            Vec::<i32>::new().into_iter()
+            .filter_map(|x| if x > 0 { Some(x as u32) } else { None })
+            .for_each(|y| { y; });
+        }
+        "#,
+        expect![[r#"
+            226..230 'self': Self
+            232..233 'f': F
+            317..328 '{ loop {} }': FilterMap<Self, F>
+            319..326 'loop {}': !
+            324..326 '{}': ()
+            349..353 'self': Self
+            355..356 'f': F
+            405..416 '{ loop {} }': ()
+            407..414 'loop {}': !
+            412..414 '{}': ()
+            525..529 'self': Self
+            854..858 'self': I
+            865..885 '{     ...     }': I
+            875..879 'self': I
+            944..955 '{ loop {} }': Vec<T>
+            946..953 'loop {}': !
+            951..953 '{}': ()
+            1142..1269 '{     ... }); }': ()
+            1148..1163 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
+            1148..1165 'Vec::<...:new()': Vec<i32>
+            1148..1177 'Vec::<...iter()': IntoIter<i32>
+            1148..1240 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
+            1148..1266 'Vec::<... y; })': ()
+            1194..1239 '|x| if...None }': |i32| -> Option<u32>
+            1195..1196 'x': i32
+            1198..1239 'if x >...None }': Option<u32>
+            1201..1202 'x': i32
+            1201..1206 'x > 0': bool
+            1205..1206 '0': i32
+            1207..1225 '{ Some...u32) }': Option<u32>
+            1209..1213 'Some': Some<u32>(u32) -> Option<u32>
+            1209..1223 'Some(x as u32)': Option<u32>
+            1214..1215 'x': i32
+            1214..1222 'x as u32': u32
+            1231..1239 '{ None }': Option<u32>
+            1233..1237 'None': Option<u32>
+            1255..1265 '|y| { y; }': |u32| -> ()
+            1256..1257 'y': u32
+            1259..1265 '{ y; }': ()
+            1261..1262 'y': u32
+        "#]],
     );
 }
 
@@ -2648,176 +2648,176 @@ fn main() {
 
 #[test]
 fn trait_object_no_coercion() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-trait Foo {}
+    check_infer_with_mismatches(
+        r#"
+        trait Foo {}
 
-fn foo(x: &dyn Foo) {}
+        fn foo(x: &dyn Foo) {}
 
-fn test(x: &dyn Foo) {
-    foo(x);
-}
-"#, true),
-        @r###"
-    21..22 'x': &dyn Foo
-    34..36 '{}': ()
-    46..47 'x': &dyn Foo
-    59..74 '{     foo(x); }': ()
-    65..68 'foo': fn foo(&dyn Foo)
-    65..71 'foo(x)': ()
-    69..70 'x': &dyn Foo
-    "###
+        fn test(x: &dyn Foo) {
+            foo(x);
+        }
+        "#,
+        expect![[r#"
+            21..22 'x': &dyn Foo
+            34..36 '{}': ()
+            46..47 'x': &dyn Foo
+            59..74 '{     foo(x); }': ()
+            65..68 'foo': fn foo(&dyn Foo)
+            65..71 'foo(x)': ()
+            69..70 'x': &dyn Foo
+        "#]],
     );
 }
 
 #[test]
 fn builtin_copy() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-#[lang = "copy"]
-trait Copy {}
+    check_infer_with_mismatches(
+        r#"
+        #[lang = "copy"]
+        trait Copy {}
 
-struct IsCopy;
-impl Copy for IsCopy {}
-struct NotCopy;
+        struct IsCopy;
+        impl Copy for IsCopy {}
+        struct NotCopy;
 
-trait Test { fn test(&self) -> bool; }
-impl<T: Copy> Test for T {}
+        trait Test { fn test(&self) -> bool; }
+        impl<T: Copy> Test for T {}
 
-fn test() {
-    IsCopy.test();
-    NotCopy.test();
-    (IsCopy, IsCopy).test();
-    (IsCopy, NotCopy).test();
-}
-"#, true),
-        @r###"
-    110..114 'self': &Self
-    166..267 '{     ...t(); }': ()
-    172..178 'IsCopy': IsCopy
-    172..185 'IsCopy.test()': bool
-    191..198 'NotCopy': NotCopy
-    191..205 'NotCopy.test()': {unknown}
-    211..227 '(IsCop...sCopy)': (IsCopy, IsCopy)
-    211..234 '(IsCop...test()': bool
-    212..218 'IsCopy': IsCopy
-    220..226 'IsCopy': IsCopy
-    240..257 '(IsCop...tCopy)': (IsCopy, NotCopy)
-    240..264 '(IsCop...test()': {unknown}
-    241..247 'IsCopy': IsCopy
-    249..256 'NotCopy': NotCopy
-    "###
+        fn test() {
+            IsCopy.test();
+            NotCopy.test();
+            (IsCopy, IsCopy).test();
+            (IsCopy, NotCopy).test();
+        }
+        "#,
+        expect![[r#"
+            110..114 'self': &Self
+            166..267 '{     ...t(); }': ()
+            172..178 'IsCopy': IsCopy
+            172..185 'IsCopy.test()': bool
+            191..198 'NotCopy': NotCopy
+            191..205 'NotCopy.test()': {unknown}
+            211..227 '(IsCop...sCopy)': (IsCopy, IsCopy)
+            211..234 '(IsCop...test()': bool
+            212..218 'IsCopy': IsCopy
+            220..226 'IsCopy': IsCopy
+            240..257 '(IsCop...tCopy)': (IsCopy, NotCopy)
+            240..264 '(IsCop...test()': {unknown}
+            241..247 'IsCopy': IsCopy
+            249..256 'NotCopy': NotCopy
+        "#]],
     );
 }
 
 #[test]
 fn builtin_fn_def_copy() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-#[lang = "copy"]
-trait Copy {}
-
-fn foo() {}
-fn bar<T: Copy>(T) -> T {}
-struct Struct(usize);
-enum Enum { Variant(usize) }
-
-trait Test { fn test(&self) -> bool; }
-impl<T: Copy> Test for T {}
-
-fn test() {
-    foo.test();
-    bar.test();
-    Struct.test();
-    Enum::Variant.test();
-}
-"#, true),
-        @r###"
-    41..43 '{}': ()
-    60..61 'T': {unknown}
-    68..70 '{}': ()
-    68..70: expected T, got ()
-    145..149 'self': &Self
-    201..281 '{     ...t(); }': ()
-    207..210 'foo': fn foo()
-    207..217 'foo.test()': bool
-    223..226 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
-    223..233 'bar.test()': bool
-    239..245 'Struct': Struct(usize) -> Struct
-    239..252 'Struct.test()': bool
-    258..271 'Enum::Variant': Variant(usize) -> Enum
-    258..278 'Enum::...test()': bool
-    "###
+    check_infer_with_mismatches(
+        r#"
+        #[lang = "copy"]
+        trait Copy {}
+
+        fn foo() {}
+        fn bar<T: Copy>(T) -> T {}
+        struct Struct(usize);
+        enum Enum { Variant(usize) }
+
+        trait Test { fn test(&self) -> bool; }
+        impl<T: Copy> Test for T {}
+
+        fn test() {
+            foo.test();
+            bar.test();
+            Struct.test();
+            Enum::Variant.test();
+        }
+        "#,
+        expect![[r#"
+            41..43 '{}': ()
+            60..61 'T': {unknown}
+            68..70 '{}': ()
+            68..70: expected T, got ()
+            145..149 'self': &Self
+            201..281 '{     ...t(); }': ()
+            207..210 'foo': fn foo()
+            207..217 'foo.test()': bool
+            223..226 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
+            223..233 'bar.test()': bool
+            239..245 'Struct': Struct(usize) -> Struct
+            239..252 'Struct.test()': bool
+            258..271 'Enum::Variant': Variant(usize) -> Enum
+            258..278 'Enum::...test()': bool
+        "#]],
     );
 }
 
 #[test]
 fn builtin_fn_ptr_copy() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-#[lang = "copy"]
-trait Copy {}
+    check_infer_with_mismatches(
+        r#"
+        #[lang = "copy"]
+        trait Copy {}
 
-trait Test { fn test(&self) -> bool; }
-impl<T: Copy> Test for T {}
+        trait Test { fn test(&self) -> bool; }
+        impl<T: Copy> Test for T {}
 
-fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
-    f1.test();
-    f2.test();
-    f3.test();
-}
-"#, true),
-        @r###"
-    54..58 'self': &Self
-    108..110 'f1': fn()
-    118..120 'f2': fn(usize) -> u8
-    139..141 'f3': fn(u8, u8) -> &u8
-    162..210 '{     ...t(); }': ()
-    168..170 'f1': fn()
-    168..177 'f1.test()': bool
-    183..185 'f2': fn(usize) -> u8
-    183..192 'f2.test()': bool
-    198..200 'f3': fn(u8, u8) -> &u8
-    198..207 'f3.test()': bool
-    "###
+        fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
+            f1.test();
+            f2.test();
+            f3.test();
+        }
+        "#,
+        expect![[r#"
+            54..58 'self': &Self
+            108..110 'f1': fn()
+            118..120 'f2': fn(usize) -> u8
+            139..141 'f3': fn(u8, u8) -> &u8
+            162..210 '{     ...t(); }': ()
+            168..170 'f1': fn()
+            168..177 'f1.test()': bool
+            183..185 'f2': fn(usize) -> u8
+            183..192 'f2.test()': bool
+            198..200 'f3': fn(u8, u8) -> &u8
+            198..207 'f3.test()': bool
+        "#]],
     );
 }
 
 #[test]
 fn builtin_sized() {
-    assert_snapshot!(
-        infer_with_mismatches(r#"
-#[lang = "sized"]
-trait Sized {}
+    check_infer_with_mismatches(
+        r#"
+        #[lang = "sized"]
+        trait Sized {}
 
-trait Test { fn test(&self) -> bool; }
-impl<T: Sized> Test for T {}
+        trait Test { fn test(&self) -> bool; }
+        impl<T: Sized> Test for T {}
 
-fn test() {
-    1u8.test();
-    (*"foo").test(); // not Sized
-    (1u8, 1u8).test();
-    (1u8, *"foo").test(); // not Sized
-}
-"#, true),
-        @r###"
-    56..60 'self': &Self
-    113..228 '{     ...ized }': ()
-    119..122 '1u8': u8
-    119..129 '1u8.test()': bool
-    135..150 '(*"foo").test()': {unknown}
-    136..142 '*"foo"': str
-    137..142 '"foo"': &str
-    169..179 '(1u8, 1u8)': (u8, u8)
-    169..186 '(1u8, ...test()': bool
-    170..173 '1u8': u8
-    175..178 '1u8': u8
-    192..205 '(1u8, *"foo")': (u8, str)
-    192..212 '(1u8, ...test()': {unknown}
-    193..196 '1u8': u8
-    198..204 '*"foo"': str
-    199..204 '"foo"': &str
-    "###
+        fn test() {
+            1u8.test();
+            (*"foo").test(); // not Sized
+            (1u8, 1u8).test();
+            (1u8, *"foo").test(); // not Sized
+        }
+        "#,
+        expect![[r#"
+            56..60 'self': &Self
+            113..228 '{     ...ized }': ()
+            119..122 '1u8': u8
+            119..129 '1u8.test()': bool
+            135..150 '(*"foo").test()': {unknown}
+            136..142 '*"foo"': str
+            137..142 '"foo"': &str
+            169..179 '(1u8, 1u8)': (u8, u8)
+            169..186 '(1u8, ...test()': bool
+            170..173 '1u8': u8
+            175..178 '1u8': u8
+            192..205 '(1u8, *"foo")': (u8, str)
+            192..212 '(1u8, ...test()': {unknown}
+            193..196 '1u8': u8
+            198..204 '*"foo"': str
+            199..204 '"foo"': &str
+        "#]],
     );
 }
 
@@ -2867,156 +2867,150 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
 
 #[test]
 fn infer_closure_arg() {
-    assert_snapshot!(
-        infer(
-            r#"
-            //- /lib.rs
-
-            enum Option<T> {
-                None,
-                Some(T)
-            }
+    check_infer(
+        r#"
+        //- /lib.rs
 
-            fn foo() {
-                let s = Option::None;
-                let f = |x: Option<i32>| {};
-                (&f)(s)
-            }
-        "#
-        ),
-        @r###"
-    52..126 '{     ...)(s) }': ()
-    62..63 's': Option<i32>
-    66..78 'Option::None': Option<i32>
-    88..89 'f': |Option<i32>| -> ()
-    92..111 '|x: Op...2>| {}': |Option<i32>| -> ()
-    93..94 'x': Option<i32>
-    109..111 '{}': ()
-    117..124 '(&f)(s)': ()
-    118..120 '&f': &|Option<i32>| -> ()
-    119..120 'f': |Option<i32>| -> ()
-    122..123 's': Option<i32>
-    "###
+        enum Option<T> {
+            None,
+            Some(T)
+        }
+
+        fn foo() {
+            let s = Option::None;
+            let f = |x: Option<i32>| {};
+            (&f)(s)
+        }
+        "#,
+        expect![[r#"
+            52..126 '{     ...)(s) }': ()
+            62..63 's': Option<i32>
+            66..78 'Option::None': Option<i32>
+            88..89 'f': |Option<i32>| -> ()
+            92..111 '|x: Op...2>| {}': |Option<i32>| -> ()
+            93..94 'x': Option<i32>
+            109..111 '{}': ()
+            117..124 '(&f)(s)': ()
+            118..120 '&f': &|Option<i32>| -> ()
+            119..120 'f': |Option<i32>| -> ()
+            122..123 's': Option<i32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_fn_trait_arg() {
-    assert_snapshot!(
-        infer(
-            r#"
-            //- /lib.rs deps:std
+    check_infer(
+        r#"
+        //- /lib.rs deps:std
 
-            #[lang = "fn_once"]
-            pub trait FnOnce<Args> {
-                type Output;
+        #[lang = "fn_once"]
+        pub trait FnOnce<Args> {
+            type Output;
 
-                extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
-            }
+            extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
+        }
 
-            #[lang = "fn"]
-            pub trait Fn<Args>:FnOnce<Args> {
-                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
-            }
+        #[lang = "fn"]
+        pub trait Fn<Args>:FnOnce<Args> {
+            extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+        }
 
-            enum Option<T> {
-                None,
-                Some(T)
-            }
+        enum Option<T> {
+            None,
+            Some(T)
+        }
 
-            fn foo<F, T>(f: F) -> T
-            where
-                F: Fn(Option<i32>) -> T,
-            {
-                let s = None;
-                f(s)
-            }
-        "#
-        ),
-        @r###"
-    101..105 'self': &Self
-    107..111 'args': Args
-    220..224 'self': &Self
-    226..230 'args': Args
-    313..314 'f': F
-    359..389 '{     ...f(s) }': T
-    369..370 's': Option<i32>
-    373..377 'None': Option<i32>
-    383..384 'f': F
-    383..387 'f(s)': T
-    385..386 's': Option<i32>
-    "###
+        fn foo<F, T>(f: F) -> T
+        where
+            F: Fn(Option<i32>) -> T,
+        {
+            let s = None;
+            f(s)
+        }
+        "#,
+        expect![[r#"
+            101..105 'self': &Self
+            107..111 'args': Args
+            220..224 'self': &Self
+            226..230 'args': Args
+            313..314 'f': F
+            359..389 '{     ...f(s) }': T
+            369..370 's': Option<i32>
+            373..377 'None': Option<i32>
+            383..384 'f': F
+            383..387 'f(s)': T
+            385..386 's': Option<i32>
+        "#]],
     );
 }
 
 #[test]
 fn infer_box_fn_arg() {
-    assert_snapshot!(
-        infer(
-            r#"
-            //- /lib.rs deps:std
+    check_infer(
+        r#"
+        //- /lib.rs deps:std
 
-            #[lang = "fn_once"]
-            pub trait FnOnce<Args> {
-                type Output;
+        #[lang = "fn_once"]
+        pub trait FnOnce<Args> {
+            type Output;
 
-                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-            }
+            extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+        }
 
-            #[lang = "deref"]
-            pub trait Deref {
-                type Target: ?Sized;
+        #[lang = "deref"]
+        pub trait Deref {
+            type Target: ?Sized;
 
-                fn deref(&self) -> &Self::Target;
-            }
+            fn deref(&self) -> &Self::Target;
+        }
 
-            #[lang = "owned_box"]
-            pub struct Box<T: ?Sized> {
-                inner: *mut T,
-            }
+        #[lang = "owned_box"]
+        pub struct Box<T: ?Sized> {
+            inner: *mut T,
+        }
 
-            impl<T: ?Sized> Deref for Box<T> {
-                type Target = T;
+        impl<T: ?Sized> Deref for Box<T> {
+            type Target = T;
 
-                fn deref(&self) -> &T {
-                    &self.inner
-                }
+            fn deref(&self) -> &T {
+                &self.inner
             }
+        }
 
-            enum Option<T> {
-                None,
-                Some(T)
-            }
+        enum Option<T> {
+            None,
+            Some(T)
+        }
 
-            fn foo() {
-                let s = Option::None;
-                let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
-                f(&s)
-            }
-        "#
-        ),
-        @r###"
-    100..104 'self': Self
-    106..110 'args': Args
-    214..218 'self': &Self
-    384..388 'self': &Box<T>
-    396..423 '{     ...     }': &T
-    406..417 '&self.inner': &*mut T
-    407..411 'self': &Box<T>
-    407..417 'self.inner': *mut T
-    478..575 '{     ...(&s) }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
-    488..489 's': Option<i32>
-    492..504 'Option::None': Option<i32>
-    514..515 'f': Box<dyn FnOnce<(&Option<i32>,)>>
-    549..562 'box (|ps| {})': Box<|{unknown}| -> ()>
-    554..561 '|ps| {}': |{unknown}| -> ()
-    555..557 'ps': {unknown}
-    559..561 '{}': ()
-    568..569 'f': Box<dyn FnOnce<(&Option<i32>,)>>
-    568..573 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
-    570..572 '&s': &Option<i32>
-    571..572 's': Option<i32>
-    "###
+        fn foo() {
+            let s = Option::None;
+            let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
+            f(&s)
+        }
+        "#,
+        expect![[r#"
+            100..104 'self': Self
+            106..110 'args': Args
+            214..218 'self': &Self
+            384..388 'self': &Box<T>
+            396..423 '{     ...     }': &T
+            406..417 '&self.inner': &*mut T
+            407..411 'self': &Box<T>
+            407..417 'self.inner': *mut T
+            478..575 '{     ...(&s) }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+            488..489 's': Option<i32>
+            492..504 'Option::None': Option<i32>
+            514..515 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+            549..562 'box (|ps| {})': Box<|{unknown}| -> ()>
+            554..561 '|ps| {}': |{unknown}| -> ()
+            555..557 'ps': {unknown}
+            559..561 '{}': ()
+            568..569 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+            568..573 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+            570..572 '&s': &Option<i32>
+            571..572 's': Option<i32>
+        "#]],
     );
 }