1 files changed, 1169 insertions, 872 deletions

diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index e8778d419..27737fa94 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,17 +1,13 @@
 use insta::assert_snapshot;
-use ra_db::fixture::WithFixture;
 use test_utils::mark;
 
-use crate::test_db::TestDB;
-
-use super::{infer, infer_with_mismatches, type_at, type_at_pos};
+use super::{check_types, infer, infer_with_mismatches};
 
 #[test]
 fn infer_await() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
-
+//- /main.rs crate:main deps:core
 struct IntFuture;
 
 impl Future for IntFuture {
@@ -21,10 +17,10 @@ impl Future for IntFuture {
 fn test() {
     let r = IntFuture;
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
-//- /std.rs crate:std
+//- /core.rs crate:core
 #[prelude_import] use future::*;
 mod future {
     #[lang = "future_trait"]
@@ -32,18 +28,15 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
-
+//- /main.rs crate:main deps:core
 async fn foo() -> u64 {
     128
 }
@@ -51,10 +44,10 @@ async fn foo() -> u64 {
 fn test() {
     let r = foo();
     let v = r.await;
-    v<|>;
-}
+    v;
+} //^ u64
 
-//- /std.rs crate:std
+//- /core.rs crate:core
 #[prelude_import] use future::*;
 mod future {
     #[lang = "future_trait"]
@@ -62,28 +55,25 @@ mod future {
         type Output;
     }
 }
-
 "#,
     );
-    assert_eq!("u64", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_desugar_async() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
-
+//- /main.rs crate:main deps:core
 async fn foo() -> u64 {
     128
 }
 
 fn test() {
     let r = foo();
-    r<|>;
-}
+    r;
+} //^ impl Future<Output = u64>
 
-//- /std.rs crate:std
+//- /core.rs crate:core
 #[prelude_import] use future::*;
 mod future {
     trait Future {
@@ -93,23 +83,20 @@ mod future {
 
 "#,
     );
-    assert_eq!("impl Future<Output = u64>", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_try() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
-
+//- /main.rs crate:main deps:core
 fn test() {
     let r: Result<i32, u64> = Result::Ok(1);
     let v = r?;
-    v<|>;
-}
-
-//- /std.rs crate:std
+    v;
+} //^ i32
 
+//- /core.rs crate:core
 #[prelude_import] use ops::*;
 mod ops {
     trait Try {
@@ -130,30 +117,26 @@ mod result {
         type Error = E;
     }
 }
-
 "#,
     );
-    assert_eq!("i32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_for_loop() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
-
-use std::collections::Vec;
+//- /main.rs crate:main deps:core,alloc
+use alloc::collections::Vec;
 
 fn test() {
     let v = Vec::new();
     v.push("foo");
     for x in v {
-        x<|>;
-    }
+        x;
+    } //^ &str
 }
 
-//- /std.rs crate:std
-
+//- /core.rs crate:core
 #[prelude_import] use iter::*;
 mod iter {
     trait IntoIterator {
@@ -161,6 +144,7 @@ mod iter {
     }
 }
 
+//- /alloc.rs crate:alloc deps:core
 mod collections {
     struct Vec<T> {}
     impl<T> Vec<T> {
@@ -168,21 +152,19 @@ mod collections {
         fn push(&mut self, t: T) { }
     }
 
-    impl<T> crate::iter::IntoIterator for Vec<T> {
+    impl<T> IntoIterator for Vec<T> {
         type Item=T;
     }
 }
 "#,
     );
-    assert_eq!("&str", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_neg() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -193,11 +175,10 @@ impl std::ops::Neg for Bar {
 fn test() {
     let a = Bar;
     let b = -a;
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
-
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "neg"]
@@ -207,15 +188,13 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_not() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -226,11 +205,10 @@ impl std::ops::Not for Bar {
 fn test() {
     let a = Bar;
     let b = !a;
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
-
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "not"]
@@ -240,7 +218,6 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -257,16 +234,16 @@ fn test() {
 }
 "#),
         @r###"
-    86..87 't': T
-    92..94 '{}': ()
-    105..144 '{     ...(s); }': ()
-    115..116 's': S<u32>
-    119..120 'S': S<u32>(u32) -> S<u32>
-    119..129 'S(unknown)': S<u32>
-    121..128 'unknown': u32
-    135..138 'foo': fn foo<S<u32>>(S<u32>)
-    135..141 'foo(s)': ()
-    139..140 's': S<u32>
+    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>
     "###
     );
 }
@@ -285,17 +262,17 @@ fn test() {
 }
 "#),
         @r###"
-    87..88 't': T
-    98..100 '{}': ()
-    111..163 '{     ...(s); }': ()
-    121..122 's': S<u32>
-    125..126 'S': S<u32>(u32) -> S<u32>
-    125..135 'S(unknown)': S<u32>
-    127..134 'unknown': u32
-    145..146 'x': u32
-    154..157 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
-    154..160 'foo(s)': u32
-    158..159 's': S<u32>
+    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>
     "###
     );
 }
@@ -313,12 +290,12 @@ trait Trait {
 }
 "#),
         @r###"
-    27..31 'self': &Self
-    53..57 'self': &Self
-    62..97 '{     ...     }': ()
-    76..77 'x': i64
-    80..84 'self': &Self
-    80..90 'self.foo()': i64
+    26..30 'self': &Self
+    52..56 'self': &Self
+    61..96 '{     ...     }': ()
+    75..76 'x': i64
+    79..83 'self': &Self
+    79..89 'self.foo()': i64
     "###
     );
 }
@@ -337,12 +314,12 @@ trait Trait: SuperTrait {
 }
 "#),
         @r###"
-    32..36 'self': &Self
-    86..90 'self': &Self
-    95..130 '{     ...     }': ()
-    109..110 'x': i64
-    113..117 'self': &Self
-    113..123 'self.foo()': i64
+    31..35 'self': &Self
+    85..89 'self': &Self
+    94..129 '{     ...     }': ()
+    108..109 'x': i64
+    112..116 'self': &Self
+    112..122 'self.foo()': i64
     "###
     );
 }
@@ -364,15 +341,15 @@ fn test<T: Iterable>() {
 }
 "#),
         @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>
+    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>
     "###
     );
 }
@@ -396,25 +373,25 @@ fn test() {
 }
 "#),
         @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
+    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
     "###
     );
 }
@@ -431,9 +408,9 @@ fn test<T: Iterable<Item=u32>>() {
 }
 "#),
         @r###"
-    67..100 '{     ...own; }': ()
-    77..78 'y': u32
-    90..97 'unknown': u32
+    66..99 '{     ...own; }': ()
+    76..77 'y': u32
+    89..96 'unknown': u32
     "###
     );
 }
@@ -446,13 +423,13 @@ const A: u32 = 1 + 1;
 static B: u64 = { let x = 1; x };
 "#),
         @r###"
-    16..17 '1': u32
-    16..21 '1 + 1': u32
-    20..21 '1': u32
-    39..55 '{ let ...1; x }': u64
-    45..46 'x': u64
-    49..50 '1': u64
-    52..53 'x': u64
+    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
     "###
     );
 }
@@ -469,17 +446,17 @@ fn test() -> u64 {
 }
 "#),
         @r###"
-    38..87 '{     ... a.1 }': u64
-    48..49 'a': S
-    52..53 'S': S(i32, u64) -> S
-    52..59 'S(4, 6)': S
-    54..55 '4': i32
-    57..58 '6': u64
-    69..70 'b': i32
-    73..74 'a': S
-    73..76 'a.0': i32
-    82..83 'a': S
-    82..85 'a.1': u64
+    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
     "###
     );
 }
@@ -496,24 +473,24 @@ fn test() -> u64 {
 }
 "#),
         @r###"
-    44..102 '{     ...0(2) }': u64
-    54..55 'a': S
-    58..59 'S': S(fn(u32) -> u64) -> S
-    58..68 'S(|i| 2*i)': S
-    60..67 '|i| 2*i': |u32| -> u64
-    61..62 'i': u32
-    64..65 '2': u32
-    64..67 '2*i': u32
-    66..67 'i': u32
-    78..79 'b': u64
-    82..83 'a': S
-    82..85 'a.0': fn(u32) -> u64
-    82..88 'a.0(4)': u64
-    86..87 '4': u32
-    94..95 'a': S
-    94..97 'a.0': fn(u32) -> u64
-    94..100 'a.0(2)': u64
-    98..99 '2': u32
+    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
     "###
     );
 }
@@ -535,10 +512,9 @@ fn indexing_arrays() {
 
 #[test]
 fn infer_ops_index() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
-
 struct Bar;
 struct Foo;
 
@@ -549,11 +525,46 @@ impl std::ops::Index<u32> for Bar {
 fn test() {
     let a = Bar;
     let b = a[1u32];
-    b<|>;
-}
+    b;
+} //^ Foo
 
 //- /std.rs crate:std
+#[prelude_import] use ops::*;
+mod ops {
+    #[lang = "index"]
+    pub trait Index<Idx> {
+        type Output;
+    }
+}
+"#,
+    );
+}
+
+#[test]
+fn infer_ops_index_int() {
+    check_types(
+        r#"
+//- /main.rs crate:main deps:std
+struct Bar;
+struct Foo;
+
+impl std::ops::Index<u32> for Bar {
+    type Output = Foo;
+}
+
+struct Range;
+impl std::ops::Index<Range> for Bar {
+    type Output = Bar;
+}
+
+fn test() {
+    let a = Bar;
+    let b = a[1];
+    b;
+  //^ Foo
+}
 
+//- /std.rs crate:std
 #[prelude_import] use ops::*;
 mod ops {
     #[lang = "index"]
@@ -563,19 +574,18 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("Foo", type_at_pos(&db, pos));
 }
 
 #[test]
 fn infer_ops_index_autoderef() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 fn test() {
     let a = &[1u32, 2, 3];
     let b = a[1u32];
-    b<|>;
-}
+    b;
+} //^ u32
 
 //- /std.rs crate:std
 impl<T> ops::Index<u32> for [T] {
@@ -591,14 +601,12 @@ mod ops {
 }
 "#,
     );
-    assert_eq!("u32", type_at_pos(&db, pos));
 }
 
 #[test]
 fn deref_trait() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -616,16 +624,15 @@ impl S {
 }
 
 fn test(s: Arc<S>) {
-    (*s, s.foo())<|>;
-}
+    (*s, s.foo());
+} //^ (S, u128)
 "#,
     );
-    assert_eq!(t, "(S, u128)");
 }
 
 #[test]
 fn deref_trait_with_inference_var() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 #[lang = "deref"]
@@ -645,19 +652,18 @@ fn foo(a: Arc<S>) {}
 
 fn test() {
     let a = new_arc();
-    let b = (*a)<|>;
+    let b = (*a);
+          //^ S
     foo(a);
 }
 "#,
     );
-    assert_eq!(t, "S");
 }
 
 #[test]
 fn deref_trait_infinite_recursion() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -671,18 +677,16 @@ impl Deref for S {
 }
 
 fn test(s: S) {
-    s.foo()<|>;
-}
+    s.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn deref_trait_with_question_mark_size() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -700,18 +704,16 @@ impl S {
 }
 
 fn test(s: Arc<S>) {
-    (*s, s.foo())<|>;
-}
+    (*s, s.foo());
+} //^ (S, u128)
 "#,
     );
-    assert_eq!(t, "(S, u128)");
 }
 
 #[test]
 fn obligation_from_function_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -720,16 +722,15 @@ impl Trait<u32> for S {}
 fn foo<T: Trait<U>, U>(t: T) -> U {}
 
 fn test(s: S) {
-    foo(s)<|>;
-}
+    (foo(s));
+} //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn obligation_from_method_clause() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 struct S;
@@ -743,18 +744,16 @@ impl O {
 }
 
 fn test() {
-    O.foo(S)<|>;
-}
+    O.foo(S);
+}      //^ isize
 "#,
     );
-    assert_eq!(t, "isize");
 }
 
 #[test]
 fn obligation_from_self_method_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -765,18 +764,16 @@ impl S {
 }
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ i64
 "#,
     );
-    assert_eq!(t, "i64");
 }
 
 #[test]
 fn obligation_from_impl_clause() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct S;
 
 trait Trait<T> {}
@@ -788,32 +785,30 @@ impl<U, T: Trait<U>> O<T> {
 }
 
 fn test(o: O<S>) {
-    o.foo()<|>;
-}
+    o.foo();
+}       //^ &str
 "#,
     );
-    assert_eq!(t, "&str");
 }
 
 #[test]
 fn generic_param_env_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Clone {}
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test<T: Clone>(t: T) { t.foo()<|>; }
+fn test<T: Clone>(t: T) { t.foo(); }
+                             //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn generic_param_env_1_not_met() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 trait Clone {}
@@ -821,45 +816,42 @@ trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Clone for S {}
 impl<T> Trait for T where T: Clone {}
-fn test<T>(t: T) { t.foo()<|>; }
+fn test<T>(t: T) { t.foo(); }
+                       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn generic_param_env_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
-fn test<T: Trait>(t: T) { t.foo()<|>; }
+fn test<T: Trait>(t: T) { t.foo(); }
+                              //^ u128
 "#,
     );
-    assert_eq!(t, "u128");
 }
 
 #[test]
 fn generic_param_env_2_not_met() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait { fn foo(self) -> u128; }
 struct S;
 impl Trait for S {}
-fn test<T>(t: T) { t.foo()<|>; }
+fn test<T>(t: T) { t.foo(); }
+                       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn generic_param_env_deref() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 #[lang = "deref"]
 trait Deref {
     type Target;
@@ -868,17 +860,17 @@ trait Trait {}
 impl<T> Deref for T where T: Trait {
     type Target = i128;
 }
-fn test<T: Trait>(t: T) { (*t)<|>; }
+fn test<T: Trait>(t: T) { (*t); }
+                        //^ i128
 "#,
     );
-    assert_eq!(t, "i128");
 }
 
 #[test]
 fn associated_type_placeholder() {
-    let t = type_at(
+    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
+    check_types(
         r#"
-//- /main.rs
 pub trait ApplyL {
     type Out;
 }
@@ -891,19 +883,16 @@ impl<T> ApplyL for RefMutL<T> {
 
 fn test<T: ApplyL>() {
     let y: <RefMutL<T> as ApplyL>::Out = no_matter;
-    y<|>;
-}
+    y;
+} //^ ApplyL::Out<T>
 "#,
     );
-    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
-    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
 fn associated_type_placeholder_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 pub trait ApplyL {
     type Out;
 }
@@ -911,11 +900,10 @@ fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
 
 fn test<T: ApplyL>(t: T) {
     let y = foo(t);
-    y<|>;
-}
+    y;
+} //^ ApplyL::Out<T>
 "#,
     );
-    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
@@ -944,34 +932,34 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
 }
 "#, true),
         @r###"
-    30..34 'self': &Self
-    55..59 'self': &Self
-    78..79 'x': impl Trait<u16>
-    98..100 '{}': ()
-    155..156 'x': impl Trait<u64>
-    175..176 'y': &impl Trait<u32>
-    196..324 '{     ...2(); }': ()
-    202..203 'x': impl Trait<u64>
-    209..210 'y': &impl Trait<u32>
-    220..221 'z': S<u16>
-    224..225 'S': S<u16>(u16) -> S<u16>
-    224..228 'S(1)': S<u16>
-    226..227 '1': u16
-    234..237 'bar': fn bar(S<u16>)
-    234..240 'bar(z)': ()
-    238..239 'z': S<u16>
-    246..247 'x': impl Trait<u64>
-    246..253 'x.foo()': u64
-    259..260 'y': &impl Trait<u32>
-    259..266 'y.foo()': u32
-    272..273 'z': S<u16>
-    272..279 'z.foo()': u16
-    285..286 'x': impl Trait<u64>
-    285..293 'x.foo2()': i64
-    299..300 'y': &impl Trait<u32>
-    299..307 'y.foo2()': i64
-    313..314 'z': S<u16>
-    313..321 'z.foo2()': i64
+    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
     "###
     );
 }
@@ -1005,39 +993,39 @@ fn test() {
 }
 "#, true),
         @r###"
-    156..157 'x': impl Trait
-    176..187 '{ loop {} }': T
-    178..185 'loop {}': !
-    183..185 '{}': ()
-    200..201 'x': impl Trait
-    220..231 '{ loop {} }': T
-    222..229 'loop {}': !
-    227..229 '{}': ()
-    301..510 '{     ... i32 }': ()
-    307..315 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
-    307..318 'Foo::bar(S)': {unknown}
-    316..317 'S': S
-    324..339 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    324..342 '<F as ...bar(S)': {unknown}
-    340..341 'S': S
-    348..354 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    348..357 'F::bar(S)': {unknown}
-    355..356 'S': S
-    363..378 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
-    363..381 'Foo::b...32>(S)': u32
-    379..380 'S': S
-    387..409 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
-    387..412 '<F as ...32>(S)': u32
-    410..411 'S': S
-    419..422 'foo': fn foo<{unknown}>(S) -> {unknown}
-    419..425 'foo(S)': {unknown}
-    423..424 'S': S
-    431..441 'foo::<u32>': fn foo<u32>(S) -> u32
-    431..444 'foo::<u32>(S)': u32
-    442..443 'S': S
-    450..465 'foo::<u32, i32>': fn foo<u32>(S) -> u32
-    450..468 'foo::<...32>(S)': u32
-    466..467 'S': S
+    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
     "###
     );
 }
@@ -1062,24 +1050,24 @@ fn test() {
 }
 "#, true),
         @r###"
-    88..92 'self': F<T>
-    94..95 'x': impl Trait
-    119..130 '{ loop {} }': (T, U)
-    121..128 'loop {}': !
-    126..128 '{}': ()
-    144..284 '{     ...ored }': ()
-    150..151 'F': F<{unknown}>
-    150..158 'F.foo(S)': ({unknown}, {unknown})
-    156..157 'S': S
-    164..172 'F::<u32>': F<u32>
-    164..179 'F::<u32>.foo(S)': (u32, {unknown})
-    177..178 'S': S
-    185..193 'F::<u32>': F<u32>
-    185..207 'F::<u3...32>(S)': (u32, i32)
-    205..206 'S': S
-    213..221 'F::<u32>': F<u32>
-    213..240 'F::<u3...32>(S)': (u32, i32)
-    238..239 'S': S
+    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
     "###
     );
 }
@@ -1098,19 +1086,18 @@ fn test() {
 }
 "#, true),
         @r###"
-    23..24 'x': impl Trait
-    38..49 '{ loop {} }': ()
-    40..47 'loop {}': !
-    45..47 '{}': ()
-    91..124 '{     ...foo; }': ()
-    101..102 'f': fn(S)
-    118..121 'foo': fn foo(S)
+    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]
-#[ignore]
 fn impl_trait() {
     assert_snapshot!(
         infer(r#"
@@ -1133,29 +1120,118 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
 }
 "#),
         @r###"
-    30..34 'self': &Self
-    55..59 'self': &Self
-    99..101 '{}': ()
-    111..112 'x': impl Trait<u64>
-    131..132 'y': &impl Trait<u64>
-    152..269 '{     ...2(); }': ()
-    158..159 'x': impl Trait<u64>
-    165..166 'y': &impl Trait<u64>
-    176..177 'z': impl Trait<u64>
-    180..183 'bar': fn bar() -> impl Trait<u64>
-    180..185 'bar()': impl Trait<u64>
-    191..192 'x': impl Trait<u64>
-    191..198 'x.foo()': u64
-    204..205 'y': &impl Trait<u64>
-    204..211 'y.foo()': u64
-    217..218 'z': impl Trait<u64>
-    217..224 'z.foo()': u64
-    230..231 'x': impl Trait<u64>
-    230..238 'x.foo2()': i64
-    244..245 'y': &impl Trait<u64>
-    244..252 'y.foo2()': i64
-    258..259 'z': impl Trait<u64>
-    258..266 'z.foo2()': i64
+    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 {} }
+
+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
+    "###
+    );
+}
+
+#[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
     "###
     );
 }
@@ -1183,29 +1259,29 @@ fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
 }
 "#),
         @r###"
-    30..34 'self': &Self
-    55..59 'self': &Self
-    98..100 '{}': ()
-    110..111 'x': dyn Trait<u64>
-    129..130 'y': &dyn Trait<u64>
-    149..266 '{     ...2(); }': ()
-    155..156 'x': dyn Trait<u64>
-    162..163 'y': &dyn Trait<u64>
-    173..174 'z': dyn Trait<u64>
-    177..180 'bar': fn bar() -> dyn Trait<u64>
-    177..182 'bar()': dyn Trait<u64>
-    188..189 'x': dyn Trait<u64>
-    188..195 'x.foo()': u64
-    201..202 'y': &dyn Trait<u64>
-    201..208 'y.foo()': u64
-    214..215 'z': dyn Trait<u64>
-    214..221 'z.foo()': u64
-    227..228 'x': dyn Trait<u64>
-    227..235 'x.foo2()': i64
-    241..242 'y': &dyn Trait<u64>
-    241..249 'y.foo2()': i64
-    255..256 'z': dyn Trait<u64>
-    255..263 'z.foo2()': i64
+    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
     "###
     );
 }
@@ -1231,17 +1307,17 @@ fn test(s: S<u32, i32>) {
 }
 "#),
         @r###"
-    33..37 'self': &Self
-    103..107 'self': &S<T, U>
-    129..140 '{ loop {} }': &dyn Trait<T, U>
-    131..138 'loop {}': !
-    136..138 '{}': ()
-    176..180 'self': &Self
-    252..253 's': S<u32, i32>
-    268..290 '{     ...z(); }': ()
-    274..275 's': S<u32, i32>
-    274..281 's.bar()': &dyn Trait<u32, i32>
-    274..287 's.bar().baz()': (u32, i32)
+    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)
     "###
     );
 }
@@ -1265,22 +1341,22 @@ fn test(x: Trait, y: &Trait) -> u64 {
 }
 "#),
         @r###"
-    27..31 'self': &Self
-    61..63 '{}': ()
-    73..74 'x': dyn Trait
-    83..84 'y': &dyn Trait
-    101..176 '{     ...o(); }': ()
-    107..108 'x': dyn Trait
-    114..115 'y': &dyn Trait
-    125..126 'z': dyn Trait
-    129..132 'bar': fn bar() -> dyn Trait
-    129..134 'bar()': dyn Trait
-    140..141 'x': dyn Trait
-    140..147 'x.foo()': u64
-    153..154 'y': &dyn Trait
-    153..160 'y.foo()': u64
-    166..167 'z': dyn Trait
-    166..173 'z.foo()': u64
+    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
     "###
     );
 }
@@ -1294,13 +1370,13 @@ fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl (
 }
 "#),
         @r###"
-    24..25 'a': impl Trait + {error}
-    51..52 'b': impl {error}
-    70..71 'c': impl Trait
-    87..88 'd': impl {error}
-    108..109 'e': impl {error}
-    124..125 'f': impl Trait + {error}
-    148..151 '{ }': ()
+    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 '{ }': ()
     "###
     );
 }
@@ -1308,19 +1384,17 @@ fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl (
 #[test]
 #[ignore]
 fn error_bound_chalk() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     fn foo(&self) -> u32 {}
 }
 
 fn test(x: (impl Trait + UnknownTrait)) {
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -1349,48 +1423,48 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
 }
 "#),
         @r###"
-    50..51 't': T
-    78..80 '{}': ()
-    112..113 't': T
-    123..125 '{}': ()
-    155..156 't': T
-    166..169 '{t}': T
-    167..168 't': T
-    257..258 'x': T
-    263..264 'y': impl Trait<Type = i64>
-    290..398 '{     ...r>); }': ()
-    296..299 'get': fn get<T>(T) -> <T as Trait>::Type
-    296..302 'get(x)': u32
-    300..301 'x': T
-    308..312 'get2': fn get2<u32, T>(T) -> u32
-    308..315 'get2(x)': u32
-    313..314 'x': T
-    321..324 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
-    321..327 'get(y)': i64
-    325..326 'y': impl Trait<Type = i64>
-    333..337 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
-    333..340 'get2(y)': i64
-    338..339 'y': impl Trait<Type = i64>
-    346..349 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
-    346..357 'get(set(S))': u64
-    350..353 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    350..356 'set(S)': S<u64>
-    354..355 'S': S<u64>
-    363..367 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    363..375 'get2(set(S))': u64
-    368..371 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    368..374 'set(S)': S<u64>
-    372..373 'S': S<u64>
-    381..385 'get2': fn get2<str, S<str>>(S<str>) -> str
-    381..395 'get2(S::<str>)': str
-    386..394 'S::<str>': S<str>
+    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>
     "###
     );
 }
 
 #[test]
 fn impl_trait_assoc_binding_projection_bug() {
-    let (db, pos) = TestDB::with_position(
+    check_types(
         r#"
 //- /main.rs crate:main deps:std
 pub trait Language {
@@ -1409,8 +1483,8 @@ trait Clone {
 
 fn api_walkthrough() {
     for node in foo() {
-        node.clone()<|>;
-    }
+        node.clone();
+    }            //^ {unknown}
 }
 
 //- /std.rs crate:std
@@ -1428,7 +1502,6 @@ mod iter {
 }
 "#,
     );
-    assert_eq!("{unknown}", type_at_pos(&db, pos));
 }
 
 #[test]
@@ -1448,20 +1521,19 @@ fn test<T: Trait1<Type = u32>>(x: T) {
 }
 "#),
         @r###"
-    62..66 'self': Self
-    164..165 'x': T
-    170..186 '{     ...o(); }': ()
-    176..177 'x': T
-    176..183 'x.foo()': u32
+    61..65 'self': Self
+    163..164 'x': T
+    169..185 '{     ...o(); }': ()
+    175..176 'x': T
+    175..182 'x.foo()': u32
     "###
     );
 }
 
 #[test]
 fn where_clause_trait_in_scope_for_method_resolution() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 mod foo {
     trait Trait {
         fn foo(&self) -> u32 {}
@@ -1469,11 +1541,10 @@ mod foo {
 }
 
 fn test<T: foo::Trait>(x: T) {
-    x.foo()<|>;
-}
+    x.foo();
+}      //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -1494,15 +1565,15 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
 }
 "#),
         @r###"
-    50..54 'self': &Self
-    63..65 '{}': ()
-    182..183 'x': T
-    188..189 'y': U
-    194..223 '{     ...o(); }': ()
-    200..201 'x': T
-    200..207 'x.foo()': u32
-    213..214 'y': U
-    213..220 'y.foo()': u32
+    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
     "###
     );
 }
@@ -1523,12 +1594,12 @@ fn test(x: &impl Trait1) {
 }
 "#),
         @r###"
-    50..54 'self': &Self
-    63..65 '{}': ()
-    116..117 'x': &impl Trait1
-    133..149 '{     ...o(); }': ()
-    139..140 'x': &impl Trait1
-    139..146 'x.foo()': u32
+    49..53 'self': &Self
+    62..64 '{}': ()
+    115..116 'x': &impl Trait1
+    132..148 '{     ...o(); }': ()
+    138..139 'x': &impl Trait1
+    138..145 'x.foo()': u32
     "###
     );
 }
@@ -1546,10 +1617,10 @@ fn test<T: A>(x: T) {
 }
 "#),
         @r###"
-    44..45 'x': T
-    50..66 '{     ...o(); }': ()
-    56..57 'x': T
-    56..63 'x.foo()': {unknown}
+    43..44 'x': T
+    49..65 '{     ...o(); }': ()
+    55..56 'x': T
+    55..62 'x.foo()': {unknown}
     "###
     );
 }
@@ -1573,17 +1644,17 @@ fn test() {
 }
 "#),
         @r###"
-    103..104 't': T
-    114..116 '{}': ()
-    146..147 't': T
-    157..160 '{t}': T
-    158..159 't': T
-    259..280 '{     ...S)); }': ()
-    265..269 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    265..277 'get2(set(S))': u64
-    270..273 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    270..276 'set(S)': S<u64>
-    274..275 'S': S<u64>
+    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>
     "###
     );
 }
@@ -1603,15 +1674,15 @@ fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
 }
 "#),
         @r###"
-    57..61 'self': Self
-    63..67 'args': Args
-    150..151 'f': F
-    156..184 '{     ...2)); }': ()
-    162..163 'f': F
-    162..181 'f.call...1, 2))': u128
-    174..180 '(1, 2)': (u32, u64)
-    175..176 '1': u32
-    178..179 '2': u64
+    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
     "###
     );
 }
@@ -1652,24 +1723,24 @@ fn test() {
 }
 "#),
         @r###"
-75..79 'self': Self
-81..85 'args': Args
-140..144 'self': &Self
-244..248 'self': &Bar<F>
-261..263 '{}': ()
-347..351 'self': Opt<T>
-353..354 'f': F
-369..371 '{}': ()
-385..501 '{     ...(f); }': ()
-395..398 'bar': Bar<fn(u8) -> u32>
-424..427 'bar': Bar<fn(u8) -> u32>
-424..433 'bar.foo()': {unknown}
-444..447 'opt': Opt<u8>
-466..467 'f': fn(u8) -> u32
-488..491 'opt': Opt<u8>
-488..498 'opt.map(f)': Opt<FnOnce::Output<fn(u8) -> u32, (u8,)>>
-496..497 'f': fn(u8) -> u32
-"###
+    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
+    "###
     );
 }
 
@@ -1718,33 +1789,33 @@ fn test() {
 }
 "#),
         @r###"
-65..69 'self': &Self
-166..170 'self': Self
-172..176 'args': Args
-240..244 'self': &Foo
-255..257 '{}': ()
-335..336 'f': F
-355..357 '{}': ()
-444..690 '{     ...o(); }': ()
-454..459 'lazy1': Lazy<Foo, fn() -> T>
-476..485 'Lazy::new': fn new<Foo, fn() -> T>(fn() -> T) -> Lazy<Foo, fn() -> T>
-476..493 'Lazy::...| Foo)': Lazy<Foo, fn() -> T>
-486..492 '|| Foo': || -> T
-489..492 'Foo': Foo
-503..505 'r1': {unknown}
-508..513 'lazy1': Lazy<Foo, fn() -> T>
-508..519 'lazy1.foo()': {unknown}
-561..576 'make_foo_fn_ptr': fn() -> Foo
-592..603 'make_foo_fn': fn make_foo_fn() -> Foo
-613..618 'lazy2': Lazy<Foo, fn() -> T>
-635..644 'Lazy::new': fn new<Foo, fn() -> T>(fn() -> T) -> Lazy<Foo, fn() -> T>
-635..661 'Lazy::...n_ptr)': Lazy<Foo, fn() -> T>
-645..660 'make_foo_fn_ptr': fn() -> Foo
-671..673 'r2': {unknown}
-676..681 'lazy2': Lazy<Foo, fn() -> T>
-676..687 'lazy2.foo()': {unknown}
-550..552 '{}': ()
-"###
+    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 '{}': ()
+    "###
     );
 }
 
@@ -1770,32 +1841,32 @@ fn test() {
 }
 "#),
         @r###"
-    148..152 'self': Option<T>
-    154..155 'f': F
-    173..175 '{}': ()
-    189..308 '{     ... 1); }': ()
-    199..200 'x': Option<u32>
-    203..215 'Option::Some': Some<u32>(u32) -> Option<u32>
-    203..221 'Option...(1u32)': Option<u32>
-    216..220 '1u32': u32
-    227..228 'x': Option<u32>
-    227..243 'x.map(...v + 1)': Option<u32>
-    233..242 '|v| v + 1': |u32| -> u32
-    234..235 'v': u32
-    237..238 'v': u32
-    237..242 'v + 1': u32
-    241..242 '1': u32
-    249..250 'x': Option<u32>
-    249..265 'x.map(... 1u64)': Option<u64>
-    255..264 '|_v| 1u64': |u32| -> u64
-    256..258 '_v': u32
-    260..264 '1u64': u64
-    275..276 'y': Option<i64>
-    292..293 'x': Option<u32>
-    292..305 'x.map(|_v| 1)': Option<i64>
-    298..304 '|_v| 1': |u32| -> i64
-    299..301 '_v': u32
-    303..304 '1': i64
+    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
     "###
     );
 }
@@ -1816,26 +1887,26 @@ fn test<F: FnOnce(u32) -> u64>(f: F) {
 }
 "#),
         @r###"
-    73..74 'f': F
-    79..155 '{     ...+ v; }': ()
-    85..86 'f': F
-    85..89 'f(1)': {unknown}
-    87..88 '1': i32
-    99..100 'g': |u64| -> i32
-    103..112 '|v| v + 1': |u64| -> i32
-    104..105 'v': u64
-    107..108 'v': u64
-    107..112 'v + 1': i32
-    111..112 '1': i32
-    118..119 'g': |u64| -> i32
-    118..125 'g(1u64)': i32
-    120..124 '1u64': u64
-    135..136 'h': |u128| -> u128
-    139..152 '|v| 1u128 + v': |u128| -> u128
-    140..141 'v': u128
-    143..148 '1u128': u128
-    143..152 '1u128 + v': u128
-    151..152 'v': u128
+    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
     "###
     );
 }
@@ -1868,61 +1939,83 @@ fn test() {
 }
 "#),
         @r###"
-    95..96 'x': T
-    101..102 'f': F
-    112..114 '{}': ()
-    148..149 'f': F
-    154..155 'x': T
-    165..167 '{}': ()
-    202..206 'self': S
-    254..258 'self': S
-    260..261 'x': T
-    266..267 'f': F
-    277..279 '{}': ()
-    317..321 'self': S
-    323..324 'f': F
-    329..330 'x': T
-    340..342 '{}': ()
-    356..515 '{     ... S); }': ()
-    366..368 'x1': u64
-    371..375 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
-    371..394 'foo1(S...hod())': u64
-    376..377 'S': S
-    379..393 '|s| s.method()': |S| -> u64
-    380..381 's': S
-    383..384 's': S
-    383..393 's.method()': u64
-    404..406 'x2': u64
-    409..413 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
-    409..432 'foo2(|...(), S)': u64
-    414..428 '|s| s.method()': |S| -> u64
-    415..416 's': S
-    418..419 's': S
-    418..428 's.method()': u64
-    430..431 'S': S
-    442..444 'x3': u64
-    447..448 'S': S
-    447..472 'S.foo1...hod())': u64
-    454..455 'S': S
-    457..471 '|s| s.method()': |S| -> u64
-    458..459 's': S
-    461..462 's': S
-    461..471 's.method()': u64
-    482..484 'x4': u64
-    487..488 'S': S
-    487..512 'S.foo2...(), S)': u64
-    494..508 '|s| s.method()': |S| -> u64
-    495..496 's': S
-    498..499 's': S
-    498..508 's.method()': u64
-    510..511 'S': S
+    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
     "###
     );
 }
 
 #[test]
+fn fn_item_fn_trait() {
+    check_types(
+        r#"
+#[lang = "fn_once"]
+trait FnOnce<Args> {
+    type Output;
+}
+
+struct S;
+
+fn foo() -> S {}
+
+fn takes_closure<U, F: FnOnce() -> U>(f: F) -> U { f() }
+
+fn test() {
+    takes_closure(foo);
+} //^^^^^^^^^^^^^^^^^^ S
+"#,
+    );
+}
+
+#[test]
 fn unselected_projection_in_trait_env_1() {
-    let t = type_at(
+    check_types(
         r#"
 //- /main.rs
 trait Trait {
@@ -1935,18 +2028,16 @@ trait Trait2 {
 
 fn test<T: Trait>() where T::Item: Trait2 {
     let x: T::Item = no_matter;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait<T> {
     type Item;
 }
@@ -1957,11 +2048,10 @@ trait Trait2 {
 
 fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
     let x: T::Item = no_matter;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -1990,26 +2080,25 @@ impl Trait for S2 {
 }
 "#,
     ), @r###"
-    54..58 'self': &Self
-    60..61 'x': Trait::Item<Self>
-    140..144 'self': &S
-    146..147 'x': u32
-    161..175 '{ let y = x; }': ()
-    167..168 'y': u32
-    171..172 'x': u32
-    242..246 'self': &S2
-    248..249 'x': i32
-    265..279 '{ let y = x; }': ()
-    271..272 'y': i32
-    275..276 'x': i32
+    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]
 fn unselected_projection_on_trait_self() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     type Item;
 
@@ -2022,18 +2111,16 @@ impl Trait for S {
 }
 
 fn test() {
-    S.f()<|>;
-}
+    S.f();
+}     //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn unselected_projection_chalk_fold() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Interner {}
 trait Fold<I: Interner, TI = I> {
     type Result;
@@ -2052,18 +2139,16 @@ where
 }
 
 fn foo<I: Interner>(interner: &I, t: Ty<I>) {
-    fold(interner, t)<|>;
-}
+    fold(interner, t);
+}     //^ Ty<I>
 "#,
     );
-    assert_eq!(t, "Ty<I>");
 }
 
 #[test]
 fn trait_impl_self_ty() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait<T> {
    fn foo(&self);
 }
@@ -2073,18 +2158,16 @@ struct S;
 impl Trait<Self> for S {}
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn trait_impl_self_ty_cycle() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
    fn foo(&self);
 }
@@ -2094,18 +2177,17 @@ struct S<T>;
 impl Trait for S<Self> {}
 
 fn test() {
-    S.foo()<|>;
-}
+    S.foo();
+}       //^ {unknown}
 "#,
     );
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_cycle_1() {
-    let t = type_at(
+    // this is a legitimate cycle
+    check_types(
         r#"
-//- /main.rs
 trait Trait {
     type Item;
 }
@@ -2113,17 +2195,16 @@ trait Trait {
 trait Trait2<T> {}
 
 fn test<T: Trait>() where T: Trait2<T::Item> {
-    let x: T::Item = no_matter<|>;
-}
+    let x: T::Item = no_matter;
+}                       //^ {unknown}
 "#,
     );
-    // this is a legitimate cycle
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn unselected_projection_in_trait_env_cycle_2() {
-    let t = type_at(
+    // this is a legitimate cycle
+    check_types(
         r#"
 //- /main.rs
 trait Trait<T> {
@@ -2131,19 +2212,16 @@ trait Trait<T> {
 }
 
 fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
-    let x: T::Item = no_matter<|>;
-}
+    let x: T::Item = no_matter;
+}                   //^ {unknown}
 "#,
     );
-    // this is a legitimate cycle
-    assert_eq!(t, "{unknown}");
 }
 
 #[test]
 fn inline_assoc_type_bounds_1() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Iterator {
     type Item;
 }
@@ -2159,29 +2237,26 @@ impl<T: Iterator> Iterator for S<T> {
 
 fn test<I: Iterator<Item: OtherTrait<u32>>>() {
     let x: <S<I> as Iterator>::Item;
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn inline_assoc_type_bounds_2() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 trait Iterator {
     type Item;
 }
 
 fn test<I: Iterator<Item: Iterator<Item = u32>>>() {
     let x: <<I as Iterator>::Item as Iterator>::Item;
-    x<|>;
-}
+    x;
+} //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
@@ -2241,15 +2316,15 @@ impl TokenStream for Rustc {
 }
 "#),
         @r###"
-    1062..1073 '{ loop {} }': T
-    1064..1071 'loop {}': !
-    1069..1071 '{}': ()
-    1137..1200 '{     ...     }': T
-    1151..1156 'group': G
-    1172..1176 'make': fn make<G>() -> G
-    1172..1178 'make()': G
-    1188..1192 'make': fn make<T>() -> T
-    1188..1194 'make()': T
+    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
     "###
     );
 }
@@ -2276,37 +2351,37 @@ fn test() -> impl Trait<i32> {
 }
 "#, true),
         @r###"
-    27..28 'x': impl Trait<u32>
-    47..58 '{ loop {} }': ()
-    49..56 'loop {}': !
-    54..56 '{}': ()
-    69..70 'x': impl Trait<T>
-    92..103 '{ loop {} }': T
-    94..101 'loop {}': !
-    99..101 '{}': ()
-    172..183 '{ loop {} }': T
-    174..181 'loop {}': !
-    179..181 '{}': ()
-    214..310 '{     ...t()) }': S<{unknown}>
-    224..226 's1': S<u32>
-    229..230 'S': S<u32>(u32) -> S<u32>
-    229..241 'S(default())': S<u32>
-    231..238 'default': fn default<u32>() -> u32
-    231..240 'default()': u32
-    247..250 'foo': fn foo(S<u32>)
-    247..254 'foo(s1)': ()
-    251..253 's1': S<u32>
-    264..265 'x': i32
-    273..276 'bar': fn bar<i32>(S<i32>) -> i32
-    273..290 'bar(S(...lt()))': i32
-    277..278 'S': S<i32>(i32) -> S<i32>
-    277..289 'S(default())': S<i32>
-    279..286 'default': fn default<i32>() -> i32
-    279..288 'default()': i32
-    296..297 'S': S<{unknown}>({unknown}) -> S<{unknown}>
-    296..308 'S(default())': S<{unknown}>
-    298..305 'default': fn default<{unknown}>() -> {unknown}
-    298..307 'default()': {unknown}
+    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}
     "###
     );
 }
@@ -2340,24 +2415,23 @@ fn main() {
 }
 "#),
         @r###"
-    147..149 '_v': F
-    192..195 '{ }': ()
-    207..238 '{     ... }); }': ()
-    213..223 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
-    213..235 'f::<()... z; })': ()
-    224..234 '|z| { z; }': |&()| -> ()
-    225..226 'z': &()
-    228..234 '{ z; }': ()
-    230..231 'z': &()
+    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': &()
     "###
     );
 }
 
 #[test]
 fn associated_type_bound() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 pub trait Trait {
     type Item: OtherTrait<u32>;
 }
@@ -2373,18 +2447,16 @@ impl<T: Trait> Trait for S<T> {
 
 fn test<T: Trait>() {
     let y: <S<T> as Trait>::Item = no_matter;
-    y.foo()<|>;
-}
+    y.foo();
+}       //^ u32
 "#,
     );
-    assert_eq!(t, "u32");
 }
 
 #[test]
 fn dyn_trait_through_chalk() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Box<T> {}
 #[lang = "deref"]
 trait Deref {
@@ -2398,18 +2470,16 @@ trait Trait {
 }
 
 fn test(x: Box<dyn Trait>) {
-    x.foo()<|>;
-}
+    x.foo();
+}       //^ ()
 "#,
     );
-    assert_eq!(t, "()");
 }
 
 #[test]
 fn string_to_owned() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct String {}
 pub trait ToOwned {
     type Owned;
@@ -2419,11 +2489,10 @@ impl ToOwned for str {
     type Owned = String;
 }
 fn test() {
-    "foo".to_owned()<|>;
-}
+    "foo".to_owned();
+}               //^ String
 "#,
     );
-    assert_eq!(t, "String");
 }
 
 #[test]
@@ -2501,55 +2570,54 @@ fn main() {
 }
 "#),
         @r###"
-    240..244 'self': Self
-    246..247 'f': F
-    331..342 '{ loop {} }': FilterMap<Self, F>
-    333..340 'loop {}': !
-    338..340 '{}': ()
-    363..367 'self': Self
-    369..370 'f': F
-    419..430 '{ loop {} }': ()
-    421..428 'loop {}': !
-    426..428 '{}': ()
-    539..543 'self': Self
-    868..872 'self': I
-    879..899 '{     ...     }': I
-    889..893 'self': I
-    958..969 '{ loop {} }': Vec<T>
-    960..967 'loop {}': !
-    965..967 '{}': ()
-    1156..1287 '{     ... }); }': ()
-    1162..1177 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
-    1162..1179 'Vec::<...:new()': Vec<i32>
-    1162..1191 'Vec::<...iter()': IntoIter<i32>
-    1162..1256 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
-    1162..1284 'Vec::<... y; })': ()
-    1210..1255 '|x| if...None }': |i32| -> Option<u32>
-    1211..1212 'x': i32
-    1214..1255 'if x >...None }': Option<u32>
-    1217..1218 'x': i32
-    1217..1222 'x > 0': bool
-    1221..1222 '0': i32
-    1223..1241 '{ Some...u32) }': Option<u32>
-    1225..1229 'Some': Some<u32>(u32) -> Option<u32>
-    1225..1239 'Some(x as u32)': Option<u32>
-    1230..1231 'x': i32
-    1230..1238 'x as u32': u32
-    1247..1255 '{ None }': Option<u32>
-    1249..1253 'None': Option<u32>
-    1273..1283 '|y| { y; }': |u32| -> ()
-    1274..1275 'y': u32
-    1277..1283 '{ y; }': ()
-    1279..1280 'y': u32
+    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
     "###
     );
 }
 
 #[test]
 fn nested_assoc() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs
 struct Bar;
 struct Foo;
 
@@ -2572,11 +2640,10 @@ impl<T:A> B for T {
 }
 
 fn main() {
-    Bar::foo()<|>;
-}
+    Bar::foo();
+}          //^ Foo
 "#,
     );
-    assert_eq!(t, "Foo");
 }
 
 #[test]
@@ -2592,13 +2659,13 @@ fn test(x: &dyn Foo) {
 }
 "#, true),
         @r###"
-    22..23 'x': &dyn Foo
-    35..37 '{}': ()
-    47..48 'x': &dyn Foo
-    60..75 '{     foo(x); }': ()
-    66..69 'foo': fn foo(&dyn Foo)
-    66..72 'foo(x)': ()
-    70..71 'x': &dyn Foo
+    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
     "###
     );
 }
@@ -2625,20 +2692,20 @@ fn test() {
 }
 "#, true),
         @r###"
-    111..115 'self': &Self
-    167..268 '{     ...t(); }': ()
-    173..179 'IsCopy': IsCopy
-    173..186 'IsCopy.test()': bool
-    192..199 'NotCopy': NotCopy
-    192..206 'NotCopy.test()': {unknown}
-    212..228 '(IsCop...sCopy)': (IsCopy, IsCopy)
-    212..235 '(IsCop...test()': bool
-    213..219 'IsCopy': IsCopy
-    221..227 'IsCopy': IsCopy
-    241..258 '(IsCop...tCopy)': (IsCopy, NotCopy)
-    241..265 '(IsCop...test()': {unknown}
-    242..248 'IsCopy': IsCopy
-    250..257 'NotCopy': NotCopy
+    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
     "###
     );
 }
@@ -2666,20 +2733,20 @@ fn test() {
 }
 "#, true),
         @r###"
-    42..44 '{}': ()
-    61..62 'T': {unknown}
-    69..71 '{}': ()
-    69..71: expected T, got ()
-    146..150 'self': &Self
-    202..282 '{     ...t(); }': ()
-    208..211 'foo': fn foo()
-    208..218 'foo.test()': bool
-    224..227 'bar': fn bar<{unknown}>({unknown}) -> {unknown}
-    224..234 'bar.test()': bool
-    240..246 'Struct': Struct(usize) -> Struct
-    240..253 'Struct.test()': bool
-    259..272 'Enum::Variant': Variant(usize) -> Enum
-    259..279 'Enum::...test()': bool
+    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
     "###
     );
 }
@@ -2701,17 +2768,17 @@ fn test(f1: fn(), f2: fn(usize) -> u8, f3: fn(u8, u8) -> &u8) {
 }
 "#, true),
         @r###"
-    55..59 'self': &Self
-    109..111 'f1': fn()
-    119..121 'f2': fn(usize) -> u8
-    140..142 'f3': fn(u8, u8) -> &u8
-    163..211 '{     ...t(); }': ()
-    169..171 'f1': fn()
-    169..178 'f1.test()': bool
-    184..186 'f2': fn(usize) -> u8
-    184..193 'f2.test()': bool
-    199..201 'f3': fn(u8, u8) -> &u8
-    199..208 'f3.test()': bool
+    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
     "###
     );
 }
@@ -2734,36 +2801,36 @@ fn test() {
 }
 "#, true),
         @r###"
-    57..61 'self': &Self
-    114..229 '{     ...ized }': ()
-    120..123 '1u8': u8
-    120..130 '1u8.test()': bool
-    136..151 '(*"foo").test()': {unknown}
-    137..143 '*"foo"': str
-    138..143 '"foo"': &str
-    170..180 '(1u8, 1u8)': (u8, u8)
-    170..187 '(1u8, ...test()': bool
-    171..174 '1u8': u8
-    176..179 '1u8': u8
-    193..206 '(1u8, *"foo")': (u8, str)
-    193..213 '(1u8, ...test()': {unknown}
-    194..197 '1u8': u8
-    199..205 '*"foo"': str
-    200..205 '"foo"': &str
+    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
     "###
     );
 }
 
 #[test]
 fn integer_range_iterate() {
-    let t = type_at(
+    check_types(
         r#"
-//- /main.rs crate:main deps:std
+//- /main.rs crate:main deps:core
 fn test() {
-    for x in 0..100 { x<|>; }
-}
+    for x in 0..100 { x; }
+}                   //^ i32
 
-//- /std.rs crate:std
+//- /core.rs crate:core
 pub mod ops {
     pub struct Range<Idx> {
         pub start: Idx,
@@ -2796,5 +2863,235 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
 }
 "#,
     );
-    assert_eq!(t, "i32");
+}
+
+#[test]
+fn infer_closure_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            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>
+    "###
+    );
+}
+
+#[test]
+fn infer_fn_trait_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type 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;
+            }
+
+            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>
+    "###
+    );
+}
+
+#[test]
+fn infer_box_fn_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+
+                fn deref(&self) -> &Self::Target;
+            }
+
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+
+            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>
+    "###
+    );
+}
+
+#[test]
+fn infer_dyn_fn_output() {
+    check_types(
+        r#"
+#[lang = "fn_once"]
+pub trait FnOnce<Args> {
+    type 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;
+}
+
+fn foo() {
+    let f: &dyn Fn() -> i32;
+    f();
+  //^^^ i32
+}"#,
+    );
+}
+
+#[test]
+fn infer_dyn_fn_once_output() {
+    check_types(
+        r#"
+#[lang = "fn_once"]
+pub trait FnOnce<Args> {
+    type Output;
+    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+}
+
+fn foo() {
+    let f: dyn FnOnce() -> i32;
+    f();
+  //^^^ i32
+}"#,
+    );
+}
+
+#[test]
+fn variable_kinds_1() {
+    check_types(
+        r#"
+trait Trait<T> { fn get(self, t: T) -> T; }
+struct S;
+impl Trait<u128> for S {}
+impl Trait<f32> for S {}
+fn test() {
+    S.get(1);
+  //^^^^^^^^ u128
+    S.get(1.);
+  //^^^^^^^^ f32
+}
+        "#,
+    );
+}
+
+#[test]
+fn variable_kinds_2() {
+    check_types(
+        r#"
+trait Trait { fn get(self) -> Self; }
+impl Trait for u128 {}
+impl Trait for f32 {}
+fn test() {
+    1.get();
+  //^^^^^^^ u128
+    (1.).get();
+  //^^^^^^^^^^ f32
+}
+        "#,
+    );
 }