Emit a warning if a match is too complex

Author: GuillaumeGomez

compiler/rustc_pattern_analysis/src/lib.rs

@@ -151,6 +151,8 @@ pub trait PatCx: Sized + fmt::Debug {
         _gapped_with: &[&DeconstructedPat<Self>],
     ) {
     }
+
+    fn too_complex_match(&self);
 }
 
 /// The arm of a match expression.

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -979,6 +979,11 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
             );
         }
     }
+
+    fn too_complex_match(&self) {
+        let span = self.whole_match_span.unwrap_or(self.scrut_span);
+        self.tcx.dcx().span_warn(span, "`match` is too complex");
+    }
 }
 
 /// Recursively expand this pattern into its subpatterns. Only useful for or-patterns.

compiler/rustc_pattern_analysis/src/usefulness.rs

@@ -736,6 +736,7 @@ struct UsefulnessCtxt<'a, Cx: PatCx> {
     useful_subpatterns: FxHashSet<PatId>,
     complexity_limit: Option<usize>,
     complexity_level: usize,
+    error_emitted: bool,
 }
 
 impl<'a, Cx: PatCx> UsefulnessCtxt<'a, Cx> {
@@ -745,8 +746,14 @@ impl<'a, Cx: PatCx> UsefulnessCtxt<'a, Cx> {
             .complexity_limit
             .is_some_and(|complexity_limit| complexity_limit < self.complexity_level)
         {
+            // We change it to `None` to prevent it from being called more than once.
+            self.complexity_limit = None;
             return self.tycx.complexity_exceeded();
         }
+        if !self.error_emitted && self.complexity_level > 10_000_000 {
+            self.tycx.too_complex_match();
+            self.error_emitted = true;
+        }
         Ok(())
     }
 }
@@ -1754,6 +1761,7 @@ pub fn compute_match_usefulness<'p, Cx: PatCx>(
         useful_subpatterns: FxHashSet::default(),
         complexity_limit,
         complexity_level: 0,
+        error_emitted: false,
     };
     let mut matrix = Matrix::new(arms, scrut_ty, scrut_validity);
     let non_exhaustiveness_witnesses = compute_exhaustiveness_and_usefulness(&mut cx, &mut matrix)?;