Add 'thir lifetime to RustMatchCheckCtxt

Author: Nadrieril

compiler/rustc_mir_build/src/errors.rs

@@ -453,8 +453,8 @@ pub enum UnusedUnsafeEnclosing {
     },
 }
 
-pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'tcx, 'm> {
-    pub cx: &'m RustcMatchCheckCtxt<'p, 'tcx>,
+pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'thir, 'tcx, 'm> {
+    pub cx: &'m RustcMatchCheckCtxt<'p, 'thir, 'tcx>,
     pub expr_span: Span,
     pub span: Span,
     pub ty: Ty<'tcx>,

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

@@ -82,7 +82,7 @@ struct MatchVisitor<'thir, 'p, 'tcx> {
     thir: &'thir Thir<'tcx>,
     lint_level: HirId,
     let_source: LetSource,
-    pattern_arena: &'p TypedArena<DeconstructedPat<'p, 'tcx>>,
+    pattern_arena: &'p TypedArena<DeconstructedPat<'p, 'thir, 'tcx>>,
     dropless_arena: &'p DroplessArena,
     /// Tracks if we encountered an error while checking this body. That the first function to
     /// report it stores it here. Some functions return `Result` to allow callers to short-circuit
@@ -275,9 +275,9 @@ impl<'thir, 'p, 'tcx> MatchVisitor<'thir, 'p, 'tcx> {
 
     fn lower_pattern(
         &mut self,
-        cx: &MatchCheckCtxt<'p, 'tcx>,
+        cx: &MatchCheckCtxt<'p, 'thir, 'tcx>,
         pat: &'thir Pat<'tcx>,
-    ) -> Result<&'p DeconstructedPat<'p, 'tcx>, ErrorGuaranteed> {
+    ) -> Result<&'p DeconstructedPat<'p, 'thir, 'tcx>, ErrorGuaranteed> {
         if let Err(err) = pat.pat_error_reported() {
             self.error = Err(err);
             Err(err)
@@ -370,7 +370,7 @@ impl<'thir, 'p, 'tcx> MatchVisitor<'thir, 'p, 'tcx> {
         whole_match_span: Option<Span>,
         scrutinee: Option<&Expr<'tcx>>,
         scrut_span: Span,
-    ) -> MatchCheckCtxt<'p, 'tcx> {
+    ) -> MatchCheckCtxt<'p, 'thir, 'tcx> {
         let refutable = match refutability {
             Irrefutable => false,
             Refutable => true,
@@ -550,7 +550,8 @@ impl<'thir, 'p, 'tcx> MatchVisitor<'thir, 'p, 'tcx> {
         pat: &'thir Pat<'tcx>,
         refutability: RefutableFlag,
         scrut: Option<&Expr<'tcx>>,
-    ) -> Result<(MatchCheckCtxt<'p, 'tcx>, UsefulnessReport<'p, 'tcx>), ErrorGuaranteed> {
+    ) -> Result<(MatchCheckCtxt<'p, 'thir, 'tcx>, UsefulnessReport<'p, 'thir, 'tcx>), ErrorGuaranteed>
+    {
         let cx = self.new_cx(refutability, None, scrut, pat.span);
         let pat = self.lower_pattern(&cx, pat)?;
         let arms = [MatchArm { pat, arm_data: self.lint_level, has_guard: false }];
@@ -836,9 +837,9 @@ fn report_irrefutable_let_patterns(
 }
 
 /// Report unreachable arms, if any.
-fn report_arm_reachability<'p, 'tcx>(
-    cx: &MatchCheckCtxt<'p, 'tcx>,
-    report: &UsefulnessReport<'p, 'tcx>,
+fn report_arm_reachability<'p, 'thir, 'tcx>(
+    cx: &MatchCheckCtxt<'p, 'thir, 'tcx>,
+    report: &UsefulnessReport<'p, 'thir, 'tcx>,
 ) {
     let report_unreachable_pattern = |span, hir_id, catchall: Option<Span>| {
         cx.tcx.emit_spanned_lint(
@@ -876,7 +877,7 @@ fn report_arm_reachability<'p, 'tcx>(
 }
 
 /// Checks for common cases of "catchall" patterns that may not be intended as such.
-fn pat_is_catchall(pat: &DeconstructedPat<'_, '_>) -> bool {
+fn pat_is_catchall(pat: &DeconstructedPat<'_, '_, '_>) -> bool {
     match pat.ctor() {
         Constructor::Wildcard => true,
         Constructor::Struct | Constructor::Ref => pat.iter_fields().all(|pat| pat_is_catchall(pat)),
@@ -885,12 +886,12 @@ fn pat_is_catchall(pat: &DeconstructedPat<'_, '_>) -> bool {
 }
 
 /// Report that a match is not exhaustive.
-fn report_non_exhaustive_match<'p, 'tcx>(
-    cx: &MatchCheckCtxt<'p, 'tcx>,
+fn report_non_exhaustive_match<'p, 'thir, 'tcx>(
+    cx: &MatchCheckCtxt<'p, 'thir, 'tcx>,
     thir: &Thir<'tcx>,
     scrut_ty: Ty<'tcx>,
     sp: Span,
-    witnesses: Vec<WitnessPat<'p, 'tcx>>,
+    witnesses: Vec<WitnessPat<'p, 'thir, 'tcx>>,
     arms: &[ArmId],
     expr_span: Span,
 ) -> ErrorGuaranteed {
@@ -1085,12 +1086,12 @@ fn report_non_exhaustive_match<'p, 'tcx>(
     err.emit()
 }
 
-fn joined_uncovered_patterns<'p, 'tcx>(
-    cx: &MatchCheckCtxt<'p, 'tcx>,
-    witnesses: &[WitnessPat<'p, 'tcx>],
+fn joined_uncovered_patterns<'p, 'thir, 'tcx>(
+    cx: &MatchCheckCtxt<'p, 'thir, 'tcx>,
+    witnesses: &[WitnessPat<'p, 'thir, 'tcx>],
 ) -> String {
     const LIMIT: usize = 3;
-    let pat_to_str = |pat: &WitnessPat<'p, 'tcx>| cx.hoist_witness_pat(pat).to_string();
+    let pat_to_str = |pat: &WitnessPat<'p, 'thir, 'tcx>| cx.hoist_witness_pat(pat).to_string();
     match witnesses {
         [] => bug!(),
         [witness] => format!("`{}`", cx.hoist_witness_pat(witness)),
@@ -1107,8 +1108,8 @@ fn joined_uncovered_patterns<'p, 'tcx>(
 }
 
 fn collect_non_exhaustive_tys<'tcx>(
-    cx: &MatchCheckCtxt<'_, 'tcx>,
-    pat: &WitnessPat<'_, 'tcx>,
+    cx: &MatchCheckCtxt<'_, '_, 'tcx>,
+    pat: &WitnessPat<'_, '_, 'tcx>,
     non_exhaustive_tys: &mut FxIndexSet<Ty<'tcx>>,
 ) {
     if matches!(pat.ctor(), Constructor::NonExhaustive) {
@@ -1127,7 +1128,7 @@ fn collect_non_exhaustive_tys<'tcx>(
 fn report_adt_defined_here<'tcx>(
     tcx: TyCtxt<'tcx>,
     ty: Ty<'tcx>,
-    witnesses: &[WitnessPat<'_, 'tcx>],
+    witnesses: &[WitnessPat<'_, '_, 'tcx>],
     point_at_non_local_ty: bool,
 ) -> Option<AdtDefinedHere<'tcx>> {
     let ty = ty.peel_refs();
@@ -1149,10 +1150,10 @@ fn report_adt_defined_here<'tcx>(
     Some(AdtDefinedHere { adt_def_span, ty, variants })
 }
 
-fn maybe_point_at_variant<'a, 'p: 'a, 'tcx: 'p>(
+fn maybe_point_at_variant<'a, 'p: 'a, 'thir: 'p, 'tcx: 'thir>(
     tcx: TyCtxt<'tcx>,
     def: AdtDef<'tcx>,
-    patterns: impl Iterator<Item = &'a WitnessPat<'p, 'tcx>>,
+    patterns: impl Iterator<Item = &'a WitnessPat<'p, 'thir, 'tcx>>,
 ) -> Vec<Span> {
     let mut covered = vec![];
     for pattern in patterns {

compiler/rustc_pattern_analysis/src/errors.rs

@@ -19,10 +19,10 @@ pub struct Uncovered<'tcx> {
 }
 
 impl<'tcx> Uncovered<'tcx> {
-    pub fn new<'p>(
+    pub fn new<'p, 'thir>(
         span: Span,
-        cx: &RustcMatchCheckCtxt<'p, 'tcx>,
-        witnesses: Vec<WitnessPat<'p, 'tcx>>,
+        cx: &RustcMatchCheckCtxt<'p, 'thir, 'tcx>,
+        witnesses: Vec<WitnessPat<'p, 'thir, 'tcx>>,
     ) -> Self {
         let witness_1 = cx.hoist_witness_pat(witnesses.get(0).unwrap());
         Self {

compiler/rustc_pattern_analysis/src/lib.rs

@@ -107,11 +107,11 @@ pub struct MatchArm<'p, Cx: TypeCx> {
 /// The entrypoint for this crate. Computes whether a match is exhaustive and which of its arms are
 /// useful, and runs some lints.
 #[cfg(feature = "rustc")]
-pub fn analyze_match<'p, 'tcx>(
-    tycx: &RustcMatchCheckCtxt<'p, 'tcx>,
-    arms: &[rustc::MatchArm<'p, 'tcx>],
+pub fn analyze_match<'p, 'thir, 'tcx>(
+    tycx: &RustcMatchCheckCtxt<'p, 'thir, 'tcx>,
+    arms: &[rustc::MatchArm<'p, 'thir, 'tcx>],
     scrut_ty: Ty<'tcx>,
-) -> rustc::UsefulnessReport<'p, 'tcx> {
+) -> rustc::UsefulnessReport<'p, 'thir, 'tcx> {
     // Arena to store the extra wildcards we construct during analysis.
     let wildcard_arena = tycx.pattern_arena;
     let scrut_validity = ValidityConstraint::from_bool(tycx.known_valid_scrutinee);

compiler/rustc_pattern_analysis/src/lints.rs

@@ -28,12 +28,12 @@ use crate::TypeCx;
 ///
 /// This is not used in the main algorithm; only in lints.
 #[derive(Debug)]
-pub(crate) struct PatternColumn<'a, 'p, 'tcx> {
-    patterns: Vec<&'a DeconstructedPat<'p, 'tcx>>,
+pub(crate) struct PatternColumn<'a, 'p, 'thir, 'tcx> {
+    patterns: Vec<&'a DeconstructedPat<'p, 'thir, 'tcx>>,
 }
 
-impl<'a, 'p, 'tcx> PatternColumn<'a, 'p, 'tcx> {
-    pub(crate) fn new(arms: &[MatchArm<'p, 'tcx>]) -> Self {
+impl<'a, 'p, 'thir, 'tcx> PatternColumn<'a, 'p, 'thir, 'tcx> {
+    pub(crate) fn new(arms: &[MatchArm<'p, 'thir, 'tcx>]) -> Self {
         let mut patterns = Vec::with_capacity(arms.len());
         for arm in arms {
             if arm.pat.is_or_pat() {
@@ -48,7 +48,7 @@ impl<'a, 'p, 'tcx> PatternColumn<'a, 'p, 'tcx> {
     fn is_empty(&self) -> bool {
         self.patterns.is_empty()
     }
-    fn head_ty(&self, cx: MatchCtxt<'a, 'p, 'tcx>) -> Option<Ty<'tcx>> {
+    fn head_ty(&self, cx: MatchCtxt<'a, 'p, 'thir, 'tcx>) -> Option<Ty<'tcx>> {
         if self.patterns.len() == 0 {
             return None;
         }
@@ -59,12 +59,17 @@ impl<'a, 'p, 'tcx> PatternColumn<'a, 'p, 'tcx> {
     }
 
     /// Do constructor splitting on the constructors of the column.
-    fn analyze_ctors(&self, pcx: &PlaceCtxt<'_, 'p, 'tcx>) -> SplitConstructorSet<'p, 'tcx> {
+    fn analyze_ctors(
+        &self,
+        pcx: &PlaceCtxt<'_, 'p, 'thir, 'tcx>,
+    ) -> SplitConstructorSet<'p, 'thir, 'tcx> {
         let column_ctors = self.patterns.iter().map(|p| p.ctor());
         pcx.ctors_for_ty().split(pcx, column_ctors)
     }
 
-    fn iter<'b>(&'b self) -> impl Iterator<Item = &'a DeconstructedPat<'p, 'tcx>> + Captures<'b> {
+    fn iter<'b>(
+        &'b self,
+    ) -> impl Iterator<Item = &'a DeconstructedPat<'p, 'thir, 'tcx>> + Captures<'b> {
         self.patterns.iter().copied()
     }
 
@@ -75,9 +80,9 @@ impl<'a, 'p, 'tcx> PatternColumn<'a, 'p, 'tcx> {
     /// which may change the lengths.
     fn specialize(
         &self,
-        pcx: &PlaceCtxt<'a, 'p, 'tcx>,
-        ctor: &Constructor<'p, 'tcx>,
-    ) -> Vec<PatternColumn<'a, 'p, 'tcx>> {
+        pcx: &PlaceCtxt<'a, 'p, 'thir, 'tcx>,
+        ctor: &Constructor<'p, 'thir, 'tcx>,
+    ) -> Vec<PatternColumn<'a, 'p, 'thir, 'tcx>> {
         let arity = ctor.arity(pcx);
         if arity == 0 {
             return Vec::new();
@@ -113,10 +118,10 @@ impl<'a, 'p, 'tcx> PatternColumn<'a, 'p, 'tcx> {
 /// Traverse the patterns to collect any variants of a non_exhaustive enum that fail to be mentioned
 /// in a given column.
 #[instrument(level = "debug", skip(cx), ret)]
-fn collect_nonexhaustive_missing_variants<'a, 'p, 'tcx>(
-    cx: MatchCtxt<'a, 'p, 'tcx>,
-    column: &PatternColumn<'a, 'p, 'tcx>,
-) -> Vec<WitnessPat<'p, 'tcx>> {
+fn collect_nonexhaustive_missing_variants<'a, 'p, 'thir, 'tcx>(
+    cx: MatchCtxt<'a, 'p, 'thir, 'tcx>,
+    column: &PatternColumn<'a, 'p, 'thir, 'tcx>,
+) -> Vec<WitnessPat<'p, 'thir, 'tcx>> {
     let Some(ty) = column.head_ty(cx) else {
         return Vec::new();
     };
@@ -160,13 +165,13 @@ fn collect_nonexhaustive_missing_variants<'a, 'p, 'tcx>(
     witnesses
 }
 
-pub(crate) fn lint_nonexhaustive_missing_variants<'a, 'p, 'tcx>(
-    cx: MatchCtxt<'a, 'p, 'tcx>,
-    arms: &[MatchArm<'p, 'tcx>],
-    pat_column: &PatternColumn<'a, 'p, 'tcx>,
+pub(crate) fn lint_nonexhaustive_missing_variants<'a, 'p, 'thir, 'tcx>(
+    cx: MatchCtxt<'a, 'p, 'thir, 'tcx>,
+    arms: &[MatchArm<'p, 'thir, 'tcx>],
+    pat_column: &PatternColumn<'a, 'p, 'thir, 'tcx>,
     scrut_ty: Ty<'tcx>,
 ) {
-    let rcx: &RustcMatchCheckCtxt<'_, '_> = cx.tycx;
+    let rcx: &RustcMatchCheckCtxt<'_, '_, '_> = cx.tycx;
     if !matches!(
         rcx.tcx.lint_level_at_node(NON_EXHAUSTIVE_OMITTED_PATTERNS, rcx.match_lint_level).0,
         rustc_session::lint::Level::Allow
@@ -214,15 +219,15 @@ pub(crate) fn lint_nonexhaustive_missing_variants<'a, 'p, 'tcx>(
 
 /// Traverse the patterns to warn the user about ranges that overlap on their endpoints.
 #[instrument(level = "debug", skip(cx))]
-pub(crate) fn lint_overlapping_range_endpoints<'a, 'p, 'tcx>(
-    cx: MatchCtxt<'a, 'p, 'tcx>,
-    column: &PatternColumn<'a, 'p, 'tcx>,
+pub(crate) fn lint_overlapping_range_endpoints<'a, 'p, 'thir, 'tcx>(
+    cx: MatchCtxt<'a, 'p, 'thir, 'tcx>,
+    column: &PatternColumn<'a, 'p, 'thir, 'tcx>,
 ) {
     let Some(ty) = column.head_ty(cx) else {
         return;
     };
     let pcx = &PlaceCtxt::new_dummy(cx, ty);
-    let rcx: &RustcMatchCheckCtxt<'_, '_> = cx.tycx;
+    let rcx: &RustcMatchCheckCtxt<'_, '_, '_> = cx.tycx;
 
     let set = column.analyze_ctors(pcx);