Add some tests

Author: Aaron1011

src/test/ui/never-fallback/box_it.rs

@@ -0,0 +1,11 @@
+// check-pass
+// Verifies that our fallback-UB check doesn't trigger
+// on correct code
+#![feature(never_type)]
+#![feature(never_type_fallback)]
+
+fn foo(e: !) -> Box<dyn std::error::Error> {
+    Box::<_>::new(e)
+}
+
+fn main() {}

src/test/ui/never-fallback/from.rs

@@ -0,0 +1,14 @@
+// check-pass
+// Tests that we correctly infer types to !
+#![feature(never_type)]
+#![feature(never_type_fallback)]
+
+struct E;
+impl From<!> for E {
+    fn from(x: !) -> E { x }
+}
+fn foo(never: !) {
+    <E as From<_>>::from(never);
+}
+
+fn main() {}

src/test/ui/never-fallback/from_try.rs

@@ -0,0 +1,17 @@
+// check-pass
+use std::convert::{TryFrom, Infallible};
+
+struct E;
+
+impl From<Infallible> for E {
+    fn from(_: Infallible) -> E {
+        E
+    }
+}
+
+fn foo() -> Result<(), E> {
+    u32::try_from(1u32)?;
+    Ok(())
+}
+
+fn main() {}

src/test/ui/never-fallback/obj.rs

@@ -0,0 +1,28 @@
+#![feature(never_type)]
+#![feature(never_type_fallback)]
+
+fn get_type<T>(_: T) -> &'static str {
+    std::any::type_name::<T>()
+}
+
+fn unconstrained_return<T>() -> Result<T, String> {
+    Err("Hi".to_string())
+}
+
+fn foo() {
+    let a = || { 
+        match unconstrained_return::<_>() { //~ ERROR Fallback to `!` may introduce undefined behavior
+            Ok(x) => x,  // `x` has type `_`, which is unconstrained
+            Err(s) => panic!(s),  // … except for unifying with the type of `panic!()`
+            // so that both `match` arms have the same type.
+            // Therefore `_` resolves to `!` and we "return" an `Ok(!)` value.
+        }
+    };
+    
+    let cast: &dyn FnOnce() -> _ = &a;
+    println!("Return type: {:?}", get_type(cast));
+}
+
+fn main() {
+    foo()
+}

src/test/ui/never-fallback/obj.stderr

@@ -0,0 +1,21 @@
+error: Fallback to `!` may introduce undefined behavior
+  --> $DIR/obj.rs:14:15
+   |
+LL |         match unconstrained_return::<_>() {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type here was inferred to `!`
+  --> $DIR/obj.rs:14:38
+   |
+LL |         match unconstrained_return::<_>() {
+   |                                      ^
+note: ... due to this expression evaluating to `!`
+  --> $DIR/obj.rs:16:23
+   |
+LL |             Err(s) => panic!(s),  // … except for unifying with the type of `panic!()`
+   |                       ^^^^^^^^^
+   = note: If you want the `!` type to be used here, add explicit type annotations
+   = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
+
+error: aborting due to previous error
+

src/test/ui/never-fallback/obj_implicit.rs

@@ -0,0 +1,28 @@
+#![feature(never_type)]
+#![feature(never_type_fallback)]
+
+fn get_type<T>(_: T) -> &'static str {
+    std::any::type_name::<T>()
+}
+
+fn unconstrained_return<T>() -> Result<T, String> {
+    Err("Hi".to_string())
+}
+
+fn foo() {
+    let a = || { 
+        match unconstrained_return() { //~ ERROR Fallback to `!` may introduce undefined behavior
+            Ok(x) => x,  // `x` has type `_`, which is unconstrained
+            Err(s) => panic!(s),  // … except for unifying with the type of `panic!()`
+            // so that both `match` arms have the same type.
+            // Therefore `_` resolves to `!` and we "return" an `Ok(!)` value.
+        }
+    };
+    
+    let cast: &dyn FnOnce() -> _ = &a;
+    println!("Return type: {:?}", get_type(cast));
+}
+
+fn main() {
+    foo()
+}

src/test/ui/never-fallback/obj_implicit.stderr

@@ -0,0 +1,26 @@
+error: Fallback to `!` may introduce undefined behavior
+  --> $DIR/obj_implicit.rs:14:15
+   |
+LL |         match unconstrained_return() {
+   |               ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the type parameter T here was inferred to `!`
+  --> $DIR/obj_implicit.rs:14:15
+   |
+LL |         match unconstrained_return() {
+   |               ^^^^^^^^^^^^^^^^^^^^
+note: (type parameter defined here)
+  --> $DIR/obj_implicit.rs:8:25
+   |
+LL | fn unconstrained_return<T>() -> Result<T, String> {
+   |                         ^
+note: ... due to this expression evaluating to `!`
+  --> $DIR/obj_implicit.rs:16:23
+   |
+LL |             Err(s) => panic!(s),  // … except for unifying with the type of `panic!()`
+   |                       ^^^^^^^^^
+   = note: If you want the `!` type to be used here, add explicit type annotations
+   = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
+
+error: aborting due to previous error
+