Merge #5472

5472: Replace insta with expect r=matklad a=lnicola



Co-authored-by: Laurențiu Nicola <[email protected]>

1 files changed, 588 insertions, 584 deletions

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}
+        "#]],
     );
 }