Coalesce unreachable_patterns lint messages

compiler/rustc_error_messages/locales/en-US/mir_build.ftl

@@ -192,9 +192,15 @@ mir_build_const_param_in_pattern = const parameters cannot be referenced in patt
 
 mir_build_non_const_path = runtime values cannot be referenced in patterns
 
-mir_build_unreachable_pattern = unreachable pattern
-    .label = unreachable pattern
-    .catchall_label = matches any value
+mir_build_unreachable_patterns = {$count ->
+    [one] unreachable pattern
+    *[more] multiple unreachable patterns
+    }
+    .catchall_label = this pattern is irrefutable; subsequent arms are never executed
+
+mir_build_never_executed = this arm is never executed
+
+mir_build_unreachable_pattern = this pattern is unreachable
 
 mir_build_const_pattern_depends_on_generic_parameter =
     constant pattern depends on a generic parameter

compiler/rustc_middle/src/lint.rs

@@ -298,6 +298,7 @@ pub fn explain_lint_level_source(
 ///     //          ^^^^^^^^^^^^^^^^^^^^^ returns `&mut DiagnosticBuilder` by default
 /// )
 /// ```
+#[track_caller]
 pub fn struct_lint_level(
     sess: &Session,
     lint: &'static Lint,
@@ -311,6 +312,7 @@ pub fn struct_lint_level(
 ) {
     // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to
     // the "real" work.
+    #[track_caller]
     fn struct_lint_level_impl(
         sess: &Session,
         lint: &'static Lint,

compiler/rustc_middle/src/ty/context.rs

@@ -2075,6 +2075,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Emit a lint at `span` from a lint struct (some type that implements `DecorateLint`,
     /// typically generated by `#[derive(LintDiagnostic)]`).
+    #[track_caller]
     pub fn emit_spanned_lint(
         self,
         lint: &'static Lint,
@@ -2111,6 +2112,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Emit a lint from a lint struct (some type that implements `DecorateLint`, typically
     /// generated by `#[derive(LintDiagnostic)]`).
+    #[track_caller]
     pub fn emit_lint(
         self,
         lint: &'static Lint,

compiler/rustc_mir_build/src/build/custom/parse.rs

@@ -36,6 +36,7 @@ macro_rules! parse_by_kind {
         let expr = &$self.thir[expr_id];
         debug!("Trying to parse {:?} as {}", expr.kind, $expected);
         let $expr_name = expr;
+        #[allow(unreachable_patterns)]
         match &expr.kind {
             $(
                 ExprKind::Call { ty, fun: _, args: $args, .. } if {
@@ -50,7 +51,6 @@ macro_rules! parse_by_kind {
             $(
                 $pat => $expr,
             )*
-            #[allow(unreachable_patterns)]
             _ => return Err($self.expr_error(expr_id, $expected))
         }
     }};

compiler/rustc_mir_build/src/errors.rs

@@ -465,14 +465,29 @@ pub struct NonConstPath {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(mir_build_unreachable_pattern)]
-pub struct UnreachablePattern {
-    #[label]
-    pub span: Option<Span>,
+#[diag(mir_build_unreachable_patterns)]
+pub struct UnreachablePatterns {
+    #[subdiagnostic]
+    pub unreachable_arms: Vec<UnreachableArm>,
+    pub count: usize,
     #[label(catchall_label)]
     pub catchall: Option<Span>,
 }
 
+#[derive(Subdiagnostic)]
+pub enum UnreachableArm {
+    #[label(mir_build_never_executed)]
+    NeverExecuted {
+        #[primary_span]
+        span: Span,
+    },
+    #[label(mir_build_unreachable_pattern)]
+    PatternUnreachable {
+        #[primary_span]
+        span: Span,
+    },
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_const_pattern_depends_on_generic_parameter)]
 pub struct ConstPatternDependsOnGenericParameter {

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -207,10 +207,17 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
         match source {
             // Don't report arm reachability of desugared `match $iter.into_iter() { iter => .. }`
             // when the iterator is an uninhabited type. unreachable_code will trigger instead.
-            hir::MatchSource::ForLoopDesugar if arms.len() == 1 => {}
-            hir::MatchSource::ForLoopDesugar
-            | hir::MatchSource::Normal
-            | hir::MatchSource::FormatArgs => report_arm_reachability(&cx, &report),
+            hir::MatchSource::ForLoopDesugar if arms.len() == 1 => {},
+            hir::MatchSource::ForLoopDesugar | hir::MatchSource::FormatArgs => {
+                report_let_reachability(scrut.hir_id, &cx, &report)
+            },
+            hir::MatchSource::Normal => {
+                if let ty::Adt(def, _) = scrut_ty.kind() && def.is_enum() && def.variants().is_empty() {
+                    report_empty_enum_arms(scrut.hir_id, hir_arms, &cx)
+                } else {
+                    report_arm_reachability(scrut.hir_id, hir_arms, &cx, &report)
+                }
+            }
             // Unreachable patterns in try and await expressions occur when one of
             // the arms are an uninhabited type. Which is OK.
             hir::MatchSource::AwaitDesugar | hir::MatchSource::TryDesugar => {}
@@ -520,15 +527,6 @@ fn pat_is_catchall(pat: &DeconstructedPat<'_, '_>) -> bool {
     }
 }
 
-fn unreachable_pattern(tcx: TyCtxt<'_>, span: Span, id: HirId, catchall: Option<Span>) {
-    tcx.emit_spanned_lint(
-        UNREACHABLE_PATTERNS,
-        id,
-        span,
-        UnreachablePattern { span: if catchall.is_some() { Some(span) } else { None }, catchall },
-    );
-}
-
 fn irrefutable_let_pattern(tcx: TyCtxt<'_>, id: HirId, span: Span) {
     let source = let_source(tcx, id);
     irrefutable_let_patterns(tcx, id, source, 1, span);
@@ -561,43 +559,127 @@ fn is_let_irrefutable<'p, 'tcx>(
     pat_id: HirId,
     pat: &'p DeconstructedPat<'p, 'tcx>,
 ) -> bool {
-    let arms = [MatchArm { pat, hir_id: pat_id, has_guard: false }];
-    let report = compute_match_usefulness(&cx, &arms, pat_id, pat.ty());
+    let arms = MatchArm { pat, hir_id: pat_id, has_guard: false };
+    let report = compute_match_usefulness(&cx, &[arms], pat_id, pat.ty());
 
     // Report if the pattern is unreachable, which can only occur when the type is uninhabited.
     // This also reports unreachable sub-patterns though, so we can't just replace it with an
     // `is_uninhabited` check.
-    report_arm_reachability(&cx, &report);
+    report_let_reachability(pat_id, &cx, &report);
 
     // If the list of witnesses is empty, the match is exhaustive,
     // i.e. the `if let` pattern is irrefutable.
     report.non_exhaustiveness_witnesses.is_empty()
 }
 
+/// Report unreachable let branches, if any.
+fn report_let_reachability<'p, 'tcx>(
+    scrut: HirId,
+    cx: &MatchCheckCtxt<'p, 'tcx>,
+    report: &UsefulnessReport<'p, 'tcx>,
+) {
+    let mut unreachable_arms = Vec::new();
+    let mut spans = Vec::new();
+
+    for (arm, is_useful) in &report.arm_usefulness {
+        match is_useful {
+            Reachability::Unreachable => {
+                spans.push(arm.pat.span());
+                unreachable_arms.push(UnreachableArm::PatternUnreachable { span: arm.pat.span() });
+            }
+            // The arm is reachable, but contains unreachable subpatterns (from or-patterns).
+            Reachability::Reachable(unreachables) => {
+                for &span in unreachables {
+                    spans.push(span);
+                    unreachable_arms.push(UnreachableArm::PatternUnreachable { span });
+                }
+            }
+        }
+    }
+
+    if !unreachable_arms.is_empty() {
+        cx.tcx.emit_spanned_lint(
+            UNREACHABLE_PATTERNS,
+            scrut,
+            spans,
+            UnreachablePatterns { count: unreachable_arms.len(), unreachable_arms, catchall: None },
+        );
+    }
+}
+
 /// Report unreachable arms, if any.
 fn report_arm_reachability<'p, 'tcx>(
+    scrut: HirId,
+    hir_arms: &'tcx [hir::Arm<'tcx>],
     cx: &MatchCheckCtxt<'p, 'tcx>,
     report: &UsefulnessReport<'p, 'tcx>,
 ) {
-    use Reachability::*;
-    let mut catchall = None;
-    for (arm, is_useful) in report.arm_usefulness.iter() {
+    let mut unreachable_arms = Vec::new();
+
+    let mut spans = Vec::new();
+    for ((_, is_useful), hir::Arm { span, .. }) in report.arm_usefulness.iter().zip(hir_arms) {
         match is_useful {
-            Unreachable => unreachable_pattern(cx.tcx, arm.pat.span(), arm.hir_id, catchall),
-            Reachable(unreachables) if unreachables.is_empty() => {}
+            Reachability::Unreachable => {
+                spans.push(*span);
+                unreachable_arms.push(UnreachableArm::NeverExecuted { span: *span });
+            }
             // The arm is reachable, but contains unreachable subpatterns (from or-patterns).
-            Reachable(unreachables) => {
-                let mut unreachables = unreachables.clone();
-                // Emit lints in the order in which they occur in the file.
-                unreachables.sort_unstable();
-                for span in unreachables {
-                    unreachable_pattern(cx.tcx, span, arm.hir_id, None);
+            Reachability::Reachable(unreachables) => {
+                for &span in unreachables {
+                    spans.push(span);
+                    unreachable_arms.push(UnreachableArm::PatternUnreachable { span });
                 }
             }
         }
-        if !arm.has_guard && catchall.is_none() && pat_is_catchall(arm.pat) {
-            catchall = Some(arm.pat.span());
-        }
+    }
+
+    // Mention it if there's a catch-all arm, but not if it's the last one.
+    let catchall = if let [arms @ .., _last] = &*report.arm_usefulness {
+        arms.iter()
+            .filter_map(|(arm, _)| {
+                (!arm.has_guard && pat_is_catchall(arm.pat)).then(|| arm.pat.span())
+            })
+            .next()
+    } else {
+        None
+    };
+    if let Some(span) = catchall {
+        spans.push(span);
+    }
+
+    if !unreachable_arms.is_empty() {
+        cx.tcx.emit_spanned_lint(
+            UNREACHABLE_PATTERNS,
+            scrut,
+            spans,
+            UnreachablePatterns { count: unreachable_arms.len(), unreachable_arms, catchall },
+        );
+    }
+}
+
+/// Report every arm matching on , if any.
+fn report_empty_enum_arms<'p, 'tcx>(
+    scrut: HirId,
+    hir_arms: &'tcx [hir::Arm<'tcx>],
+    cx: &MatchCheckCtxt<'p, 'tcx>,
+) {
+    let mut spans = Vec::new();
+
+    let unreachable_arms = hir_arms
+        .iter()
+        .map(|arm| {
+            spans.push(arm.span);
+            UnreachableArm::NeverExecuted { span: arm.span }
+        })
+        .collect::<Vec<_>>();
+
+    if !unreachable_arms.is_empty() {
+        cx.tcx.emit_spanned_lint(
+            UNREACHABLE_PATTERNS,
+            scrut,
+            spans,
+            UnreachablePatterns { count: unreachable_arms.len(), unreachable_arms, catchall: None },
+        );
     }
 }
 

tests/ui/consts/const_in_pattern/issue-78057.stderr

@@ -5,13 +5,13 @@ LL |         FOO => {},
    |         ^^^
 
 error: unreachable pattern
-  --> $DIR/issue-78057.rs:14:9
+  --> $DIR/issue-78057.rs:12:9
    |
 LL |         FOO => {},
-   |         --- matches any value
+   |         ^^^ this pattern is irrefutable; subsequent arms are never executed
 LL |
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^^^^^^^ this arm is never executed
    |
 note: the lint level is defined here
   --> $DIR/issue-78057.rs:1:9

tests/ui/consts/packed_pattern.stderr

@@ -2,7 +2,7 @@ warning: unreachable pattern
   --> $DIR/packed_pattern.rs:16:9
    |
 LL |         FOO => unreachable!(),
-   |         ^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^ this arm is never executed
    |
    = note: `#[warn(unreachable_patterns)]` on by default
 

tests/ui/consts/packed_pattern2.stderr

@@ -2,7 +2,7 @@ warning: unreachable pattern
   --> $DIR/packed_pattern2.rs:24:9
    |
 LL |         FOO => unreachable!(),
-   |         ^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^ this arm is never executed
    |
    = note: `#[warn(unreachable_patterns)]` on by default
 

tests/ui/error-codes/E0001.stderr

@@ -2,7 +2,7 @@ error: unreachable pattern
   --> $DIR/E0001.rs:8:9
    |
 LL |         _ => {/* ... */}
-   |         ^
+   |         ^^^^^^^^^^^^^^^^ this arm is never executed
    |
 note: the lint level is defined here
   --> $DIR/E0001.rs:1:9

tests/ui/lint/issue-30302.stderr

@@ -7,13 +7,13 @@ LL |         Nil => true,
    = note: `#[deny(bindings_with_variant_name)]` on by default
 
 error: unreachable pattern
-  --> $DIR/issue-30302.rs:15:9
+  --> $DIR/issue-30302.rs:13:9
    |
 LL |         Nil => true,
-   |         --- matches any value
+   |         ^^^ this pattern is irrefutable; subsequent arms are never executed
 LL |
 LL |         _ => false
-   |         ^ unreachable pattern
+   |         ^^^^^^^^^^ this arm is never executed
    |
 note: the lint level is defined here
   --> $DIR/issue-30302.rs:4:9