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

@@ -253,16 +253,39 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // diverging expression (e.g. it arose from desugaring of `try { return }`),
             // we skip issuing a warning because it is autogenerated code.
             ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
-            ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
+            ExprKind::Call(callee, _) => {
+                let emit_warning = if let ExprKind::Path(ref qpath) = callee.kind {
+                    // Do not emit a warning for a call to a constructor.
+                    let res = self.typeck_results.borrow().qpath_res(qpath, callee.hir_id);
+                    !matches!(res, Res::Def(DefKind::Ctor(..), _))
+                } else {
+                    true
+                };
+                if emit_warning {
+                    self.warn_if_unreachable(expr.hir_id, callee.span, "call")
+                }
+            }
             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.ty_is_uninhabited(ty) => {}
             _ => 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() {
+                // Any expression that produces a value of type `!` must have diverged.
+                self.diverges.set(Diverges::Always(DivergeReason::Other, expr));
+            } else if expr_may_be_uninhabited(expr) && self.ty_is_uninhabited(ty) {
+                // This expression produces a value of uninhabited type.
+                // This means it has diverged somehow.
+                self.diverges.set(Diverges::Always(DivergeReason::Uninhabited, expr));
+            }
         }
 
         // Record the type, which applies it effects.
@@ -279,6 +302,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ty
     }
 
+    fn ty_is_uninhabited(&self, ty: Ty<'tcx>) -> bool {
+        let ty = self.resolve_vars_if_possible(ty);
+        // Freshen the type as `is_inhabited_from` may call a query on `ty`.
+        let ty = self.freshen(ty);
+        !ty.is_inhabited_from(self.tcx, self.parent_module, self.param_env)
+    }
+
     #[instrument(skip(self, expr), level = "debug")]
     fn check_expr_kind(
         &self,
@@ -3206,3 +3236,42 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.tcx.types.usize
     }
 }
+
+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::ConstBlock(..)
+        | ExprKind::Array(..)
+        | ExprKind::Tup(..)
+        | ExprKind::Binary(..)
+        | ExprKind::Unary(hir::UnOp::Neg | hir::UnOp::Not, _)
+        | ExprKind::Lit(..)
+        | ExprKind::Type(..)
+        | ExprKind::DropTemps(..)
+        | ExprKind::OffsetOf(..)
+        | 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::Become(..)
+        | ExprKind::InlineAsm(..)
+        | ExprKind::Repeat(..)
+        | ExprKind::Yield(..)
+        | ExprKind::Err(_) => false,
+    }
+}

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -40,6 +40,7 @@ use rustc_trait_selection::traits::{
     self, NormalizeExt, ObligationCauseCode, ObligationCtxt, StructurallyNormalizeExt,
 };
 
+use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::slice;
 
@@ -62,15 +63,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         self.diverges.set(Diverges::WarnedAlways);
 
+        if matches!(reason, DivergeReason::Uninhabited) {
+            if let Some(impl_of) = self.tcx.impl_of_method(self.body_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.clone(), |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
@@ -122,6 +124,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         FnCtxt {
             body_id,
             param_env,
+            parent_module: inh.tcx.parent_module_from_def_id(body_id).to_def_id(),
             err_count_on_creation: inh.tcx.sess.err_count(),
             ret_coercion: None,
             ret_coercion_span: Cell::new(None),

compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs

@@ -62,18 +62,7 @@ impl<'tcx> InhabitedPredicate<'tcx> {
                 Some(1..) => Ok(false),
             },
             Self::NotInModule(id) => in_module(id).map(|in_mod| !in_mod),
-            // `t` may be a projection, for which `inhabited_predicate` returns a `GenericType`. As
-            // we have a param_env available, we can do better.
-            Self::GenericType(t) => {
-                let normalized_pred = tcx
-                    .try_normalize_erasing_regions(param_env, t)
-                    .map_or(self, |t| t.inhabited_predicate(tcx));
-                match normalized_pred {
-                    // We don't have more information than we started with, so consider inhabited.
-                    Self::GenericType(_) => Ok(true),
-                    pred => pred.apply_inner(tcx, param_env, in_module),
-                }
-            }
+            Self::GenericType(_) => Ok(true),
             Self::And([a, b]) => try_and(a, b, |x| x.apply_inner(tcx, param_env, in_module)),
             Self::Or([a, b]) => try_or(a, b, |x| x.apply_inner(tcx, param_env, in_module)),
         }

compiler/rustc_passes/src/liveness.rs

@@ -95,7 +95,7 @@ use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Expr, HirId, HirIdMap, HirIdSet};
 use rustc_index::IndexVec;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, RootVariableMinCaptureList, Ty, TyCtxt};
+use rustc_middle::ty::{self, RootVariableMinCaptureList, TyCtxt};
 use rustc_session::lint;
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::DUMMY_SP;
@@ -121,8 +121,8 @@ rustc_index::newtype_index! {
 #[derive(Copy, Clone, PartialEq, Debug)]
 enum LiveNodeKind {
     UpvarNode(Span),
-    ExprNode(Span, HirId),
-    VarDefNode(Span, HirId),
+    ExprNode(Span),
+    VarDefNode(Span),
     ClosureNode,
     ExitNode,
 }
@@ -131,8 +131,8 @@ fn live_node_kind_to_string(lnk: LiveNodeKind, tcx: TyCtxt<'_>) -> String {
     let sm = tcx.sess.source_map();
     match lnk {
         UpvarNode(s) => format!("Upvar node [{}]", sm.span_to_diagnostic_string(s)),
-        ExprNode(s, _) => format!("Expr node [{}]", sm.span_to_diagnostic_string(s)),
-        VarDefNode(s, _) => format!("Var def node [{}]", sm.span_to_diagnostic_string(s)),
+        ExprNode(s) => format!("Expr node [{}]", sm.span_to_diagnostic_string(s)),
+        VarDefNode(s) => format!("Var def node [{}]", sm.span_to_diagnostic_string(s)),
         ClosureNode => "Closure node".to_owned(),
         ExitNode => "Exit node".to_owned(),
     }
@@ -354,7 +354,7 @@ impl<'tcx> IrMaps<'tcx> {
         let shorthand_field_ids = self.collect_shorthand_field_ids(pat);
 
         pat.each_binding(|_, hir_id, _, ident| {
-            self.add_live_node_for_node(hir_id, VarDefNode(ident.span, hir_id));
+            self.add_live_node_for_node(hir_id, VarDefNode(ident.span));
             self.add_variable(Local(LocalInfo {
                 id: hir_id,
                 name: ident.name,
@@ -368,7 +368,7 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
     fn visit_local(&mut self, local: &'tcx hir::Local<'tcx>) {
         self.add_from_pat(&local.pat);
         if local.els.is_some() {
-            self.add_live_node_for_node(local.hir_id, ExprNode(local.span, local.hir_id));
+            self.add_live_node_for_node(local.hir_id, ExprNode(local.span));
         }
         intravisit::walk_local(self, local);
     }
@@ -403,14 +403,14 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
             hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
                 debug!("expr {}: path that leads to {:?}", expr.hir_id, path.res);
                 if let Res::Local(_var_hir_id) = path.res {
-                    self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
+                    self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
                 }
                 intravisit::walk_expr(self, expr);
             }
             hir::ExprKind::Closure(closure) => {
                 // Interesting control flow (for loops can contain labeled
                 // breaks or continues)
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
+                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
 
                 // Make a live_node for each mentioned variable, with the span
                 // being the location that the variable is used. This results
@@ -438,11 +438,11 @@ impl<'tcx> Visitor<'tcx> for IrMaps<'tcx> {
             | hir::ExprKind::Match(..)
             | hir::ExprKind::Loop(..)
             | hir::ExprKind::Yield(..) => {
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
+                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
                 intravisit::walk_expr(self, expr);
             }
             hir::ExprKind::Binary(op, ..) if op.node.is_lazy() => {
-                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span, expr.hir_id));
+                self.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
                 intravisit::walk_expr(self, expr);
             }
 
@@ -1288,52 +1288,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
     fn check_is_ty_uninhabited(&mut self, expr: &Expr<'_>, succ: LiveNode) -> LiveNode {
         let ty = self.typeck_results.expr_ty(expr);
         let m = self.ir.tcx.parent_module(expr.hir_id).to_def_id();
-        if ty.is_inhabited_from(self.ir.tcx, m, self.param_env) {
-            return succ;
-        }
-        match self.ir.lnks[succ] {
-            LiveNodeKind::ExprNode(succ_span, succ_id) => {
-                self.warn_about_unreachable(expr.span, ty, succ_span, succ_id, "expression");
-            }
-            LiveNodeKind::VarDefNode(succ_span, succ_id) => {
-                self.warn_about_unreachable(expr.span, ty, succ_span, succ_id, "definition");
-            }
-            _ => {}
-        };
-        self.exit_ln
-    }
-
-    fn warn_about_unreachable<'desc>(
-        &mut self,
-        orig_span: Span,
-        orig_ty: Ty<'tcx>,
-        expr_span: Span,
-        expr_id: HirId,
-        descr: &'desc str,
-    ) {
-        if !orig_ty.is_never() {
-            // Unreachable code warnings are already emitted during type checking.
-            // However, during type checking, full type information is being
-            // calculated but not yet available, so the check for diverging
-            // expressions due to uninhabited result types is pretty crude and
-            // only checks whether ty.is_never(). Here, we have full type
-            // information available and can issue warnings for less obviously
-            // uninhabited types (e.g. empty enums). The check above is used so
-            // that we do not emit the same warning twice if the uninhabited type
-            // is indeed `!`.
-
-            self.ir.tcx.emit_spanned_lint(
-                lint::builtin::UNREACHABLE_CODE,
-                expr_id,
-                expr_span,
-                errors::UnreachableDueToUninhabited {
-                    expr: expr_span,
-                    orig: orig_span,
-                    descr,
-                    ty: orig_ty,
-                },
-            );
-        }
+        if ty.is_inhabited_from(self.ir.tcx, m, self.param_env) { succ } else { self.exit_ln }
     }
 }
 

src/tools/miri/src/shims/unix/dlsym.rs

@@ -46,8 +46,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
         match dlsym {
             Dlsym::Android(dlsym) =>
                 android::EvalContextExt::call_dlsym(this, dlsym, args, dest, ret),
+            #[allow(unreachable_code)]
             Dlsym::FreeBsd(dlsym) =>
                 freebsd::EvalContextExt::call_dlsym(this, dlsym, args, dest, ret),
+            #[allow(unreachable_code)]
             Dlsym::Linux(dlsym) => linux::EvalContextExt::call_dlsym(this, dlsym, args, dest, ret),
             Dlsym::MacOs(dlsym) => macos::EvalContextExt::call_dlsym(this, dlsym, args, dest, ret),
         }

src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs

@@ -470,6 +470,7 @@ impl Constructor {
             (IntRange(self_range), IntRange(other_range)) => self_range.is_covered_by(other_range),
             (FloatRange(void), FloatRange(..)) => match *void {},
             (Str(void), Str(..)) => match *void {},
+            #[allow(unreachable_code)]
             (Slice(self_slice), Slice(other_slice)) => self_slice.is_covered_by(*other_slice),
 
             // We are trying to inspect an opaque constant. Thus we skip the row.
@@ -502,6 +503,7 @@ impl Constructor {
                 .iter()
                 .filter_map(|c| c.as_int_range())
                 .any(|other| range.is_covered_by(other)),
+            #[allow(unreachable_code)]
             Slice(slice) => used_ctors
                 .iter()
                 .filter_map(|c| c.as_slice())