Check for uninhabited types in typeck

Author: camsteffen

compiler/rustc_hir_typeck/src/diverges.rs

@@ -71,5 +71,6 @@ impl Diverges<'_> {
 #[derive(Clone, Copy, Debug)]
 pub enum DivergeReason {
     AllArmsDiverge,
+    Uninhabited,
     Other,
 }

compiler/rustc_hir_typeck/src/expr.rs

@@ -244,12 +244,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ExprKind::MethodCall(segment, ..) => {
                 self.warn_if_unreachable(expr.hir_id, segment.ident.span, "call")
             }
+            // allow field access when the struct and the field are both uninhabited
+            ExprKind::Field(..)
+                if matches!(
+                    self.diverges.get(),
+                    Diverges::Always(DivergeReason::Uninhabited, _)
+                ) && self.tcx.is_ty_uninhabited_from(self.parent_module, ty, self.param_env) => {}
             _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression"),
         }
 
         // Any expression that produces a value of type `!` must have diverged
-        if ty.is_never() {
-            self.diverges.set(self.diverges.get() | Diverges::Always(DivergeReason::Other, expr));
+        if !self.diverges.get().is_always() {
+            if ty.is_never() {
+                self.diverges.set(Diverges::Always(DivergeReason::Other, expr));
+            } else if expr_may_be_uninhabited(expr)
+                && self.tcx.is_ty_uninhabited_from(self.parent_module, ty, self.param_env)
+            {
+                self.diverges.set(Diverges::Always(DivergeReason::Uninhabited, expr));
+            }
         }
 
         // Record the type, which applies it effects.
@@ -2886,3 +2898,41 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 }
+
+fn expr_may_be_uninhabited(expr: &hir::Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Call(..)
+        | ExprKind::MethodCall(..)
+        | ExprKind::Cast(..)
+        | ExprKind::Unary(hir::UnOp::Deref, _)
+        | ExprKind::Field(..)
+        | ExprKind::Path(..)
+        | ExprKind::Struct(..) => true,
+        ExprKind::Box(..)
+        | ExprKind::ConstBlock(..)
+        | ExprKind::Array(..)
+        | ExprKind::Tup(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(hir::UnOp::Neg | hir::UnOp::Not, _)
+        | ExprKind::Lit(..)
+        | ExprKind::Type(..)
+        | ExprKind::DropTemps(..)
+        | ExprKind::Let(..)
+        | ExprKind::If(..)
+        | ExprKind::Loop(..)
+        | ExprKind::Match(..)
+        | ExprKind::Closure(..)
+        | ExprKind::Block(..)
+        | ExprKind::Assign(..)
+        | ExprKind::AssignOp(..)
+        | ExprKind::Index(..)
+        | ExprKind::AddrOf(..)
+        | ExprKind::Break(..)
+        | ExprKind::Continue(..)
+        | ExprKind::Ret(..)
+        | ExprKind::InlineAsm(..)
+        | ExprKind::Repeat(..)
+        | ExprKind::Yield(..)
+        | ExprKind::Err => false,
+    }
+}

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -36,6 +36,7 @@ use rustc_trait_selection::traits::{
     self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt,
 };
 
+use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::slice;
 
@@ -58,15 +59,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         self.diverges.set(Diverges::WarnedAlways);
 
+        if matches!(reason, DivergeReason::Uninhabited) {
+            let def_id = self.tcx.hir().body_owner_def_id(hir::BodyId { hir_id: self.body_id });
+            if let Some(impl_of) = self.tcx.impl_of_method(def_id.to_def_id()) {
+                if self.tcx.has_attr(impl_of, sym::automatically_derived) {
+                    // Built-in derives are generated before typeck,
+                    // so they may contain unreachable code if there are uninhabited types
+                    return;
+                }
+            }
+        }
+
         debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
 
         let msg = format!("unreachable {}", kind);
         self.tcx().struct_span_lint_hir(lint::builtin::UNREACHABLE_CODE, id, span, &msg, |lint| {
             let label = match reason {
-                DivergeReason::AllArmsDiverge => {
-                    "any code following this `match` expression is unreachable, as all arms diverge"
-                }
-                DivergeReason::Other => "any code following this expression is unreachable",
+                DivergeReason::AllArmsDiverge =>
+                    Cow::Borrowed("any code following this `match` expression is unreachable, as all arms diverge"),
+                DivergeReason::Uninhabited => format!(
+                    "this expression has type `{}`, which is uninhabited",
+                    self.typeck_results.borrow().node_type(diverging_expr.hir_id)
+                ).into(),
+                DivergeReason::Other => Cow::Borrowed("any code following this expression is unreachable"),
             };
             lint.span_label(span, &msg).span_label(diverging_expr.span, label)
         });

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -48,6 +48,8 @@ pub struct FnCtxt<'a, 'tcx> {
     /// eventually).
     pub(super) param_env: ty::ParamEnv<'tcx>,
 
+    pub(super) parent_module: DefId,
+
     /// Number of errors that had been reported when we started
     /// checking this function. On exit, if we find that *more* errors
     /// have been reported, we will skip regionck and other work that
@@ -138,6 +140,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         FnCtxt {
             body_id,
             param_env,
+            parent_module: inh.tcx.parent_module(body_id).to_def_id(),
             err_count_on_creation: inh.tcx.sess.err_count(),
             ret_coercion: None,
             in_tail_expr: false,

src/test/ui/uninhabited/uninhabited-struct-match.rs

@@ -0,0 +1,24 @@
+#![crate_type = "lib"]
+
+#![warn(unused)]
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Void {}
+
+pub struct UnStruct {
+    x: u32,
+    v: Void
+}
+
+pub fn match_struct(x: UnStruct) {
+    match x {} //~ non-exhaustive patterns: type `UnStruct` is non-empty
+}
+
+pub fn match_inhabited_field(x: UnStruct) {
+    match x.x {} //~  non-exhaustive patterns: type `u32` is non-empty
+                 //~| unreachable expression
+}
+
+pub fn match_uninhabited_field(x: UnStruct) {
+    match x.v {} // ok
+}

src/test/ui/uninhabited/uninhabited-struct-match.stderr

@@ -0,0 +1,52 @@
+warning: unreachable expression
+  --> $DIR/uninhabited-struct-match.rs:18:11
+   |
+LL |     match x.x {}
+   |           -^^
+   |           |
+   |           unreachable expression
+   |           this expression has type `UnStruct`, which is uninhabited
+   |
+note: the lint level is defined here
+  --> $DIR/uninhabited-struct-match.rs:3:9
+   |
+LL | #![warn(unused)]
+   |         ^^^^^^
+   = note: `#[warn(unreachable_code)]` implied by `#[warn(unused)]`
+
+error[E0004]: non-exhaustive patterns: type `UnStruct` is non-empty
+  --> $DIR/uninhabited-struct-match.rs:14:11
+   |
+LL |     match x {}
+   |           ^
+   |
+note: `UnStruct` defined here
+  --> $DIR/uninhabited-struct-match.rs:8:12
+   |
+LL | pub struct UnStruct {
+   |            ^^^^^^^^
+   = note: the matched value is of type `UnStruct`
+help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
+   |
+LL ~     match x {
+LL +         _ => todo!(),
+LL ~     }
+   |
+
+error[E0004]: non-exhaustive patterns: type `u32` is non-empty
+  --> $DIR/uninhabited-struct-match.rs:18:11
+   |
+LL |     match x.x {}
+   |           ^^^
+   |
+   = note: the matched value is of type `u32`
+help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
+   |
+LL ~     match x.x {
+LL +         _ => todo!(),
+LL ~     }
+   |
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0004`.