Impl reachable_patterns lint in usefulness checking

Some usefulness code altered

Author: DevinR528

compiler/rustc_lint/src/reachable_patterns.rs

@@ -50,8 +50,7 @@ impl<'tcx> LateLintPass<'tcx> for ReachablePattern {
             MatchSource::Normal,
         ) = &expr.kind
         {
-            if !arms.is_empty() {
-                // TODO: can this ever not be there?
+            if !arms.is_empty() && false {
                 if let Some(ty::Adt(def, _)) =
                     cx.maybe_typeck_results().map(|r| r.expr_ty(e).kind())
                 {
@@ -148,7 +147,7 @@ fn has_reachable_attr(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
             && attr.meta().map_or(false, |a| {
                 a.meta_item_list()
                     .and_then(|s| s.first().cloned())
-                    .map_or(false, |a| a.has_name(sym::reachable))
+                    .map_or(false, |a| a.has_name(sym::reachable_patterns))
             })
     })
 }

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

@@ -1,6 +1,6 @@
 use super::usefulness::{
-    compute_match_usefulness, expand_pattern, is_wildcard, MatchArm, MatchCheckCtxt, Reachability,
-    UsefulnessReport,
+    compute_match_usefulness, expand_pattern, is_wildcard, MatchArm, MatchCheckCtxt,
+    NonExhaustiveReachable, Reachability, UsefulnessReport,
 };
 use super::{PatCtxt, PatternError};
 
@@ -14,8 +14,8 @@ use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{HirId, Pat};
 use rustc_middle::thir::PatKind;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_session::lint::builtin::BINDINGS_WITH_VARIANT_NAME;
 use rustc_session::lint::builtin::{IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS};
+use rustc_session::lint::{builtin::BINDINGS_WITH_VARIANT_NAME, Level};
 use rustc_session::parse::feature_err;
 use rustc_session::Session;
 use rustc_span::{sym, Span};
@@ -74,6 +74,7 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
         };
         self.check_irrefutable(&loc.pat, msg, sp);
         self.check_patterns(&loc.pat);
+        check_for_reachable_patterns_in_non_exhaustive(self, &loc.pat, loc.hir_id);
     }
 
     fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
@@ -121,7 +122,7 @@ impl PatCtxt<'_, '_> {
 }
 
 impl<'tcx> MatchVisitor<'_, 'tcx> {
-    fn check_patterns(&mut self, pat: &Pat<'_>) {
+    fn check_patterns(&mut self, pat: &'tcx Pat<'_>) {
         pat.walk_always(|pat| check_borrow_conflicts_in_at_patterns(self, pat));
         if !self.tcx.features().bindings_after_at {
             check_legality_of_bindings_in_at_patterns(self, pat);
@@ -183,9 +184,10 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
 
         let arms: Vec<_> = arms
             .iter()
-            .map(|hir::Arm { pat, guard, .. }| MatchArm {
+            .map(|hir::Arm { pat, guard, hir_id, .. }| MatchArm {
                 pat: self.lower_pattern(&mut cx, pat, &mut have_errors).0,
                 hir_id: pat.hir_id,
+                arm_hir_id: Some(*hir_id),
                 has_guard: guard.is_some(),
             })
             .collect();
@@ -206,16 +208,24 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
         // since an empty matrix can occur when there are arms, if those arms all have guards.
         let is_empty_match = arms.is_empty();
         let witnesses = report.non_exhaustiveness_witnesses;
+        let reachable = report.reachable;
         if !witnesses.is_empty() {
-            non_exhaustive_match(&cx, scrut_ty, scrut.span, witnesses, is_empty_match);
+            if let NonExhaustiveReachable::Lint { wildcard_span: Some(sp), level: Some(level) } =
+                reachable
+            {
+                non_exhaustive_reachable_match(&cx, scrut_ty, scrut.span, sp, witnesses, level);
+            } else {
+                non_exhaustive_match(&cx, scrut_ty, scrut.span, witnesses, is_empty_match);
+            }
         }
     }
 
     fn check_irrefutable(&self, pat: &'tcx Pat<'tcx>, origin: &str, sp: Option<Span>) {
         let mut cx = self.new_cx(pat.hir_id);
 
         let (pattern, pattern_ty) = self.lower_pattern(&mut cx, pat, &mut false);
-        let arms = vec![MatchArm { pat: pattern, hir_id: pat.hir_id, has_guard: false }];
+        let arms =
+            vec![MatchArm { pat: pattern, hir_id: pat.hir_id, arm_hir_id: None, has_guard: false }];
         let report = compute_match_usefulness(&cx, &arms, pat.hir_id, pattern_ty);
 
         // Note: we ignore whether the pattern is unreachable (i.e. whether the type is empty). We
@@ -343,6 +353,37 @@ fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor<'_, '_>, pat: &Pa
     });
 }
 
+fn check_for_reachable_patterns_in_non_exhaustive<'p, 'tcx>(
+    cx: &MatchVisitor<'p, 'tcx>,
+    pat: &'tcx Pat<'tcx>,
+    attr_hir_id: HirId,
+) {
+    if let hir::PatKind::Struct(_, _fields @ [_, ..], true) = &pat.kind {
+        if let ty::Adt(def, _) = cx.typeck_results.pat_ty(pat).kind() {
+            if let Some(var) = def.variants.iter().next() {
+                if var.is_field_list_non_exhaustive() && !def.did.is_local() {
+                    let mut mcx = cx.new_cx(pat.hir_id);
+
+                    let (pattern, pattern_ty) = cx.lower_pattern(&mut mcx, pat, &mut false);
+                    let arms = vec![MatchArm {
+                        pat: pattern,
+                        hir_id: pat.hir_id,
+                        arm_hir_id: Some(attr_hir_id),
+                        has_guard: false,
+                    }];
+                    let report = compute_match_usefulness(&mcx, &arms, pat.hir_id, pattern_ty);
+                    println!("{:?}", report);
+                    // let missing = get_missing_fields(fields, &var.fields);
+                    // if !missing.is_empty() {
+                    //     let last = fields.last().unwrap().span;
+                    //     lint(cx, pat.span, last, missing)
+                    // }
+                }
+            }
+        }
+    }
+}
+
 /// Checks for common cases of "catchall" patterns that may not be intended as such.
 fn pat_is_catchall(pat: &super::Pat<'_>) -> bool {
     use PatKind::*;
@@ -400,7 +441,7 @@ fn check_if_let_guard<'p, 'tcx>(
     pat: &'p super::Pat<'tcx>,
     pat_id: HirId,
 ) {
-    let arms = [MatchArm { pat, hir_id: pat_id, has_guard: false }];
+    let arms = [MatchArm { pat, hir_id: pat_id, arm_hir_id: None, has_guard: false }];
     let report = compute_match_usefulness(&cx, &arms, pat_id, pat.ty);
     report_arm_reachability(&cx, &report, hir::MatchSource::IfLetGuardDesugar);
 
@@ -502,6 +543,10 @@ fn non_exhaustive_match<'p, 'tcx>(
         _ => false,
     };
 
+    if is_variant_list_non_exhaustive {
+        println!("{:?}", witnesses);
+    }
+
     adt_defined_here(cx, &mut err, scrut_ty, &witnesses);
     err.help(
         "ensure that all possible cases are being handled, \
@@ -538,6 +583,38 @@ fn non_exhaustive_match<'p, 'tcx>(
     err.emit();
 }
 
+/// Report that a match of a non_exhaustive type marked with `reachable_patterns` is not
+/// exhaustive enough.
+fn non_exhaustive_reachable_match<'p, 'tcx>(
+    cx: &MatchCheckCtxt<'p, 'tcx>,
+    scrut_ty: Ty<'tcx>,
+    sp: Span,
+    _wild_sp: Span,
+    witnesses: Vec<super::Pat<'tcx>>,
+    _level: Level,
+) {
+    let joined_patterns = joined_uncovered_patterns(&witnesses);
+
+    let mut warn = cx
+        .tcx
+        .sess
+        .struct_span_err(sp, &format!("reachable-patterns: {} not covered", joined_patterns));
+    warn.span_label(sp, pattern_not_covered_label(&witnesses, &joined_patterns));
+
+    // IS THIS HELPFUL
+    // adt_defined_here(cx, &mut warn, scrut_ty, &witnesses);
+
+    warn.help(
+        "ensure that all possible cases are being handled by adding the suggested match arms",
+    );
+    warn.note(&format!(
+        "the matched value is of type `{}` and the wildcard has the `reachable_patterns` attribute",
+        scrut_ty,
+    ));
+
+    warn.emit();
+}
+
 fn joined_uncovered_patterns(witnesses: &[super::Pat<'_>]) -> String {
     const LIMIT: usize = 3;
     match witnesses {

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

@@ -605,6 +605,17 @@ pub(super) enum Constructor<'tcx> {
     /// Fake extra constructor for enums that aren't allowed to be matched exhaustively. Also used
     /// for those types for which we cannot list constructors explicitly, like `f64` and `str`.
     NonExhaustive,
+    // /// Used to distinguish between patterns of non_exhaustive and non_exhaustive with
+    // /// the reachable_patterns lint enabled.
+    // ///
+    // /// ```rust
+    // /// match NonExhaustiveEnum {
+    // ///     Variant1 => {},
+    // ///     #[warn(reachable_patterns)]
+    // ///     _ => {},
+    // /// }
+    // /// ```
+    // NonExhaustiveReachable,
     /// Stands for constructors that are not seen in the matrix, as explained in the documentation
     /// for [`SplitWildcard`].
     Missing,
@@ -753,7 +764,8 @@ impl<'tcx> Constructor<'tcx> {
     pub(super) fn is_covered_by<'p>(&self, pcx: PatCtxt<'_, 'p, 'tcx>, other: &Self) -> bool {
         // This must be kept in sync with `is_covered_by_any`.
         match (self, other) {
-            // Wildcards cover anything
+            // We ignore the wildcard when this lint is enabled
+            // (NonExhaustiveReachable, Wildcard) => false,
             (_, Wildcard) => true,
             // The missing ctors are not covered by anything in the matrix except wildcards.
             (Missing | Wildcard, _) => false,
@@ -829,6 +841,7 @@ impl<'tcx> Constructor<'tcx> {
                 .any(|other| slice.is_covered_by(other)),
             // This constructor is never covered by anything else
             NonExhaustive => false,
+            // NonExhaustiveReachable => false,
             Str(..) | FloatRange(..) | Opaque | Missing | Wildcard => {
                 span_bug!(pcx.span, "found unexpected ctor in all_ctors: {:?}", self)
             }
@@ -862,6 +875,8 @@ pub(super) struct SplitWildcard<'tcx> {
 impl<'tcx> SplitWildcard<'tcx> {
     pub(super) fn new<'p>(pcx: PatCtxt<'_, 'p, 'tcx>) -> Self {
         debug!("SplitWildcard::new({:?})", pcx.ty);
+        println!("SplitWildcard::new({:?})", pcx.ty);
+
         let cx = pcx.cx;
         let make_range = |start, end| {
             IntRange(
@@ -919,7 +934,9 @@ impl<'tcx> SplitWildcard<'tcx> {
                     && !cx.tcx.features().exhaustive_patterns
                     && !pcx.is_top_level;
 
-                if is_secretly_empty || is_declared_nonexhaustive {
+                if is_declared_nonexhaustive && pcx.non_exhaustive_reachable {
+                    def.variants.indices().map(|idx| Variant(idx)).collect()
+                } else if is_secretly_empty || is_declared_nonexhaustive {
                     smallvec![NonExhaustive]
                 } else if cx.tcx.features().exhaustive_patterns {
                     // If `exhaustive_patterns` is enabled, we exclude variants known to be
@@ -975,6 +992,9 @@ impl<'tcx> SplitWildcard<'tcx> {
             // This type is one for which we cannot list constructors, like `str` or `f64`.
             _ => smallvec![NonExhaustive],
         };
+
+        println!("{:?}", all_ctors);
+
         SplitWildcard { matrix_ctors: Vec::new(), all_ctors }
     }
 
@@ -1189,15 +1209,18 @@ impl<'p, 'tcx> Fields<'p, 'tcx> {
     /// This is roughly the inverse of `specialize_constructor`.
     ///
     /// Examples:
-    /// `ctor`: `Constructor::Single`
-    /// `ty`: `Foo(u32, u32, u32)`
-    /// `self`: `[10, 20, _]`
+    ///
+    /// ```text
+    /// ctor: `Constructor::Single`
+    /// ty: `Foo(u32, u32, u32)`
+    /// self: `[10, 20, _]`
     /// returns `Foo(10, 20, _)`
     ///
-    /// `ctor`: `Constructor::Variant(Option::Some)`
-    /// `ty`: `Option<bool>`
-    /// `self`: `[false]`
+    /// ctor: `Constructor::Variant(Option::Some)`
+    /// ty: `Option<bool>`
+    /// self: `[false]`
     /// returns `Some(false)`
+    /// ```
     pub(super) fn apply(self, pcx: PatCtxt<'_, 'p, 'tcx>, ctor: &Constructor<'tcx>) -> Pat<'tcx> {
         let subpatterns_and_indices = self.patterns_and_indices();
         let mut subpatterns = subpatterns_and_indices.iter().map(|&(_, p)| p).cloned();
@@ -1263,6 +1286,7 @@ impl<'p, 'tcx> Fields<'p, 'tcx> {
             &FloatRange(lo, hi, end) => PatKind::Range(PatRange { lo, hi, end }),
             IntRange(range) => return range.to_pat(pcx.cx.tcx, pcx.ty),
             NonExhaustive => PatKind::Wild,
+            // NonExhaustiveReachable => PatKind::Wild,
             Wildcard => return Pat::wildcard_from_ty(pcx.ty),
             Opaque => bug!("we should not try to apply an opaque constructor"),
             Missing => bug!(