2 files changed, 615 insertions, 0 deletions

diff --git a/crates/ra_hir/src/ty/tests/coercion.rs b/crates/ra_hir/src/ty/tests/coercion.rs
new file mode 100644
index 000000000..1530fcc63
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/coercion.rs
@@ -0,0 +1,369 @@
+use insta::assert_snapshot;
+use test_utils::covers;
+
+// Infer with some common definitions and impls.
+fn infer(source: &str) -> String {
+    let defs = r#"
+        #[lang = "sized"]
+        pub trait Sized {}
+        #[lang = "unsize"]
+        pub trait Unsize<T: ?Sized> {}
+        #[lang = "coerce_unsized"]
+        pub trait CoerceUnsized<T> {}
+
+        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
+    "#;
+
+    // Append to the end to keep positions unchanged.
+    super::infer(&format!("{}{}", source, defs))
+}
+
+#[test]
+fn infer_block_expr_type_mismatch() {
+    assert_snapshot!(
+        infer(r#"
+fn test() {
+    let a: i32 = { 1i64 };
+}
+"#),
+        @r###"
+    [11; 41) '{     ...4 }; }': ()
+    [21; 22) 'a': i32
+    [30; 38) '{ 1i64 }': i64
+    [32; 36) '1i64': i64
+    "###);
+}
+
+#[test]
+fn coerce_places() {
+    assert_snapshot!(
+        infer(r#"
+struct S<T> { a: T }
+
+fn f<T>(_: &[T]) -> T { loop {} }
+fn g<T>(_: S<&[T]>) -> T { loop {} }
+
+fn gen<T>() -> *mut [T; 2] { loop {} }
+fn test1<U>() -> *mut [U] {
+    gen()
+}
+
+fn test2() {
+    let arr: &[u8; 1] = &[1];
+
+    let a: &[_] = arr;
+    let b = f(arr);
+    let c: &[_] = { arr };
+    let d = g(S { a: arr });
+    let e: [&[_]; 1] = [arr];
+    let f: [&[_]; 2] = [arr; 2];
+    let g: (&[_], &[_]) = (arr, arr);
+}
+"#),
+        @r###"
+    [31; 32) '_': &[T]
+    [45; 56) '{ loop {} }': T
+    [47; 54) 'loop {}': !
+    [52; 54) '{}': ()
+    [65; 66) '_': S<&[T]>
+    [82; 93) '{ loop {} }': T
+    [84; 91) 'loop {}': !
+    [89; 91) '{}': ()
+    [122; 133) '{ loop {} }': *mut [T;_]
+    [124; 131) 'loop {}': !
+    [129; 131) '{}': ()
+    [160; 173) '{     gen() }': *mut [U]
+    [166; 169) 'gen': fn gen<U>() -> *mut [T;_]
+    [166; 171) 'gen()': *mut [U;_]
+    [186; 420) '{     ...rr); }': ()
+    [196; 199) 'arr': &[u8;_]
+    [212; 216) '&[1]': &[u8;_]
+    [213; 216) '[1]': [u8;_]
+    [214; 215) '1': u8
+    [227; 228) 'a': &[u8]
+    [237; 240) 'arr': &[u8;_]
+    [250; 251) 'b': u8
+    [254; 255) 'f': fn f<u8>(&[T]) -> T
+    [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; 316) 'g(S { a: arr })': u8
+    [303; 315) 'S { a: arr }': S<&[u8]>
+    [310; 313) 'arr': &[u8;_]
+    [326; 327) 'e': [&[u8];_]
+    [341; 346) '[arr]': [&[u8];_]
+    [342; 345) 'arr': &[u8;_]
+    [356; 357) 'f': [&[u8];_]
+    [371; 379) '[arr; 2]': [&[u8];_]
+    [372; 375) 'arr': &[u8;_]
+    [377; 378) '2': usize
+    [389; 390) 'g': (&[u8], &[u8])
+    [407; 417) '(arr, arr)': (&[u8], &[u8])
+    [408; 411) 'arr': &[u8;_]
+    [413; 416) 'arr': &[u8;_]
+    "###
+    );
+}
+
+#[test]
+fn infer_let_stmt_coerce() {
+    assert_snapshot!(
+        infer(r#"
+fn test() {
+    let x: &[i32] = &[1];
+}
+"#),
+        @r###"
+    [11; 40) '{     ...[1]; }': ()
+    [21; 22) 'x': &[i32]
+    [33; 37) '&[1]': &[i32;_]
+    [34; 37) '[1]': [i32;_]
+    [35; 36) '1': i32
+    "###);
+}
+
+#[test]
+fn infer_custom_coerce_unsized() {
+    assert_snapshot!(
+        infer(r#"
+struct A<T: ?Sized>(*const T);
+struct B<T: ?Sized>(*const T);
+struct C<T: ?Sized> { inner: *const T }
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<B<U>> for B<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<C<U>> for C<T> {}
+
+fn foo1<T>(x: A<[T]>) -> A<[T]> { x }
+fn foo2<T>(x: B<[T]>) -> B<[T]> { x }
+fn foo3<T>(x: C<[T]>) -> C<[T]> { x }
+
+fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
+    let d = foo1(a);
+    let e = foo2(b);
+    let f = foo3(c);
+}
+"#),
+        @r###"
+    [258; 259) 'x': A<[T]>
+    [279; 284) '{ x }': A<[T]>
+    [281; 282) 'x': A<[T]>
+    [296; 297) 'x': B<[T]>
+    [317; 322) '{ x }': B<[T]>
+    [319; 320) 'x': B<[T]>
+    [334; 335) 'x': C<[T]>
+    [355; 360) '{ x }': C<[T]>
+    [357; 358) 'x': C<[T]>
+    [370; 371) 'a': A<[u8;_]>
+    [385; 386) 'b': B<[u8;_]>
+    [400; 401) 'c': C<[u8;_]>
+    [415; 481) '{     ...(c); }': ()
+    [425; 426) 'd': A<[{unknown}]>
+    [429; 433) 'foo1': fn foo1<{unknown}>(A<[T]>) -> A<[T]>
+    [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; 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; 478) 'foo3(c)': C<[u8]>
+    [476; 477) 'c': C<[u8;_]>
+    "###
+    );
+}
+
+#[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###"
+    [11; 12) 'x': &[T]
+    [28; 39) '{ loop {} }': &[T]
+    [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 {} }': &[T]
+    [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 {} }': &[T]
+    [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 {} }': &[T]
+    [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 coerce_merge_one_by_one1() {
+    covers!(coerce_merge_fail_fallback);
+
+    assert_snapshot!(
+        infer(r#"
+fn test() {
+    let t = &mut 1;
+    let x = match 1 {
+        1 => t as *mut i32,
+        2 => t as &i32,
+        _ => t as *const i32,
+    };
+}
+"#),
+        @r###"
+    [11; 145) '{     ...  }; }': ()
+    [21; 22) 't': &mut i32
+    [25; 31) '&mut 1': &mut i32
+    [30; 31) '1': i32
+    [41; 42) 'x': *const i32
+    [45; 142) 'match ...     }': *const i32
+    [51; 52) '1': i32
+    [63; 64) '1': i32
+    [68; 69) 't': &mut i32
+    [68; 81) 't as *mut i32': *mut i32
+    [91; 92) '2': i32
+    [96; 97) 't': &mut i32
+    [96; 105) 't as &i32': &i32
+    [115; 116) '_': i32
+    [120; 121) 't': &mut i32
+    [120; 135) 't as *const i32': *const i32
+    "###
+    );
+}
diff --git a/crates/ra_hir/src/ty/tests/never_type.rs b/crates/ra_hir/src/ty/tests/never_type.rs
new file mode 100644
index 000000000..c202f545a
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/never_type.rs
@@ -0,0 +1,246 @@
+use super::type_at;
+
+#[test]
+fn infer_never1() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test() {
+    let t = return;
+    t<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn infer_never2() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn gen<T>() -> T { loop {} }
+
+fn test() {
+    let a = gen();
+    if false { a } else { loop {} };
+    a<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn infer_never3() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn gen<T>() -> T { loop {} }
+
+fn test() {
+    let a = gen();
+    if false { loop {} } else { a };
+    a<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn never_type_in_generic_args() {
+    let t = type_at(
+        r#"
+//- /main.rs
+enum Option<T> { None, Some(T) }
+
+fn test() {
+    let a = if true { Option::None } else { Option::Some(return) };
+    a<|>;
+}
+"#,
+    );
+    assert_eq!(t, "Option<!>");
+}
+
+#[test]
+fn never_type_can_be_reinferred1() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn gen<T>() -> T { loop {} }
+
+fn test() {
+    let a = gen();
+    if false { loop {} } else { a };
+    a<|>;
+    if false { a };
+}
+"#,
+    );
+    assert_eq!(t, "()");
+}
+
+#[test]
+fn never_type_can_be_reinferred2() {
+    let t = type_at(
+        r#"
+//- /main.rs
+enum Option<T> { None, Some(T) }
+
+fn test() {
+    let a = if true { Option::None } else { Option::Some(return) };
+    a<|>;
+    match 42 {
+        42 => a,
+        _ => Option::Some(42),
+    };
+}
+"#,
+    );
+    assert_eq!(t, "Option<i32>");
+}
+#[test]
+fn never_type_can_be_reinferred3() {
+    let t = type_at(
+        r#"
+//- /main.rs
+enum Option<T> { None, Some(T) }
+
+fn test() {
+    let a = if true { Option::None } else { Option::Some(return) };
+    a<|>;
+    match 42 {
+        42 => a,
+        _ => Option::Some("str"),
+    };
+}
+"#,
+    );
+    assert_eq!(t, "Option<&str>");
+}
+
+#[test]
+fn match_no_arm() {
+    let t = type_at(
+        r#"
+//- /main.rs
+enum Void {}
+
+fn test(a: Void) {
+    let t = match a {};
+    t<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn if_never() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test() {
+    let i = if true {
+        loop {}
+    } else {
+        3.0
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "f64");
+}
+
+#[test]
+fn if_else_never() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(input: bool) {
+    let i = if input {
+        2.0
+    } else {
+        return
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "f64");
+}
+
+#[test]
+fn match_first_arm_never() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: i32) {
+    let i = match a {
+        1 => return,
+        2 => 2.0,
+        3 => loop {},
+        _ => 3.0,
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "f64");
+}
+
+#[test]
+fn match_second_arm_never() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: i32) {
+    let i = match a {
+        1 => 3.0,
+        2 => loop {},
+        3 => 3.0,
+        _ => return,
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "f64");
+}
+
+#[test]
+fn match_all_arms_never() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: i32) {
+    let i = match a {
+        2 => return,
+        _ => loop {},
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn match_no_never_arms() {
+    let t = type_at(
+        r#"
+//- /main.rs
+fn test(a: i32) {
+    let i = match a {
+        2 => 2.0,
+        _ => 3.0,
+    };
+    i<|>;
+}
+"#,
+    );
+    assert_eq!(t, "f64");
+}