7 files changed, 335 insertions, 116 deletions

diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 76a1b46c0..fc5ef36a5 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -75,7 +75,7 @@ fn test2() {
     [124; 131) 'loop {}': !
     [129; 131) '{}': ()
     [160; 173) '{     gen() }': *mut [U]
-    [166; 169) 'gen': fn gen<U>() -> *mut [T; _]
+    [166; 169) 'gen': fn gen<U>() -> *mut [U; _]
     [166; 171) 'gen()': *mut [U; _]
     [186; 420) '{     ...rr); }': ()
     [196; 199) 'arr': &[u8; _]
@@ -85,14 +85,14 @@ fn test2() {
     [227; 228) 'a': &[u8]
     [237; 240) 'arr': &[u8; _]
     [250; 251) 'b': u8
-    [254; 255) 'f': fn f<u8>(&[T]) -> T
+    [254; 255) 'f': fn f<u8>(&[u8]) -> u8
     [254; 260) 'f(arr)': u8
     [256; 259) 'arr': &[u8; _]
     [270; 271) 'c': &[u8]
     [280; 287) '{ arr }': &[u8]
     [282; 285) 'arr': &[u8; _]
     [297; 298) 'd': u8
-    [301; 302) 'g': fn g<u8>(S<&[T]>) -> T
+    [301; 302) 'g': fn g<u8>(S<&[u8]>) -> u8
     [301; 316) 'g(S { a: arr })': u8
     [303; 315) 'S { a: arr }': S<&[u8]>
     [310; 313) 'arr': &[u8; _]
@@ -164,15 +164,15 @@ fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
     [400; 401) 'c': C<[u8; _]>
     [415; 481) '{     ...(c); }': ()
     [425; 426) 'd': A<[{unknown}]>
-    [429; 433) 'foo1': fn foo1<{unknown}>(A<[T]>) -> A<[T]>
+    [429; 433) 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
     [429; 436) 'foo1(a)': A<[{unknown}]>
     [434; 435) 'a': A<[u8; _]>
     [446; 447) 'e': B<[u8]>
-    [450; 454) 'foo2': fn foo2<u8>(B<[T]>) -> B<[T]>
+    [450; 454) 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
     [450; 457) 'foo2(b)': B<[u8]>
     [455; 456) 'b': B<[u8; _]>
     [467; 468) 'f': C<[u8]>
-    [471; 475) 'foo3': fn foo3<u8>(C<[T]>) -> C<[T]>
+    [471; 475) 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
     [471; 478) 'foo3(c)': C<[u8]>
     [476; 477) 'c': C<[u8; _]>
     "###
@@ -202,7 +202,7 @@ fn test() {
     [64; 123) 'if tru...     }': &[i32]
     [67; 71) 'true': bool
     [72; 97) '{     ...     }': &[i32]
-    [82; 85) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [82; 85) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [82; 91) 'foo(&[1])': &[i32]
     [86; 90) '&[1]': &[i32; _]
     [87; 90) '[1]': [i32; _]
@@ -242,7 +242,7 @@ fn test() {
     [83; 86) '[1]': [i32; _]
     [84; 85) '1': i32
     [98; 123) '{     ...     }': &[i32]
-    [108; 111) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [108; 111) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [108; 117) 'foo(&[1])': &[i32]
     [112; 116) '&[1]': &[i32; _]
     [113; 116) '[1]': [i32; _]
@@ -275,7 +275,7 @@ fn test(i: i32) {
     [70; 147) 'match ...     }': &[i32]
     [76; 77) 'i': i32
     [88; 89) '2': i32
-    [93; 96) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [93; 102) 'foo(&[2])': &[i32]
     [97; 101) '&[2]': &[i32; _]
     [98; 101) '[2]': [i32; _]
@@ -320,7 +320,7 @@ fn test(i: i32) {
     [94; 97) '[1]': [i32; _]
     [95; 96) '1': i32
     [107; 108) '2': i32
-    [112; 115) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
     [112; 121) 'foo(&[2])': &[i32]
     [116; 120) '&[2]': &[i32; _]
     [117; 120) '[2]': [i32; _]
@@ -438,16 +438,16 @@ fn test() {
     [43; 45) '*x': T
     [44; 45) 'x': &T
     [58; 127) '{     ...oo); }': ()
-    [64; 73) 'takes_ref': fn takes_ref<Foo>(&T) -> T
+    [64; 73) 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
     [64; 79) 'takes_ref(&Foo)': Foo
     [74; 78) '&Foo': &Foo
     [75; 78) 'Foo': Foo
-    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&T) -> T
+    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
     [85; 101) 'takes_...&&Foo)': &Foo
     [95; 100) '&&Foo': &&Foo
     [96; 100) '&Foo': &Foo
     [97; 100) 'Foo': Foo
-    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&T) -> T
+    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
     [107; 124) 'takes_...&&Foo)': &&Foo
     [117; 123) '&&&Foo': &&&Foo
     [118; 123) '&&Foo': &&Foo
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index ce9a06fde..1722563aa 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -27,7 +27,7 @@ fn test() {
     [66; 73) 'loop {}': !
     [71; 73) '{}': ()
     [133; 160) '{     ...o"); }': ()
-    [139; 149) '<[_]>::foo': fn foo<u8>(&[T]) -> T
+    [139; 149) '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
     [139; 157) '<[_]>:..."foo")': u8
     [150; 156) 'b"foo"': &[u8]
     "###
@@ -175,7 +175,7 @@ fn test() {
     [98; 101) 'val': T
     [123; 155) '{     ...32); }': ()
     [133; 134) 'a': Gen<u32>
-    [137; 146) 'Gen::make': fn make<u32>(T) -> Gen<T>
+    [137; 146) 'Gen::make': fn make<u32>(u32) -> Gen<u32>
     [137; 152) 'Gen::make(0u32)': Gen<u32>
     [147; 151) '0u32': u32
     "###
@@ -206,7 +206,7 @@ fn test() {
     [95; 98) '{ }': ()
     [118; 146) '{     ...e(); }': ()
     [128; 129) 'a': Gen<u32>
-    [132; 141) 'Gen::make': fn make<u32>() -> Gen<T>
+    [132; 141) 'Gen::make': fn make<u32>() -> Gen<u32>
     [132; 143) 'Gen::make()': Gen<u32>
     "###
     );
@@ -260,7 +260,7 @@ fn test() {
     [91; 94) '{ }': ()
     [114; 149) '{     ...e(); }': ()
     [124; 125) 'a': Gen<u32>
-    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<T>
+    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<u32>
     [128; 146) 'Gen::<...make()': Gen<u32>
     "###
     );
@@ -291,7 +291,7 @@ fn test() {
     [117; 120) '{ }': ()
     [140; 180) '{     ...e(); }': ()
     [150; 151) 'a': Gen<u32, u64>
-    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, T>
+    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
     [154; 177) 'Gen::<...make()': Gen<u32, u64>
     "###
     );
@@ -475,7 +475,7 @@ fn test() {
         @r###"
     [33; 37) 'self': &Self
     [102; 127) '{     ...d(); }': ()
-    [108; 109) 'S': S<u32>(T) -> S<T>
+    [108; 109) 'S': S<u32>(u32) -> S<u32>
     [108; 115) 'S(1u32)': S<u32>
     [108; 124) 'S(1u32...thod()': u32
     [110; 114) '1u32': u32
@@ -501,13 +501,13 @@ fn test() {
         @r###"
     [87; 193) '{     ...t(); }': ()
     [97; 99) 's1': S
-    [105; 121) 'Defaul...efault': fn default<S>() -> Self
+    [105; 121) 'Defaul...efault': fn default<S>() -> S
     [105; 123) 'Defaul...ault()': S
     [133; 135) 's2': S
-    [138; 148) 'S::default': fn default<S>() -> Self
+    [138; 148) 'S::default': fn default<S>() -> S
     [138; 150) 'S::default()': S
     [160; 162) 's3': S
-    [165; 188) '<S as ...efault': fn default<S>() -> Self
+    [165; 188) '<S as ...efault': fn default<S>() -> S
     [165; 190) '<S as ...ault()': S
     "###
     );
@@ -533,13 +533,13 @@ fn test() {
         @r###"
     [127; 211) '{     ...e(); }': ()
     [137; 138) 'a': u32
-    [141; 148) 'S::make': fn make<S, u32>() -> T
+    [141; 148) 'S::make': fn make<S, u32>() -> u32
     [141; 150) 'S::make()': u32
     [160; 161) 'b': u64
-    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> T
+    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
     [164; 180) 'G::<u6...make()': u64
     [190; 191) 'c': f64
-    [199; 206) 'G::make': fn make<G<f64>, f64>() -> T
+    [199; 206) 'G::make': fn make<G<f64>, f64>() -> f64
     [199; 208) 'G::make()': f64
     "###
     );
@@ -567,19 +567,19 @@ fn test() {
         @r###"
     [135; 313) '{     ...e(); }': ()
     [145; 146) 'a': (u32, i64)
-    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (T, U)
+    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
     [149; 165) 'S::mak...i64>()': (u32, i64)
     [175; 176) 'b': (u32, i64)
-    [189; 196) 'S::make': fn make<S, u32, i64>() -> (T, U)
+    [189; 196) 'S::make': fn make<S, u32, i64>() -> (u32, i64)
     [189; 198) 'S::make()': (u32, i64)
     [208; 209) 'c': (u32, i64)
-    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [212; 235) 'G::<u3...i64>()': (u32, i64)
     [245; 246) 'd': (u32, i64)
-    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (T, U)
+    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [259; 275) 'G::mak...i64>()': (u32, i64)
     [285; 286) 'e': (u32, i64)
-    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (T, U)
+    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
     [301; 310) 'G::make()': (u32, i64)
     "###
     );
@@ -601,7 +601,7 @@ fn test() {
         @r###"
     [101; 127) '{     ...e(); }': ()
     [111; 112) 'a': (S<i32>, i64)
-    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (Self, T)
+    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
     [115; 124) 'S::make()': (S<i32>, i64)
     "###
     );
@@ -625,10 +625,10 @@ fn test() {
         @r###"
     [131; 203) '{     ...e(); }': ()
     [141; 142) 'a': (S<u64>, i64)
-    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (Self, T)
+    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
     [158; 167) 'S::make()': (S<u64>, i64)
     [177; 178) 'b': (S<u32>, i32)
-    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (Self, T)
+    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
     [191; 200) 'S::make()': (S<u32>, i32)
     "###
     );
@@ -651,10 +651,10 @@ fn test() {
         @r###"
     [107; 211) '{     ...>(); }': ()
     [117; 118) 'a': (S<u64>, i64, u8)
-    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
     [121; 152) '<S as ...<u8>()': (S<u64>, i64, u8)
     [162; 163) 'b': (S<u64>, i64, u8)
-    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (Self, T, U)
+    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
     [182; 208) 'Trait:...<u8>()': (S<u64>, i64, u8)
     "###
     );
@@ -697,7 +697,7 @@ fn test<U, T: Trait<U>>(t: T) {
     [71; 72) 't': T
     [77; 96) '{     ...d(); }': ()
     [83; 84) 't': T
-    [83; 93) 't.method()': [missing name]
+    [83; 93) 't.method()': U
     "###
     );
 }
@@ -728,7 +728,7 @@ fn test() {
     [157; 158) 'S': S
     [157; 165) 'S.into()': u64
     [175; 176) 'z': u64
-    [179; 196) 'Into::...::into': fn into<S, u64>(Self) -> T
+    [179; 196) 'Into::...::into': fn into<S, u64>(S) -> u64
     [179; 199) 'Into::...nto(S)': u64
     [197; 198) 'S': S
     "###
diff --git a/crates/ra_hir_ty/src/tests/never_type.rs b/crates/ra_hir_ty/src/tests/never_type.rs
index c202f545a..a77209480 100644
--- a/crates/ra_hir_ty/src/tests/never_type.rs
+++ b/crates/ra_hir_ty/src/tests/never_type.rs
@@ -101,6 +101,7 @@ fn test() {
     );
     assert_eq!(t, "Option<i32>");
 }
+
 #[test]
 fn never_type_can_be_reinferred3() {
     let t = type_at(
@@ -138,6 +139,22 @@ fn test(a: Void) {
 }
 
 #[test]
+fn match_unknown_arm() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: Option) {
+    let t = match 0 {
+        _ => unknown,
+    };
+    t<|>;
+}
+"#,
+    );
+    assert_eq!(t, "{unknown}");
+}
+
+#[test]
 fn if_never() {
     let t = type_at(
         r#"
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index cb3890b42..e25d6dbc4 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -96,13 +96,13 @@ fn test() {
     [38; 42) 'A(n)': A<i32>
     [40; 41) 'n': &i32
     [45; 50) '&A(1)': &A<i32>
-    [46; 47) 'A': A<i32>(T) -> A<T>
+    [46; 47) 'A': A<i32>(i32) -> A<i32>
     [46; 50) 'A(1)': A<i32>
     [48; 49) '1': i32
     [60; 64) 'A(n)': A<i32>
     [62; 63) 'n': &mut i32
     [67; 76) '&mut A(1)': &mut A<i32>
-    [72; 73) 'A': A<i32>(T) -> A<T>
+    [72; 73) 'A': A<i32>(i32) -> A<i32>
     [72; 76) 'A(1)': A<i32>
     [74; 75) '1': i32
     "###
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 02bab6dbe..14c8ed3a9 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -346,7 +346,7 @@ pub fn main_loop() {
     @r###"
     [144; 146) '{}': ()
     [169; 198) '{     ...t(); }': ()
-    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<T, H>
+    [175; 193) 'FxHash...efault': fn default<{unknown}, FxHasher>() -> HashSet<{unknown}, FxHasher>
     [175; 195) 'FxHash...ault()': HashSet<{unknown}, FxHasher>
     "###
     );
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index fdab9c187..3803f5938 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -754,15 +754,15 @@ fn test() {
     [289; 295) 'self.0': T
     [315; 353) '{     ...))); }': ()
     [325; 326) 't': &i32
-    [329; 335) 'A::foo': fn foo<i32>(&A<T>) -> &T
+    [329; 335) 'A::foo': fn foo<i32>(&A<i32>) -> &i32
     [329; 350) 'A::foo...42))))': &i32
     [336; 349) '&&B(B(A(42)))': &&B<B<A<i32>>>
     [337; 349) '&B(B(A(42)))': &B<B<A<i32>>>
-    [338; 339) 'B': B<B<A<i32>>>(T) -> B<T>
+    [338; 339) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
     [338; 349) 'B(B(A(42)))': B<B<A<i32>>>
-    [340; 341) 'B': B<A<i32>>(T) -> B<T>
+    [340; 341) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
     [340; 348) 'B(A(42))': B<A<i32>>
-    [342; 343) 'A': A<i32>(T) -> A<T>
+    [342; 343) 'A': A<i32>(i32) -> A<i32>
     [342; 347) 'A(42)': A<i32>
     [344; 346) '42': i32
     "###
@@ -817,16 +817,16 @@ fn test(a: A<i32>) {
     [326; 327) 'a': A<i32>
     [337; 383) '{     ...))); }': ()
     [347; 348) 't': &i32
-    [351; 352) 'A': A<i32>(*mut T) -> A<T>
+    [351; 352) 'A': A<i32>(*mut i32) -> A<i32>
     [351; 365) 'A(0 as *mut _)': A<i32>
     [351; 380) 'A(0 as...B(a)))': &i32
     [353; 354) '0': i32
     [353; 364) '0 as *mut _': *mut i32
     [370; 379) '&&B(B(a))': &&B<B<A<i32>>>
     [371; 379) '&B(B(a))': &B<B<A<i32>>>
-    [372; 373) 'B': B<B<A<i32>>>(T) -> B<T>
+    [372; 373) 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
     [372; 379) 'B(B(a))': B<B<A<i32>>>
-    [374; 375) 'B': B<A<i32>>(T) -> B<T>
+    [374; 375) 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
     [374; 378) 'B(a)': B<A<i32>>
     [376; 377) 'a': A<i32>
     "###
@@ -1169,16 +1169,16 @@ fn test() {
 "#),
         @r###"
     [76; 184) '{     ...one; }': ()
-    [82; 83) 'A': A<i32>(T) -> A<T>
+    [82; 83) 'A': A<i32>(i32) -> A<i32>
     [82; 87) 'A(42)': A<i32>
     [84; 86) '42': i32
-    [93; 94) 'A': A<u128>(T) -> A<T>
+    [93; 94) 'A': A<u128>(u128) -> A<u128>
     [93; 102) 'A(42u128)': A<u128>
     [95; 101) '42u128': u128
-    [108; 112) 'Some': Some<&str>(T) -> Option<T>
+    [108; 112) 'Some': Some<&str>(&str) -> Option<&str>
     [108; 117) 'Some("x")': Option<&str>
     [113; 116) '"x"': &str
-    [123; 135) 'Option::Some': Some<&str>(T) -> Option<T>
+    [123; 135) 'Option::Some': Some<&str>(&str) -> Option<&str>
     [123; 140) 'Option...e("x")': Option<&str>
     [136; 139) '"x"': &str
     [146; 150) 'None': Option<{unknown}>
@@ -1205,14 +1205,14 @@ fn test() {
     [21; 26) '{ t }': T
     [23; 24) 't': T
     [38; 98) '{     ...(1); }': ()
-    [44; 46) 'id': fn id<u32>(T) -> T
+    [44; 46) 'id': fn id<u32>(u32) -> u32
     [44; 52) 'id(1u32)': u32
     [47; 51) '1u32': u32
-    [58; 68) 'id::<i128>': fn id<i128>(T) -> T
+    [58; 68) 'id::<i128>': fn id<i128>(i128) -> i128
     [58; 71) 'id::<i128>(1)': i128
     [69; 70) '1': i128
     [81; 82) 'x': u64
-    [90; 92) 'id': fn id<u64>(T) -> T
+    [90; 92) 'id': fn id<u64>(u64) -> u64
     [90; 95) 'id(1)': u64
     [93; 94) '1': u64
     "###
@@ -1220,7 +1220,7 @@ fn test() {
 }
 
 #[test]
-fn infer_impl_generics() {
+fn infer_impl_generics_basic() {
     assert_snapshot!(
         infer(r#"
 struct A<T1, T2> {
@@ -1349,16 +1349,16 @@ fn test() -> i128 {
     [146; 147) 'x': i128
     [150; 151) '1': i128
     [162; 163) 'y': i128
-    [166; 168) 'id': fn id<i128>(T) -> T
+    [166; 168) 'id': fn id<i128>(i128) -> i128
     [166; 171) 'id(x)': i128
     [169; 170) 'x': i128
     [182; 183) 'a': A<i128>
     [186; 200) 'A { x: id(y) }': A<i128>
-    [193; 195) 'id': fn id<i128>(T) -> T
+    [193; 195) 'id': fn id<i128>(i128) -> i128
     [193; 198) 'id(y)': i128
     [196; 197) 'y': i128
     [211; 212) 'z': i128
-    [215; 217) 'id': fn id<i128>(T) -> T
+    [215; 217) 'id': fn id<i128>(i128) -> i128
     [215; 222) 'id(a.x)': i128
     [218; 219) 'a': A<i128>
     [218; 221) 'a.x': i128
@@ -1502,14 +1502,14 @@ fn test() {
     [78; 158) '{     ...(1); }': ()
     [88; 89) 'y': u32
     [92; 97) '10u32': u32
-    [103; 105) 'id': fn id<u32>(T) -> T
+    [103; 105) 'id': fn id<u32>(u32) -> u32
     [103; 108) 'id(y)': u32
     [106; 107) 'y': u32
     [118; 119) 'x': bool
-    [128; 133) 'clone': fn clone<bool>(&T) -> T
+    [128; 133) 'clone': fn clone<bool>(&bool) -> bool
     [128; 136) 'clone(z)': bool
     [134; 135) 'z': &bool
-    [142; 152) 'id::<i128>': fn id<i128>(T) -> T
+    [142; 152) 'id::<i128>': fn id<i128>(i128) -> i128
     [142; 155) 'id::<i128>(1)': i128
     [153; 154) '1': i128
     "###
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index a6ac18f86..17611ddbf 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,7 +1,6 @@
 use insta::assert_snapshot;
 
 use ra_db::fixture::WithFixture;
-use test_utils::covers;
 
 use super::{infer, infer_with_mismatches, type_at, type_at_pos};
 use crate::test_db::TestDB;
@@ -261,10 +260,10 @@ fn test() {
     [92; 94) '{}': ()
     [105; 144) '{     ...(s); }': ()
     [115; 116) 's': S<u32>
-    [119; 120) 'S': S<u32>(T) -> S<T>
+    [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>>(T) -> ()
+    [135; 138) 'foo': fn foo<S<u32>>(S<u32>) -> ()
     [135; 141) 'foo(s)': ()
     [139; 140) 's': S<u32>
     "###
@@ -289,11 +288,11 @@ fn test() {
     [98; 100) '{}': ()
     [111; 163) '{     ...(s); }': ()
     [121; 122) 's': S<u32>
-    [125; 126) 'S': S<u32>(T) -> S<T>
+    [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>>(T) -> U
+    [154; 157) 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
     [154; 160) 'foo(s)': u32
     [158; 159) 's': S<u32>
     "###
@@ -358,15 +357,15 @@ fn test() {
     [221; 223) '{}': ()
     [234; 300) '{     ...(S); }': ()
     [244; 245) 'x': u32
-    [248; 252) 'foo1': fn foo1<S>(T) -> <T as Iterable>::Item
+    [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>(T) -> <T as Iterable>::Item
+    [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>(T) -> <T as Iterable>::Item
+    [290; 294) 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
     [290; 297) 'foo3(S)': u32
     [295; 296) 'S': S
     "###
@@ -822,8 +821,7 @@ fn test<T: ApplyL>() {
 "#,
     );
     // 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].
-    // FIXME: fix type parameter names going missing when going through Chalk
-    assert_eq!(t, "ApplyL::Out<[missing name]>");
+    assert_eq!(t, "ApplyL::Out<T>");
 }
 
 #[test]
@@ -850,6 +848,197 @@ fn test<T: ApplyL>(t: T) {
 }
 
 #[test]
+fn argument_impl_trait() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait<T> {
+    fn foo(&self) -> T;
+    fn foo2(&self) -> i64;
+}
+fn bar(x: impl Trait<u16>) {}
+struct S<T>(T);
+impl<T> Trait<T> for S<T> {}
+
+fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
+    x;
+    y;
+    let z = S(1);
+    bar(z);
+    x.foo();
+    y.foo();
+    z.foo();
+    x.foo2();
+    y.foo2();
+    z.foo2();
+}
+"#, true),
+        @r###"
+    [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
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_type_args_1() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+trait Foo {
+    // this function has an implicit Self param, an explicit type param,
+    // and an implicit impl Trait param!
+    fn bar<T>(x: impl Trait) -> T { loop {} }
+}
+fn foo<T>(x: impl Trait) -> T { loop {} }
+struct S;
+impl Trait for S {}
+struct F;
+impl Foo for F {}
+
+fn test() {
+    Foo::bar(S);
+    <F as Foo>::bar(S);
+    F::bar(S);
+    Foo::bar::<u32>(S);
+    <F as Foo>::bar::<u32>(S);
+
+    foo(S);
+    foo::<u32>(S);
+    foo::<u32, i32>(S); // we should ignore the extraneous i32
+}
+"#, true),
+        @r###"
+    [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
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_type_args_2() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+struct S;
+impl Trait for S {}
+struct F<T>;
+impl<T> F<T> {
+    fn foo<U>(self, x: impl Trait) -> (T, U) { loop {} }
+}
+
+fn test() {
+    F.foo(S);
+    F::<u32>.foo(S);
+    F::<u32>.foo::<i32>(S);
+    F::<u32>.foo::<i32, u32>(S); // extraneous argument should be ignored
+}
+"#, true),
+        @r###"
+    [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
+    "###
+    );
+}
+
+#[test]
+fn argument_impl_trait_to_fn_pointer() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait {}
+fn foo(x: impl Trait) { loop {} }
+struct S;
+impl Trait for S {}
+
+fn test() {
+    let f: fn(S) -> () = foo;
+}
+"#, 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) -> ()
+    "###
+    );
+}
+
+#[test]
 #[ignore]
 fn impl_trait() {
     assert_snapshot!(
@@ -994,29 +1183,17 @@ fn weird_bounds() {
     assert_snapshot!(
         infer(r#"
 trait Trait {}
-fn test() {
-    let a: impl Trait + 'lifetime = foo;
-    let b: impl 'lifetime = foo;
-    let b: impl (Trait) = foo;
-    let b: impl ('lifetime) = foo;
-    let d: impl ?Sized = foo;
-    let e: impl Trait + ?Sized = foo;
+fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl ('lifetime), e: impl ?Sized, f: impl Trait + ?Sized) {
 }
 "#),
         @r###"
-    [26; 237) '{     ...foo; }': ()
-    [36; 37) 'a': impl Trait + {error}
-    [64; 67) 'foo': impl Trait + {error}
-    [77; 78) 'b': impl {error}
-    [97; 100) 'foo': impl {error}
-    [110; 111) 'b': impl Trait
-    [128; 131) 'foo': impl Trait
-    [141; 142) 'b': impl {error}
-    [163; 166) 'foo': impl {error}
-    [176; 177) 'd': impl {error}
-    [193; 196) 'foo': impl {error}
-    [206; 207) 'e': impl Trait + {error}
-    [231; 234) 'foo': impl Trait + {error}
+    [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) '{ }': ()
     "###
     );
 }
@@ -1078,26 +1255,26 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
     [296; 299) 'get': fn get<T>(T) -> <T as Trait>::Type
     [296; 302) 'get(x)': {unknown}
     [300; 301) 'x': T
-    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> U
+    [308; 312) 'get2': fn get2<{unknown}, T>(T) -> {unknown}
     [308; 315) 'get2(x)': {unknown}
     [313; 314) 'x': T
-    [321; 324) 'get': fn get<impl Trait<Type = i64>>(T) -> <T as Trait>::Type
+    [321; 324) 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
     [321; 327) 'get(y)': {unknown}
     [325; 326) 'y': impl Trait<Type = i64>
-    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(T) -> U
+    [333; 337) 'get2': fn get2<{unknown}, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> {unknown}
     [333; 340) 'get2(y)': {unknown}
     [338; 339) 'y': impl Trait<Type = i64>
-    [346; 349) 'get': fn get<S<u64>>(T) -> <T as Trait>::Type
+    [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>>(T) -> T
+    [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>>(T) -> U
+    [363; 367) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
     [363; 375) 'get2(set(S))': u64
-    [368; 371) 'set': fn set<S<u64>>(T) -> T
+    [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>>(T) -> U
+    [381; 385) 'get2': fn get2<str, S<str>>(S<str>) -> str
     [381; 395) 'get2(S::<str>)': str
     [386; 394) 'S::<str>': S<str>
     "###
@@ -1225,6 +1402,32 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
 }
 
 #[test]
+fn super_trait_impl_trait_method_resolution() {
+    assert_snapshot!(
+        infer(r#"
+mod foo {
+    trait SuperTrait {
+        fn foo(&self) -> u32 {}
+    }
+}
+trait Trait1: foo::SuperTrait {}
+
+fn test(x: &impl Trait1) {
+    x.foo();
+}
+"#),
+        @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
+    "###
+    );
+}
+
+#[test]
 fn super_trait_cycle() {
     // This just needs to not crash
     assert_snapshot!(
@@ -1270,9 +1473,9 @@ fn test() {
     [157; 160) '{t}': T
     [158; 159) 't': T
     [259; 280) '{     ...S)); }': ()
-    [265; 269) 'get2': fn get2<u64, S<u64>>(T) -> U
+    [265; 269) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
     [265; 277) 'get2(set(S))': u64
-    [270; 273) 'set': fn set<S<u64>>(T) -> T
+    [270; 273) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
     [270; 276) 'set(S)': S<u64>
     [274; 275) 'S': S<u64>
     "###
@@ -1334,7 +1537,7 @@ fn test() {
     [173; 175) '{}': ()
     [189; 308) '{     ... 1); }': ()
     [199; 200) 'x': Option<u32>
-    [203; 215) 'Option::Some': Some<u32>(T) -> Option<T>
+    [203; 215) 'Option::Some': Some<u32>(u32) -> Option<u32>
     [203; 221) 'Option...(1u32)': Option<u32>
     [216; 220) '1u32': u32
     [227; 228) 'x': Option<u32>
@@ -1444,7 +1647,7 @@ fn test() {
     [340; 342) '{}': ()
     [356; 515) '{     ... S); }': ()
     [366; 368) 'x1': u64
-    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(T, F) -> U
+    [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
@@ -1452,7 +1655,7 @@ fn test() {
     [383; 384) 's': S
     [383; 393) 's.method()': u64
     [404; 406) 'x2': u64
-    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(F, T) -> U
+    [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
@@ -1605,7 +1808,6 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
 
 #[test]
 fn unify_impl_trait() {
-    covers!(insert_vars_for_impl_trait);
     assert_snapshot!(
         infer_with_mismatches(r#"
 trait Trait<T> {}
@@ -1637,26 +1839,26 @@ fn test() -> impl Trait<i32> {
     [172; 183) '{ loop {} }': T
     [174; 181) 'loop {}': !
     [179; 181) '{}': ()
-    [214; 310) '{     ...t()) }': S<i32>
+    [214; 310) '{     ...t()) }': S<{unknown}>
     [224; 226) 's1': S<u32>
-    [229; 230) 'S': S<u32>(T) -> S<T>
+    [229; 230) 'S': S<u32>(u32) -> S<u32>
     [229; 241) 'S(default())': S<u32>
-    [231; 238) 'default': fn default<u32>() -> T
+    [231; 238) 'default': fn default<u32>() -> u32
     [231; 240) 'default()': u32
-    [247; 250) 'foo': fn foo(impl Trait<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>(impl Trait<T>) -> T
+    [273; 276) 'bar': fn bar<i32>(S<i32>) -> i32
     [273; 290) 'bar(S(...lt()))': i32
-    [277; 278) 'S': S<i32>(T) -> S<T>
+    [277; 278) 'S': S<i32>(i32) -> S<i32>
     [277; 289) 'S(default())': S<i32>
-    [279; 286) 'default': fn default<i32>() -> T
+    [279; 286) 'default': fn default<i32>() -> i32
     [279; 288) 'default()': i32
-    [296; 297) 'S': S<i32>(T) -> S<T>
-    [296; 308) 'S(default())': S<i32>
-    [298; 305) 'default': fn default<i32>() -> T
-    [298; 307) '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}
     "###
     );
 }