tweak

Author: Nadrieril

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

@@ -261,8 +261,7 @@ impl IntRange {
                 }
             }
             if !overlaps.is_empty() {
-                let overlap_as_pat =
-                    (IntRange { range: overlap..=overlap }).to_pat(pcx.cx.tcx, pcx.ty);
+                let overlap_as_pat = self.to_pat(pcx.cx.tcx, pcx.ty);
                 let overlaps: Vec<_> = overlaps
                     .into_iter()
                     .map(|span| Overlap { range: overlap_as_pat.clone(), span })
@@ -995,24 +994,23 @@ impl ConstructorSet {
             }
             ConstructorSet::Variants { variants, non_exhaustive } => {
                 let seen_set: FxHashSet<_> = seen.iter().map(|c| c.as_variant().unwrap()).collect();
-                let mut skipped_any_missing_variant = false;
+                let mut skipped_a_hidden_variant = false;
                 for variant in variants {
                     let ctor = Variant(*variant);
                     if seen_set.contains(&variant) {
                         present.push(ctor);
                     } else if ctor.is_doc_hidden_variant(pcx) || ctor.is_unstable_variant(pcx) {
-                        // We don't want to mention any variants that are `doc(hidden)` or
-                        // behind an unstable feature gate.
-                        skipped_any_missing_variant = true;
+                        // We don't want to mention any variants that are `doc(hidden)` or behind an
+                        // unstable feature gate if they aren't present in the match.
+                        skipped_a_hidden_variant = true;
                     } else {
                         missing.push(ctor);
                     }
                 }
-                if skipped_any_missing_variant {
-                    missing.push(Wildcard);
-                }
                 if *non_exhaustive {
                     missing.push(NonExhaustive);
+                } else if skipped_a_hidden_variant {
+                    missing.push(Wildcard);
                 }
             }
             ConstructorSet::Integers { range_1, range_2, non_exhaustive } => {

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

@@ -804,7 +804,6 @@ fn compute_usefulness<'p, 'tcx>(
     // For each constructor, we compute whether there's a value that starts with it that would
     // witness the usefulness of `v`.
     let mut ret = WitnessMatrix::new_empty();
-    let orig_column_count = matrix.column_count();
     for ctor in split_ctors {
         debug!("specialize({:?})", ctor);
         let mut spec_matrix = matrix.specialize_constructor(pcx, &ctor);
@@ -814,12 +813,12 @@ fn compute_usefulness<'p, 'tcx>(
         ret.extend(witnesses);
 
         // Lint on likely incorrect range patterns (#63987)
-        if spec_matrix.rows().len() >= 2 {
+        if spec_matrix.rows().len() >= 2 && matches!(ctor_set, ConstructorSet::Integers { .. }) {
             if let Constructor::IntRange(overlap_range) = &ctor {
                 // If two ranges overlap on their boundaries, that boundary will be found as a singleton
                 // range after splitting.
                 // We limit to a single column for now, see `lint_overlapping_range_endpoints`.
-                if overlap_range.is_singleton() && orig_column_count == 1 {
+                if overlap_range.is_singleton() && matrix.column_count() == 1 {
                     overlap_range.lint_overlapping_range_endpoints(
                         pcx,
                         spec_matrix.rows().map(|child_row| &matrix.rows[child_row.parent_row]).map(
@@ -831,7 +830,7 @@ fn compute_usefulness<'p, 'tcx>(
                                 )
                             },
                         ),
-                        orig_column_count,
+                        matrix.column_count(),
                     );
                 }
             }
@@ -847,7 +846,7 @@ fn compute_usefulness<'p, 'tcx>(
         {
             let patterns = missing_ctors
                 .iter()
-                // We want to list only real variants.
+                // We only list real variants.
                 .filter(|c| !(c.is_non_exhaustive() || c.is_wildcard()))
                 .cloned()
                 .map(|missing_ctor| DeconstructedPat::wild_from_ctor(pcx, missing_ctor))