1 files changed, 215 insertions, 56 deletions

diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 6076e4025..2ce0039b1 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -806,14 +806,14 @@ fn infer_argument_autoderef() {
         infer(r#"
 #[lang = "deref"]
 pub trait Deref {
-    type Target: ?Sized;
+    type Target;
     fn deref(&self) -> &Self::Target;
 }
 
 struct A<T>(T);
 
-impl<T: Copy> A<T> {
-    fn foo(&self) -> T {
+impl<T> A<T> {
+    fn foo(&self) -> &T {
         self.0
     }
 }
@@ -828,32 +828,33 @@ impl<T> Deref for B<T> {
 }
 
 fn test() {
-    A::foo(&&B(B(A(42))));
+    let t = A::foo(&&B(B(A(42))));
 }
 "#),
         @r###"
-    [76; 80) 'self': &Self
-    [153; 157) 'self': &A<T>
-    [164; 186) '{     ...     }': T
-    [174; 178) 'self': &A<T>
-    [174; 180) 'self.0': T
-    [267; 271) 'self': &B<T>
-    [290; 313) '{     ...     }': &T
-    [300; 307) '&self.0': &T
-    [301; 305) 'self': &B<T>
-    [301; 307) 'self.0': T
-    [327; 357) '{     ...))); }': ()
-    [333; 339) 'A::foo': fn foo<i32>(&A<T>) -> T
-    [333; 354) 'A::foo...42))))': i32
-    [340; 353) '&&B(B(A(42)))': &&B<B<A<i32>>>
-    [341; 353) '&B(B(A(42)))': &B<B<A<i32>>>
-    [342; 343) 'B': B<B<A<i32>>>(T) -> B<T>
-    [342; 353) 'B(B(A(42)))': B<B<A<i32>>>
-    [344; 345) 'B': B<A<i32>>(T) -> B<T>
-    [344; 352) 'B(A(42))': B<A<i32>>
-    [346; 347) 'A': A<i32>(T) -> A<T>
-    [346; 351) 'A(42)': A<i32>
-    [348; 350) '42': i32
+    [68; 72) 'self': &Self
+    [139; 143) 'self': &A<T>
+    [151; 173) '{     ...     }': T
+    [161; 165) 'self': &A<T>
+    [161; 167) 'self.0': T
+    [254; 258) 'self': &B<T>
+    [277; 300) '{     ...     }': &T
+    [287; 294) '&self.0': &T
+    [288; 292) 'self': &B<T>
+    [288; 294) 'self.0': T
+    [314; 352) '{     ...))); }': ()
+    [324; 325) 't': &i32
+    [328; 334) 'A::foo': fn foo<i32>(&A<T>) -> &T
+    [328; 349) 'A::foo...42))))': &i32
+    [335; 348) '&&B(B(A(42)))': &&B<B<A<i32>>>
+    [336; 348) '&B(B(A(42)))': &B<B<A<i32>>>
+    [337; 338) 'B': B<B<A<i32>>>(T) -> B<T>
+    [337; 348) 'B(B(A(42)))': B<B<A<i32>>>
+    [339; 340) 'B': B<A<i32>>(T) -> B<T>
+    [339; 347) 'B(A(42))': B<A<i32>>
+    [341; 342) 'A': A<i32>(T) -> A<T>
+    [341; 346) 'A(42)': A<i32>
+    [343; 345) '42': i32
 "###
     );
 }
@@ -864,15 +865,15 @@ fn infer_method_argument_autoderef() {
         infer(r#"
 #[lang = "deref"]
 pub trait Deref {
-    type Target: ?Sized;
+    type Target;
     fn deref(&self) -> &Self::Target;
 }
 
 struct A<T>(*mut T);
 
-impl<T: Copy> A<T> {
-    fn foo(&self, x: &A<T>) -> T {
-        x
+impl<T> A<T> {
+    fn foo(&self, x: &A<T>) -> &T {
+        &*x.0
     }
 }
 
@@ -886,39 +887,197 @@ impl<T> Deref for B<T> {
 }
 
 fn test(a: A<i32>) {
-    A(0 as *mut _).foo(&&B(B(a)));
+    let t = A(0 as *mut _).foo(&&B(B(a)));
+}
+"#),
+        @r###"
+    [68; 72) 'self': &Self
+    [144; 148) 'self': &A<T>
+    [150; 151) 'x': &A<T>
+    [166; 187) '{     ...     }': &T
+    [176; 181) '&*x.0': &T
+    [177; 181) '*x.0': T
+    [178; 179) 'x': &A<T>
+    [178; 181) 'x.0': *mut T
+    [268; 272) 'self': &B<T>
+    [291; 314) '{     ...     }': &T
+    [301; 308) '&self.0': &T
+    [302; 306) 'self': &B<T>
+    [302; 308) 'self.0': T
+    [326; 327) 'a': A<i32>
+    [337; 383) '{     ...))); }': ()
+    [347; 348) 't': &i32
+    [351; 352) 'A': A<i32>(*mut T) -> A<T>
+    [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; 379) 'B(B(a))': B<B<A<i32>>>
+    [374; 375) 'B': B<A<i32>>(T) -> B<T>
+    [374; 378) 'B(a)': B<A<i32>>
+    [376; 377) 'a': A<i32>
+"###
+    );
+}
+
+#[test]
+fn infer_if_coerce() {
+    assert_snapshot!(
+        infer(r#"
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test() {
+    let x = if true {
+        foo(&[1])
+    } else {
+        &[1]
+    };
 }
 "#),
         @r###"
-    [76; 80) 'self': &Self
-    [158; 162) 'self': &A<T>
-    [164; 165) 'x': &A<T>
-    [179; 196) '{     ...     }': &A<T>
-    [189; 190) 'x': &A<T>
-    [277; 281) 'self': &B<T>
-    [300; 323) '{     ...     }': &T
-    [310; 317) '&self.0': &T
-    [311; 315) 'self': &B<T>
-    [311; 317) 'self.0': T
-    [335; 336) 'a': A<i32>
-    [346; 384) '{     ...))); }': ()
-    [352; 353) 'A': A<i32>(*mut T) -> A<T>
-    [352; 366) 'A(0 as *mut _)': A<i32>
-    [352; 381) 'A(0 as...B(a)))': i32
-    [354; 355) '0': i32
-    [354; 365) '0 as *mut _': *mut i32
-    [371; 380) '&&B(B(a))': &&B<B<A<i32>>>
-    [372; 380) '&B(B(a))': &B<B<A<i32>>>
-    [373; 374) 'B': B<B<A<i32>>>(T) -> B<T>
-    [373; 380) 'B(B(a))': B<B<A<i32>>>
-    [375; 376) 'B': B<A<i32>>(T) -> B<T>
-    [375; 379) 'B(a)': B<A<i32>>
-    [377; 378) 'a': A<i32>
+    [11; 12) 'x': &[T]
+    [28; 39) '{ loop {} }': !
+    [30; 37) 'loop {}': !
+    [35; 37) '{}': ()
+    [50; 126) '{     ...  }; }': ()
+    [60; 61) 'x': &[i32]
+    [64; 123) 'if tru...     }': &[i32]
+    [67; 71) 'true': bool
+    [72; 97) '{     ...     }': &[i32]
+    [82; 85) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [82; 91) 'foo(&[1])': &[i32]
+    [86; 90) '&[1]': &[i32;_]
+    [87; 90) '[1]': [i32;_]
+    [88; 89) '1': i32
+    [103; 123) '{     ...     }': &[i32;_]
+    [113; 117) '&[1]': &[i32;_]
+    [114; 117) '[1]': [i32;_]
+    [115; 116) '1': i32
 "###
     );
 }
 
 #[test]
+fn infer_if_else_coerce() {
+    assert_snapshot!(
+        infer(r#"
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test() {
+    let x = if true {
+        &[1]
+    } else {
+        foo(&[1])
+    };
+}
+"#),
+        @r###"
+    [11; 12) 'x': &[T]
+    [28; 39) '{ loop {} }': !
+    [30; 37) 'loop {}': !
+    [35; 37) '{}': ()
+    [50; 126) '{     ...  }; }': ()
+    [60; 61) 'x': &[i32]
+    [64; 123) 'if tru...     }': &[i32]
+    [67; 71) 'true': bool
+    [72; 92) '{     ...     }': &[i32;_]
+    [82; 86) '&[1]': &[i32;_]
+    [83; 86) '[1]': [i32;_]
+    [84; 85) '1': i32
+    [98; 123) '{     ...     }': &[i32]
+    [108; 111) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [108; 117) 'foo(&[1])': &[i32]
+    [112; 116) '&[1]': &[i32;_]
+    [113; 116) '[1]': [i32;_]
+    [114; 115) '1': i32
+"###
+    );
+}
+
+#[test]
+fn infer_match_first_coerce() {
+    assert_snapshot!(
+        infer(r#"
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test(i: i32) {
+    let x = match i {
+        2 => foo(&[2]),
+        1 => &[1],
+        _ => &[3],
+    };
+}
+"#),
+        @r###"
+    [11; 12) 'x': &[T]
+    [28; 39) '{ loop {} }': !
+    [30; 37) 'loop {}': !
+    [35; 37) '{}': ()
+    [48; 49) 'i': i32
+    [56; 150) '{     ...  }; }': ()
+    [66; 67) 'x': &[i32]
+    [70; 147) 'match ...     }': &[i32]
+    [76; 77) 'i': i32
+    [88; 89) '2': i32
+    [93; 96) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [93; 102) 'foo(&[2])': &[i32]
+    [97; 101) '&[2]': &[i32;_]
+    [98; 101) '[2]': [i32;_]
+    [99; 100) '2': i32
+    [112; 113) '1': i32
+    [117; 121) '&[1]': &[i32;_]
+    [118; 121) '[1]': [i32;_]
+    [119; 120) '1': i32
+    [131; 132) '_': i32
+    [136; 140) '&[3]': &[i32;_]
+    [137; 140) '[3]': [i32;_]
+    [138; 139) '3': i32
+    "###
+    );
+}
+
+#[test]
+fn infer_match_second_coerce() {
+    assert_snapshot!(
+        infer(r#"
+fn foo<T>(x: &[T]) -> &[T] { loop {} }
+fn test(i: i32) {
+    let x = match i {
+        1 => &[1],
+        2 => foo(&[2]),
+        _ => &[3],
+    };
+}
+"#),
+        @r###"
+    [11; 12) 'x': &[T]
+    [28; 39) '{ loop {} }': !
+    [30; 37) 'loop {}': !
+    [35; 37) '{}': ()
+    [48; 49) 'i': i32
+    [56; 150) '{     ...  }; }': ()
+    [66; 67) 'x': &[i32]
+    [70; 147) 'match ...     }': &[i32]
+    [76; 77) 'i': i32
+    [88; 89) '1': i32
+    [93; 97) '&[1]': &[i32;_]
+    [94; 97) '[1]': [i32;_]
+    [95; 96) '1': i32
+    [107; 108) '2': i32
+    [112; 115) 'foo': fn foo<i32>(&[T]) -> &[T]
+    [112; 121) 'foo(&[2])': &[i32]
+    [116; 120) '&[2]': &[i32;_]
+    [117; 120) '[2]': [i32;_]
+    [118; 119) '2': i32
+    [131; 132) '_': i32
+    [136; 140) '&[3]': &[i32;_]
+    [137; 140) '[3]': [i32;_]
+    [138; 139) '3': i32
+    "###
+    );
+}
+
+#[test]
 fn bug_484() {
     assert_snapshot!(
         infer(r#"
@@ -3474,7 +3633,7 @@ trait Deref {
 }
 
 struct Arc<T>;
-impl<T: ?Sized> Deref for Arc<T> {
+impl<T> Deref for Arc<T> {
     type Target = T;
 }