Empty diverging functions do not warn

Author: varkor

src/libcore/num/mod.rs

@@ -4210,7 +4210,6 @@ impl fmt::Display for TryFromIntError {
 
 #[unstable(feature = "try_from", issue = "33417")]
 impl From<!> for TryFromIntError {
-    #[allow(unreachable_code)]
     fn from(never: !) -> TryFromIntError {
         never
     }

src/librustc_typeck/check/_match.rs

@@ -609,6 +609,7 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
             let diverges = match self.diverges.get() {
                 Diverges::Maybe | Diverges::Always => Diverges::Always,
                 Diverges::WarnedAlways => Diverges::WarnedAlways,
+                Diverges::UnwarnedAlways => Diverges::UnwarnedAlways,
             };
             self.diverges.set(diverges);
             return tcx.types.never;
@@ -637,15 +638,17 @@ https://doc.rust-lang.org/reference/types.html#trait-objects");
             match all_pats_diverge {
                 Diverges::Maybe => Diverges::Maybe,
                 Diverges::Always | Diverges::WarnedAlways => Diverges::WarnedAlways,
+                Diverges::UnwarnedAlways => Diverges::UnwarnedAlways,
             }
         }).collect();
 
         // Now typecheck the blocks.
         //
         // The result of the match is the common supertype of all the
-        // arms. We start the value as the logical bottom , since it's the,
-        // well, bottom of the type lattice, and we'll be moving up the lattice
-        // as we process each arm. (Note that any match with 0 arms is matching
+        // arms. We start the value as the logical bottom (skipping
+        // `UnwarnedAlways`, which is a special case), since it's the, well,
+        // bottom of the type lattice, and we'll be moving up the lattice as
+        // we process each arm. (Note that any match with 0 arms is matching
         // on any empty type and is therefore unreachable; should the flow
         // of execution reach it, we will panic, so bottom is an appropriate
         // type in that case.)

src/librustc_typeck/check/mod.rs

@@ -457,6 +457,13 @@ pub enum Diverges {
     /// Same as `Always` but with a reachability
     /// warning already emitted.
     WarnedAlways,
+
+    /// Same as `Always` but without a reachability
+    /// warning emitted. Unlike `Always`, cannot be
+    /// converted to `WarnedAlways`. Used when
+    /// unreachable code is expected (e.g. in
+    /// function parameters as part of trait impls).
+    UnwarnedAlways,
 }
 
 // Convenience impls for combining `Diverges`.
@@ -1062,7 +1069,16 @@ fn check_fn<'a, 'gcx, 'tcx>(inherited: &'a Inherited<'a, 'gcx, 'tcx>,
         // it must always diverge.
         if fcx.tcx.features().exhaustive_patterns {
             if arg_ty.conservative_is_uninhabited() {
-                fcx.diverges.set(fcx.diverges.get() | Diverges::Always);
+                let mut diverges = Diverges::Always;
+                if let hir::Expr_::ExprBlock(ref block) = body.value.node {
+                    // If the function is completely empty, or has a single trailing
+                    // expression, then we do not issue a warning (as it was likely
+                    // mandated by a trait, rather than being an oversight).
+                    if block.stmts.is_empty() {
+                        diverges = Diverges::UnwarnedAlways;
+                    }
+                }
+                fcx.diverges.set(fcx.diverges.get() | diverges);
             }
         }
 

src/libstd/error.rs

@@ -309,9 +309,8 @@ impl Error for string::FromUtf16Error {
 
 #[stable(feature = "str_parse_error2", since = "1.8.0")]
 impl Error for string::ParseError {
-    #[allow(unreachable_code)]
     fn description(&self) -> &str {
-        match *self {}
+        match self {}
     }
 }
 

src/libstd/process.rs

@@ -1477,7 +1477,6 @@ impl<E: fmt::Debug> Termination for Result<(), E> {
 
 #[unstable(feature = "termination_trait_lib", issue = "43301")]
 impl Termination for ! {
-    #[allow(unreachable_code)]
     fn report(self) -> i32 { self }
 }
 

src/test/compile-fail/unreachable-try-pattern.rs

@@ -17,7 +17,6 @@ enum Void {}
 
 impl From<Void> for i32 {
     fn from(v: Void) -> i32 {
-        //~^ WARN unreachable expression
         match v {}
         //~^ WARN unreachable expression
     }

src/test/ui/better_divergence_checking.rs

@@ -9,12 +9,27 @@
 // except according to those terms.
 
 #![feature(exhaustive_patterns)]
+#![feature(never_type)]
 #![deny(unreachable_code)]
 
 pub enum Void {}
 
-pub fn uninhabited_parameter(_v: Void) {
-    //~^ ERROR unreachable expression
+pub fn uninhabited_parameter_i(_v: Void) {
+    // A function with an uninhabited parameter
+    // is permitted if its body is empty.
+}
+
+pub fn uninhabited_parameter_ii(v: !) -> i32 {
+    // A function with an uninhabited parameter
+    // is permitted if it simply returns a value
+    // as a trailing expression to satisfy the
+    // return type.
+    v
+}
+
+pub fn uninhabited_parameter_iii(_v: Void, x: i32) -> i32 {
+    println!("Call me if you can!"); //~^ ERROR unreachable expression
+    x
 }
 
 fn main() {}

src/test/ui/better_divergence_checking.stderr

@@ -1,14 +1,15 @@
 error: unreachable expression
-  --> $DIR/better_divergence_checking.rs:16:40
+  --> $DIR/better_divergence_checking.rs:30:59
    |
-LL |   pub fn uninhabited_parameter(_v: Void) {
-   |  ________________________________________^
-LL | |     //~^ ERROR unreachable expression
+LL |   pub fn uninhabited_parameter_iii(_v: Void, x: i32) -> i32 {
+   |  ___________________________________________________________^
+LL | |     println!("Call me if you can!"); //~^ ERROR unreachable expression
+LL | |     x
 LL | | }
    | |_^
    |
 note: lint level defined here
-  --> $DIR/better_divergence_checking.rs:12:9
+  --> $DIR/better_divergence_checking.rs:13:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^