merge guards early with metadata flags retention

Author: Human9000-bit

compiler/rustc_mir_build/src/builder/matches/match_pair.rs

@@ -88,12 +88,12 @@ impl<'tcx> FlatPat<'tcx> {
     fn from_inter_pat(inter_pat: InterPat<'tcx>) -> Self {
         let mut match_pairs = vec![];
         let mut guard_patterns = vec![];
-        if let Some(guard_pat) = inter_pat.guard_pat {
+        if let Some(guard_pat) = inter_pat.guard {
             guard_patterns.push(super::OrderedPatternData::One(guard_pat));
         }
         let mut extra_data = PatternExtraData {
             span: inter_pat.pattern_span,
-            guard_patterns,
+            guards: guard_patterns,
             is_never: inter_pat.is_never,
             ..Default::default()
         };
@@ -118,17 +118,14 @@ fn squash_inter_pat<'tcx>(
         or_subpats,
         ascriptions,
         binding,
-        guard_pat,
+        guard,
         pattern_span,
         is_never: _, // Not needed by `MatchPairTree` forests.
     } = inter_pat;
 
     // Type ascriptions can appear regardless of whether the node is an or-pattern.
     extra_data.ascriptions.extend(ascriptions);
-
-    guard_pat.inspect(|&guard_pat| {
-        extra_data.guard_patterns.push(super::OrderedPatternData::One(guard_pat));
-    });
+    guard.inspect(|&g| extra_data.guards.push(super::OrderedPatternData::One(g)));
 
     // Or and non-or patterns have very different handling.
     if let Some(or_subpats) = or_subpats {
@@ -150,8 +147,9 @@ fn squash_inter_pat<'tcx>(
             // FIXME(@dianne): this needs updating/removing if we always merge or-patterns
             extra_data.bindings.push(super::OrderedPatternData::FromOrPattern);
         }
-        if or_subpats.iter().any(|pat| !pat.extra_data.guard_patterns.is_empty()) {
-            extra_data.guard_patterns.push(super::OrderedPatternData::FromOrPattern);
+
+        if or_subpats.iter().any(|pat| !pat.extra_data.guards.is_empty()) {
+            extra_data.guards.push(super::OrderedPatternData::FromOrPattern);
         }
 
         match_pairs.push(MatchPairTree {
@@ -226,7 +224,7 @@ struct InterPat<'tcx> {
     /// Binding to establish for a [`PatKind::Binding`] node.
     binding: Option<super::Binding<'tcx>>,
 
-    guard_pat: Option<ExprId>,
+    guard: Option<ExprId>,
 
     /// Span field of the THIR pattern this node was created from.
     pattern_span: Span,
@@ -270,7 +268,7 @@ impl<'tcx> InterPat<'tcx> {
         let mut or_subpats = None;
         let mut ascriptions = vec![];
         let mut binding = None;
-        let mut guard_pat = None;
+        let mut guard = None;
 
         // Apply any type ascriptions to the value at `match_pair.place`.
         if let Some(place) = place
@@ -472,7 +470,7 @@ impl<'tcx> InterPat<'tcx> {
             PatKind::Guard { ref subpattern, condition } => {
                 let subpattern = InterPat::lower_thir_pat(cx, place_builder, subpattern);
                 subpats.push(subpattern);
-                guard_pat = Some(condition);
+                guard = Some(condition);
                 None
             }
 
@@ -496,7 +494,7 @@ impl<'tcx> InterPat<'tcx> {
             or_subpats,
             ascriptions,
             binding,
-            guard_pat,
+            guard,
             pattern_span: pattern.span,
             is_never,
         }

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -993,13 +993,13 @@ struct PatternExtraData<'tcx> {
     /// Whether this corresponds to a never pattern.
     is_never: bool,
 
-    /// [`ExprId`]s of subpattern conditions
-    guard_patterns: Vec<OrderedPatternData<ExprId>>,
+    /// [`ExprId`]s of guards that must be evaluated for this pattern
+    guards: Vec<OrderedPatternData<ExprId>>,
 }
 
 impl<'tcx> PatternExtraData<'tcx> {
     fn is_empty(&self) -> bool {
-        self.bindings.is_empty() && self.ascriptions.is_empty() && self.guard_patterns.is_empty()
+        self.bindings.is_empty() && self.ascriptions.is_empty() && self.guards.is_empty()
     }
 }
 
@@ -1087,8 +1087,12 @@ struct Candidate<'tcx> {
     /// `otherwise_block`.
     ///
     /// ---
-    /// For subcandidates, this is copied from the parent candidate
-    guards: Vec<ExprId>,
+    /// For subcandidates, this is copied from the parent candidate, so it indicates
+    /// whether the enclosing match arm has a guard.
+    under_guard: bool,
+
+    /// Whether subcandidates contain guards.
+    contains_guards: bool,
 
     /// Holds extra pattern data that was prepared by [`FlatPat`], including bindings and
     /// ascriptions that must be established if this candidate succeeds.
@@ -1125,20 +1129,24 @@ impl<'tcx> Candidate<'tcx> {
     ) -> Self {
         // Use `FlatPat` to build simplified match pairs, then immediately
         // incorporate them into a new candidate.
-        let flat_pat = FlatPat::new(place, pattern, cx);
-        let mut guards = Vec::new();
+        let mut flat_pat = FlatPat::new(place, pattern, cx);
+        let mut under_guard = false;
         if let HasMatchGuard::Yes(g) = guard {
-            guards.push(g);
+            under_guard = true;
+            flat_pat.extra_data.guards.push(OrderedPatternData::One(g));
         }
-        Self::from_flat_pat(flat_pat, guards)
+        Self::from_flat_pat(flat_pat, under_guard)
     }
 
     /// Incorporates an already-simplified [`FlatPat`] into a new candidate.
-    fn from_flat_pat(flat_pat: FlatPat<'tcx>, guards: Vec<ExprId>) -> Self {
+    fn from_flat_pat(flat_pat: FlatPat<'tcx>, under_guard: bool) -> Self {
+        let contains_guards = flat_pat.extra_data.guards.len() >= 2
+            || flat_pat.extra_data.guards.len() == 1 && !under_guard;
         let mut this = Candidate {
             match_pairs: flat_pat.match_pairs,
             extra_data: flat_pat.extra_data,
-            guards,
+            under_guard,
+            contains_guards,
             subcandidates: Vec::new(),
             or_span: None,
             otherwise_block: None,
@@ -1494,12 +1502,9 @@ impl<'tcx> MatchTreeSubBranch<'tcx> {
                 .chain(candidate.extra_data.ascriptions)
                 .collect(),
             guards: sub_branch_ordered_pat_data(
-                parent_data.iter().map(|parent| parent.guard_patterns.as_slice()),
-                &candidate.extra_data.guard_patterns,
-            )
-            .into_iter()
-            .chain(candidate.guards)
-            .collect(),
+                parent_data.iter().map(|parent| parent.guards.as_slice()),
+                &candidate.extra_data.guards,
+            ),
             is_never: candidate.extra_data.is_never,
         }
     }
@@ -1659,7 +1664,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             Exhaustive::No => Some(otherwise_block),
         };
         for candidate in candidates.iter_mut().rev() {
-            let has_guard = !candidate.guards.is_empty();
+            let has_guard = candidate.under_guard || candidate.contains_guards;
             candidate.visit_leaves_rev(|leaf_candidate| {
                 if let Some(next_candidate_start_block) = next_candidate_start_block {
                     let source_info = self.source_info(leaf_candidate.extra_data.span);
@@ -2004,10 +2009,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let TestableCase::Or { pats } = match_pair.testable_case else { bug!() };
         debug!("expanding or-pattern: candidate={:#?}\npats={:#?}", candidate, pats);
         candidate.or_span = Some(match_pair.pattern_span);
-        candidate.subcandidates = pats
-            .into_iter()
-            .map(|flat_pat| Candidate::from_flat_pat(flat_pat, candidate.guards.clone()))
-            .collect();
+        candidate.subcandidates =
+            pats.into_iter().map(|flat_pat| Candidate::from_flat_pat(flat_pat, false)).collect();
         candidate.subcandidates[0].false_edge_start_block = candidate.false_edge_start_block;
     }
 
@@ -2070,7 +2073,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// in match tree lowering.
     fn merge_trivial_subcandidates(&mut self, candidate: &mut Candidate<'tcx>) {
         assert!(!candidate.subcandidates.is_empty());
-        if !candidate.guards.is_empty() || !candidate.extra_data.guard_patterns.is_empty() {
+        if candidate.under_guard || candidate.contains_guards {
             // FIXME(or_patterns; matthewjasper) Don't give up if we have a guard.
             return;
         }
@@ -2190,7 +2193,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             // directly to `last_otherwise`. If there is a guard,
             // `leaf_candidate.otherwise_block` can be reached by guard failure as well, so we
             // can't skip `Q`.
-            let or_otherwise = if !leaf_candidate.guards.is_empty() {
+            let or_otherwise = if leaf_candidate.under_guard {
                 leaf_candidate.otherwise_block.unwrap()
             } else {
                 last_otherwise.unwrap()

compiler/rustc_mir_build/src/builder/matches/util.rs

@@ -72,7 +72,7 @@ pub(super) fn collect_fake_borrows<'tcx>(
     temp_span: Span,
     scrutinee_base: PlaceBase,
 ) -> Vec<(Place<'tcx>, Local, FakeBorrowKind)> {
-    if candidates.iter().all(|candidate| candidate.guards.is_empty()) {
+    if !candidates.iter().any(|candidate| candidate.under_guard || candidate.contains_guards) {
         // Fake borrows are only used when there is a guard.
         return Vec::new();
     }