Store match pairs indexed by their place

Author: Nadrieril

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

@@ -946,7 +946,7 @@ struct FlatPat<'pat, 'tcx> {
     /// To match the pattern, all of these must be satisfied...
     // Invariant: all the `MatchPair`s are recursively simplified.
     // Invariant: or-patterns must be sorted to the end.
-    match_pairs: Vec<MatchPair<'pat, 'tcx>>,
+    match_pairs: FxIndexMap<Place<'tcx>, MatchPair<'pat, 'tcx>>,
 
     /// ...these bindings established...
     bindings: Vec<Binding<'tcx>>,
@@ -974,6 +974,8 @@ impl<'tcx, 'pat> FlatPat<'pat, 'tcx> {
             && ascriptions.is_empty()
             && match_pairs.iter().all(|mp| mp.is_simple());
 
+        let match_pairs = match_pairs.into_iter().map(|mp| (mp.place.unwrap(), mp)).collect();
+
         FlatPat { span: pattern.span, match_pairs, bindings, ascriptions, simple }
     }
 }
@@ -989,7 +991,7 @@ struct Candidate<'pat, 'tcx> {
     /// All of these must be satisfied...
     // Invariant: all the `MatchPair`s are recursively simplified.
     // Invariant: or-patterns must be sorted at the end.
-    match_pairs: Vec<MatchPair<'pat, 'tcx>>,
+    match_pairs: FxIndexMap<Place<'tcx>, MatchPair<'pat, 'tcx>>,
 
     /// ...these bindings established...
     // Invariant: not mutated after candidate creation.
@@ -1283,8 +1285,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) {
         let mut split_or_candidate = false;
         for candidate in &mut *candidates {
-            if let [MatchPair { test_case: TestCase::Or { pats, .. }, .. }] =
-                &*candidate.match_pairs
+            if candidate.match_pairs.len() == 1
+                && let TestCase::Or { pats, .. } = &candidate.match_pairs[0].test_case
             {
                 // Split a candidate in which the only match-pair is an or-pattern into multiple
                 // candidates. This is so that
@@ -1512,7 +1514,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             return;
         }
 
-        let first_match_pair = first_candidate.match_pairs.remove(0);
+        let first_match_pair = first_candidate.match_pairs.shift_remove_index(0).unwrap().1;
         let or_span = first_match_pair.pattern.span;
         let TestCase::Or { pats, simple } = first_match_pair.test_case else { unreachable!() };
         debug!("candidate={:#?}\npats={:#?}", first_candidate, pats);
@@ -1545,7 +1547,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let remaining_match_pairs = mem::take(&mut first_candidate.match_pairs);
             first_candidate.visit_leaves(|leaf_candidate| {
                 assert!(leaf_candidate.match_pairs.is_empty());
-                leaf_candidate.match_pairs.extend(remaining_match_pairs.iter().cloned());
+                leaf_candidate.match_pairs.clone_from(&remaining_match_pairs);
                 let or_start = leaf_candidate.pre_binding_block.unwrap();
                 // In a case like `(P | Q, R | S)`, if `P` succeeds and `R | S` fails, we know `(Q,
                 // R | S)` will fail too. If there is no guard, we skip testing of `Q` by branching

compiler/rustc_mir_build/src/build/matches/simplify.rs

@@ -113,8 +113,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .cloned()
             .map(|flat_pat| {
                 let mut candidate = Candidate::from_flat_pat(flat_pat, has_guard);
-                if let [MatchPair { test_case: TestCase::Or { pats, .. }, .. }] =
-                    &*candidate.match_pairs
+                if candidate.match_pairs.len() == 1
+                    && let TestCase::Or { pats, .. } = &candidate.match_pairs[0].test_case
                 {
                     candidate.subcandidates = self.create_or_subcandidates(pats, has_guard);
                     candidate.match_pairs.pop();

compiler/rustc_mir_build/src/build/matches/test.rs

@@ -484,11 +484,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // than one, but it'd be very unusual to have two sides that
         // both require tests; you'd expect one side to be simplified
         // away.)
-        let (match_pair_index, match_pair) = candidate
-            .match_pairs
-            .iter()
-            .enumerate()
-            .find(|&(_, mp)| mp.place == Some(test_place))?;
+        let match_pair = candidate.match_pairs.get(&test_place)?;
 
         let fully_matched;
         let ret = match (&test.kind, &match_pair.test_case) {
@@ -521,8 +517,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let is_conflicting_candidate = |candidate: &&mut Candidate<'_, 'tcx>| {
                     candidate
                         .match_pairs
-                        .iter()
-                        .any(|mp| mp.place == Some(test_place) && is_covering_range(&mp.test_case))
+                        .get(&test_place)
+                        .is_some_and(|mp| is_covering_range(&mp.test_case))
                 };
                 if sorted_candidates
                     .get(&TestBranch::Failure)
@@ -674,10 +670,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         if fully_matched {
             // Replace the match pair by its sub-pairs.
-            let match_pair = candidate.match_pairs.remove(match_pair_index);
-            candidate.match_pairs.extend(match_pair.subpairs);
+            let match_pair = candidate.match_pairs.shift_remove(&test_place).unwrap();
+            candidate
+                .match_pairs
+                .extend(match_pair.subpairs.into_iter().map(|mp| (mp.place.unwrap(), mp)));
             // Move or-patterns to the end.
-            candidate.match_pairs.sort_by_key(|pair| matches!(pair.test_case, TestCase::Or { .. }));
+            candidate
+                .match_pairs
+                .sort_by_cached_key(|_, pair| matches!(pair.test_case, TestCase::Or { .. }));
         }
 
         ret

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

@@ -293,7 +293,7 @@ impl<'a, 'b, 'tcx> FakeBorrowCollector<'a, 'b, 'tcx> {
         for binding in &candidate.bindings {
             self.visit_binding(binding);
         }
-        for match_pair in &candidate.match_pairs {
+        for match_pair in candidate.match_pairs.values() {
             self.visit_match_pair(match_pair);
         }
     }
@@ -302,7 +302,7 @@ impl<'a, 'b, 'tcx> FakeBorrowCollector<'a, 'b, 'tcx> {
         for binding in &flat_pat.bindings {
             self.visit_binding(binding);
         }
-        for match_pair in &flat_pat.match_pairs {
+        for match_pair in flat_pat.match_pairs.values() {
             self.visit_match_pair(match_pair);
         }
     }