From bf161fa3e58d57d9b15bd965405036d834f18595 Mon Sep 17 00:00:00 2001
From: uHOOCCOOHu <hooccooh1896@gmail.com>
Date: Wed, 18 Sep 2019 03:59:51 +0800
Subject: Better handle never type and branch merging Split out tests for never
 type to another file

---
 crates/ra_hir/src/ty/tests/never_type.rs | 258 +++++++++++++++++++++++++++++++
 1 file changed, 258 insertions(+)
 create mode 100644 crates/ra_hir/src/ty/tests/never_type.rs

(limited to 'crates/ra_hir/src/ty/tests')

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..b9af918e9
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/never_type.rs
@@ -0,0 +1,258 @@
+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
+trait Foo { fn gen() -> Self; }
+impl Foo for ! { fn gen() -> Self { loop {} } }
+impl Foo for () { fn gen() -> Self { loop {} } }
+
+fn test() {
+    let a = Foo::gen();
+    if false { a } else { loop {} };
+    a<|>;
+}
+"#,
+    );
+    assert_eq!(t, "!");
+}
+
+#[test]
+fn infer_never3() {
+    let t = type_at(
+        r#"
+//- /main.rs
+trait Foo { fn gen() -> Self; }
+impl Foo for ! { fn gen() -> Self { loop {} } }
+impl Foo for () { fn gen() -> Self { loop {} } }
+
+fn test() {
+    let a = Foo::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
+trait Foo { fn gen() -> Self; }
+impl Foo for ! { fn gen() -> Self { loop {} } }
+impl Foo for () { fn gen() -> Self { loop {} } }
+
+fn test() {
+    let a = Foo::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");
+}
-- 
cgit v1.2.3