Migrate usefulness.rs

compiler/rustc_mir_build/src/errors.rs

@@ -685,3 +685,17 @@ pub struct Overlap<'tcx> {
     pub span: Span,
     pub range: Pat<'tcx>,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(mir_build_non_exhaustive_omitted_pattern)]
+#[help]
+#[note]
+pub(crate) struct NonExhaustiveOmittedPattern<'tcx> {
+    pub scrut_ty: Ty<'tcx>,
+    #[label]
+    pub uncovered: Span,
+    pub count: usize,
+    pub witness_1: Pat<'tcx>,
+    pub witness_2: Pat<'tcx>,
+    pub witness_3: Pat<'tcx>,
+}

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

@@ -435,7 +435,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 _ => {
                     if !pointee_ty.is_sized(tcx, param_env) {
                         // `tcx.deref_mir_constant()` below will ICE with an unsized type
-                        // (except slices, which are handled in a separate arm above).                        
+                        // (except slices, which are handled in a separate arm above).
 
                         let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
                         tcx.sess.create_err(err).emit_unless(!self.include_lint_checks);

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

@@ -2,7 +2,7 @@
 
 mod check_match;
 mod const_to_pat;
-mod deconstruct_pat;
+pub(crate) mod deconstruct_pat;
 mod usefulness;
 
 pub(crate) use self::check_match::check_match;

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

@@ -291,9 +291,8 @@
 
 use self::ArmType::*;
 use self::Usefulness::*;
-
-use super::check_match::{joined_uncovered_patterns, pattern_not_covered_label};
 use super::deconstruct_pat::{Constructor, DeconstructedPat, Fields, SplitWildcard};
+use crate::errors::NonExhaustiveOmittedPattern;
 
 use rustc_data_structures::captures::Captures;
 
@@ -754,6 +753,23 @@ fn lint_non_exhaustive_omitted_patterns<'p, 'tcx>(
     hir_id: HirId,
     witnesses: Vec<DeconstructedPat<'p, 'tcx>>,
 ) {
+    let witness_1 = witnesses.get(0).unwrap().to_pat(cx);
+
+    cx.tcx.emit_spanned_lint(
+        NON_EXHAUSTIVE_OMITTED_PATTERNS,
+        hir_id,
+        sp,
+        NonExhaustiveOmittedPattern {
+            scrut_ty,
+            uncovered: sp,
+            count: witnesses.len(),
+            // Substitute dummy values if witnesses is smaller than 3.
+            witness_2: witnesses.get(1).map(|w| w.to_pat(cx)).unwrap_or_else(|| witness_1.clone()),
+            witness_3: witnesses.get(2).map(|w| w.to_pat(cx)).unwrap_or_else(|| witness_1.clone()),
+            witness_1,
+        },
+    );
+    /*
     cx.tcx.struct_span_lint_hir(NON_EXHAUSTIVE_OMITTED_PATTERNS, hir_id, sp, "some variants are not matched explicitly", |lint| {
         let joined_patterns = joined_uncovered_patterns(cx, &witnesses);
         lint.span_label(sp, pattern_not_covered_label(&witnesses, &joined_patterns));
@@ -766,6 +782,7 @@ fn lint_non_exhaustive_omitted_patterns<'p, 'tcx>(
         ));
         lint
     });
+    */
 }
 
 /// Algorithm from <http://moscova.inria.fr/~maranget/papers/warn/index.html>.