Remove carveouts.

Author: cjgillot

compiler/rustc_hir_typeck/src/expr.rs

@@ -230,18 +230,7 @@ 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, _) => {
-                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::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
             ExprKind::MethodCall(segment, ..) => {
                 self.warn_if_unreachable(expr.hir_id, segment.ident.span, "call")
             }
@@ -258,7 +247,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             if ty.is_never() {
                 // Any expression that produces a value of type `!` must have diverged.
                 self.diverges.set(Diverges::Always(DivergeReason::Other, expr.span));
-            } else if expr_may_be_uninhabited(expr) && self.ty_is_uninhabited(ty) {
+            } else if self.ty_is_uninhabited(ty) {
                 // This expression produces a value of uninhabited type.
                 // This means it has diverged somehow.
                 self.diverges
@@ -3554,42 +3543,3 @@ 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/mod.rs

@@ -49,6 +49,9 @@ pub(crate) struct FnCtxt<'a, 'tcx> {
     /// eventually).
     pub(super) param_env: ty::ParamEnv<'tcx>,
 
+    /// The module in which the current function is defined. This
+    /// is used to compute type inhabitedness, which accounts for
+    /// visibility information.
     pub(super) parent_module: DefId,
 
     /// If `Some`, this stores coercion information for returned

tests/ui/consts/const-eval/write-to-uninhabited-enum-variant.rs

@@ -1,5 +1,6 @@
 //@ run-pass
 #![allow(unreachable_patterns)]
+#![allow(unreachable_code)]
 #![allow(dead_code)]
 
 enum Empty {}

tests/ui/enum-discriminant/issue-46519.rs

@@ -19,7 +19,7 @@ pub enum SystemFont {}
 
 impl FontLanguageOverride {
     fn system_font(f: SystemFont) -> Self {
-        FontLanguageOverride::System(f)
+        FontLanguageOverride::System(f) //~ unreachable call
     }
 }
 

tests/ui/enum-discriminant/issue-46519.stderr

@@ -8,5 +8,13 @@ LL |     FontLanguageOverride::system_font(SystemFont::new());
    |
    = note: `#[warn(unreachable_code)]` on by default
 
-warning: 1 warning emitted
+warning: unreachable call
+  --> $DIR/issue-46519.rs:22:9
+   |
+LL |         FontLanguageOverride::System(f)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - this expression has type `SystemFont`, which is uninhabited
+   |         |
+   |         unreachable call
+
+warning: 2 warnings emitted
 

tests/ui/reachable/type-dependent-ctor.rs

@@ -1,5 +1,4 @@
 // Verify that we do not warn on type-dependent constructors (`Self::A` below).
-//@ check-pass
 #![deny(unreachable_code)]
 
 enum Void {}
@@ -11,10 +10,12 @@ enum Foo {
 impl Foo {
     fn wrap(x: Void) -> Self {
         Self::A(x)
+        //~^ ERROR unreachable call
     }
 
     fn make() -> Self {
         Self::A(produce())
+        //~^ ERROR unreachable call
     }
 }
 

tests/ui/reachable/type-dependent-ctor.stderr

@@ -0,0 +1,24 @@
+error: unreachable call
+  --> $DIR/type-dependent-ctor.rs:12:9
+   |
+LL |         Self::A(x)
+   |         ^^^^^^^ - this expression has type `Void`, which is uninhabited
+   |         |
+   |         unreachable call
+   |
+note: the lint level is defined here
+  --> $DIR/type-dependent-ctor.rs:2:9
+   |
+LL | #![deny(unreachable_code)]
+   |         ^^^^^^^^^^^^^^^^
+
+error: unreachable call
+  --> $DIR/type-dependent-ctor.rs:17:9
+   |
+LL |         Self::A(produce())
+   |         ^^^^^^^ --------- this expression has type `Void`, which is uninhabited
+   |         |
+   |         unreachable call
+
+error: aborting due to 2 previous errors
+

tests/ui/reachable/unreachable-try-pattern.rs

@@ -29,6 +29,7 @@ fn qux(x: Result<u32, Void>) -> Result<u32, i32> {
 fn vom(x: Result<u32, Void>) -> Result<u32, i32> {
     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
     //~^ WARN unreachable pattern
+    //~| WARN unreachable call
     Ok(y)
 }
 

tests/ui/reachable/unreachable-try-pattern.stderr

@@ -13,6 +13,14 @@ note: the lint level is defined here
 LL | #![warn(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
+warning: unreachable call
+  --> $DIR/unreachable-try-pattern.rs:30:50
+   |
+LL |     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
+   |                                                  ^^^ - this expression has type `Void`, which is uninhabited
+   |                                                  |
+   |                                                  unreachable call
+
 warning: unreachable pattern
   --> $DIR/unreachable-try-pattern.rs:19:24
    |
@@ -34,5 +42,5 @@ LL |     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
    |
    = note: this pattern matches no values because `Void` is uninhabited
 
-warning: 3 warnings emitted
+warning: 4 warnings emitted
 

tests/ui/try-block/try-block-unreachable-code-lint.rs

@@ -50,6 +50,7 @@ fn test_try_block_after_divergent_stmt() {
 fn test_wrapped_divergent_expr() {
     let _: Result<u32, ()> = {
         Err(return)
+        //~^ WARN unreachable call
     };
 }