Emit a warning if a match is too complex and set the default trigger when complexity reaches 10_000_000

Author: GuillaumeGomez

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

@@ -405,7 +405,10 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         scrut_ty: Ty<'tcx>,
     ) -> Result<UsefulnessReport<'p, 'tcx>, ErrorGuaranteed> {
         let pattern_complexity_limit =
-            get_limit_size(cx.tcx.hir().krate_attrs(), cx.tcx.sess, sym::pattern_complexity);
+            get_limit_size(cx.tcx.hir().krate_attrs(), cx.tcx.sess, sym::pattern_complexity)
+                // Default value to emit the warning for "too complex" match. We picked it based on
+                // this crater run: <https://github.com/rust-lang/rust/pull/121979>.
+                .or(Some(10_000_000));
         let report =
             rustc_pattern_analysis::analyze_match(&cx, &arms, scrut_ty, pattern_complexity_limit)
                 .map_err(|err| {

compiler/rustc_pattern_analysis/messages.ftl

@@ -19,6 +19,10 @@ pattern_analysis_overlapping_range_endpoints = multiple patterns overlap on thei
     .label = ... with this range
     .note = you likely meant to write mutually exclusive ranges
 
+pattern_analysis_too_complex = this pattern-match expression is taking too long to analyze
+    .help = break it up into smaller `match`es and/or replace some patterns with guards
+    .note = match checking can take exponential time when many different fields of structs/tuples/arrays are involved
+
 pattern_analysis_uncovered = {$count ->
         [1] pattern `{$witness_1}`
         [2] patterns `{$witness_1}` and `{$witness_2}`

compiler/rustc_pattern_analysis/src/errors.rs

@@ -1,5 +1,5 @@
 use rustc_errors::{Diag, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic};
-use rustc_macros::{LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::thir::Pat;
 use rustc_middle::ty::Ty;
 use rustc_span::Span;
@@ -148,3 +148,12 @@ pub(crate) struct NonExhaustiveOmittedPatternLintOnArm {
     pub lint_level: &'static str,
     pub lint_name: &'static str,
 }
+
+#[derive(Diagnostic)]
+#[diag(pattern_analysis_too_complex)]
+#[help]
+#[note]
+pub(crate) struct TooComplex {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -913,7 +913,8 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
 
     fn complexity_exceeded(&self) -> Result<(), Self::Error> {
         let span = self.whole_match_span.unwrap_or(self.scrut_span);
-        Err(self.tcx.dcx().span_err(span, "reached pattern complexity limit"))
+        self.tcx.dcx().emit_warn(errors::TooComplex { span });
+        Ok(())
     }
 
     fn lint_non_contiguous_range_endpoints(

compiler/rustc_pattern_analysis/src/usefulness.rs

@@ -745,6 +745,8 @@ 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();
         }
         Ok(())