Pass Candidate exploded to simplify

Author: Nadrieril

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

@@ -1172,7 +1172,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // be a switch or pattern comparison.
         let mut split_or_candidate = false;
         for candidate in &mut *candidates {
-            split_or_candidate |= self.simplify_candidate(candidate);
+            split_or_candidate |= self.simplify_candidate(
+                &mut candidate.bindings,
+                &mut candidate.ascriptions,
+                &mut candidate.match_pairs,
+                &mut candidate.subcandidates,
+                candidate.has_guard,
+            );
         }
 
         ensure_sufficient_stack(|| {

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

@@ -16,6 +16,7 @@ use crate::build::expr::as_place::PlaceBuilder;
 use crate::build::matches::{Ascription, Binding, Candidate, MatchPair};
 use crate::build::Builder;
 use rustc_middle::thir::{self, *};
+use smallvec::SmallVec;
 
 use std::mem;
 
@@ -33,13 +34,36 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ///
     /// only generates a single switch. If this happens this method returns
     /// `true`.
-    #[instrument(skip(self, candidate), level = "debug")]
+    #[instrument(skip(self), level = "debug")]
     pub(super) fn simplify_candidate<'pat>(
         &mut self,
-        candidate: &mut Candidate<'pat, 'tcx>,
+        bindings: &mut Vec<Binding<'tcx>>,
+        ascriptions: &mut Vec<Ascription<'tcx>>,
+        match_pairs: &mut SmallVec<[MatchPair<'pat, 'tcx>; 1]>,
+        subcandidates: &mut Vec<Candidate<'pat, 'tcx>>,
+        has_guard: bool,
     ) -> bool {
+        self.simplify_candidate_inner(bindings, ascriptions, match_pairs);
+
+        if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place, .. }] =
+            &**match_pairs
+        {
+            *subcandidates = self.create_or_subcandidates(place, pats, has_guard);
+            match_pairs.pop();
+            return true;
+        }
+
+        false
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    pub(super) fn simplify_candidate_inner<'pat>(
+        &mut self,
+        candidate_bindings: &mut Vec<Binding<'tcx>>,
+        candidate_ascriptions: &mut Vec<Ascription<'tcx>>,
+        candidate_match_pairs: &mut SmallVec<[MatchPair<'pat, 'tcx>; 1]>,
+    ) {
         // repeatedly simplify match pairs until fixed point is reached
-        debug!("{candidate:#?}");
 
         // existing_bindings and new_bindings exists to keep the semantics in order.
         // Reversing the binding order for bindings after `@` changes the binding order in places
@@ -59,28 +83,32 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // binding in iter 2: [6, 7]
         //
         // final binding: [1, 2, 3, 6, 7, 4, 5]
-        let mut existing_bindings = mem::take(&mut candidate.bindings);
+        let mut existing_bindings = mem::take(candidate_bindings);
         let mut new_bindings = Vec::new();
         loop {
-            let match_pairs = mem::take(&mut candidate.match_pairs);
+            let mut match_pairs = mem::take(candidate_match_pairs);
 
-            if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place }] =
-                &*match_pairs
+            if let [MatchPair { pattern: Pat { kind: PatKind::Or { .. }, .. }, .. }] = &*match_pairs
             {
                 existing_bindings.extend_from_slice(&new_bindings);
-                mem::swap(&mut candidate.bindings, &mut existing_bindings);
-                candidate.subcandidates = self.create_or_subcandidates(candidate, place, pats);
-                return true;
+                mem::swap(candidate_bindings, &mut existing_bindings);
+                mem::swap(candidate_match_pairs, &mut match_pairs);
+                return;
             }
 
             let mut changed = false;
             for match_pair in match_pairs {
-                match self.simplify_match_pair(match_pair, candidate) {
+                match self.simplify_match_pair(
+                    match_pair,
+                    candidate_bindings,
+                    candidate_ascriptions,
+                    candidate_match_pairs,
+                ) {
                     Ok(()) => {
                         changed = true;
                     }
                     Err(match_pair) => {
-                        candidate.match_pairs.push(match_pair);
+                        candidate_match_pairs.push(match_pair);
                     }
                 }
             }
@@ -97,21 +125,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             //     let z = x.copy_field;
             //     let y = x;
             // }
-            candidate.bindings.extend_from_slice(&new_bindings);
-            mem::swap(&mut candidate.bindings, &mut new_bindings);
-            candidate.bindings.clear();
+            candidate_bindings.extend_from_slice(&new_bindings);
+            mem::swap(candidate_bindings, &mut new_bindings);
+            candidate_bindings.clear();
 
             if !changed {
                 existing_bindings.extend_from_slice(&new_bindings);
-                mem::swap(&mut candidate.bindings, &mut existing_bindings);
+                mem::swap(candidate_bindings, &mut existing_bindings);
                 // Move or-patterns to the end, because they can result in us
                 // creating additional candidates, so we want to test them as
                 // late as possible.
-                candidate
-                    .match_pairs
+                candidate_match_pairs
                     .sort_by_key(|pair| matches!(pair.pattern.kind, PatKind::Or { .. }));
-                debug!(simplified = ?candidate, "simplify_candidate");
-                return false; // if we were not able to simplify any, done.
+                debug!(simplified = ?candidate_match_pairs, "simplify_candidate");
+                return; // if we were not able to simplify any, done.
             }
         }
     }
@@ -121,14 +148,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// `pats`.
     fn create_or_subcandidates<'pat>(
         &mut self,
-        candidate: &Candidate<'pat, 'tcx>,
         place: &PlaceBuilder<'tcx>,
         pats: &'pat [Box<Pat<'tcx>>],
+        has_guard: bool,
     ) -> Vec<Candidate<'pat, 'tcx>> {
         pats.iter()
             .map(|box pat| {
-                let mut candidate = Candidate::new(place.clone(), pat, candidate.has_guard, self);
-                self.simplify_candidate(&mut candidate);
+                let mut candidate = Candidate::new(place.clone(), pat, has_guard, self);
+                self.simplify_candidate(
+                    &mut candidate.bindings,
+                    &mut candidate.ascriptions,
+                    &mut candidate.match_pairs,
+                    &mut candidate.subcandidates,
+                    candidate.has_guard,
+                );
                 candidate
             })
             .collect()
@@ -142,7 +175,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn simplify_match_pair<'pat>(
         &mut self,
         match_pair: MatchPair<'pat, 'tcx>,
-        candidate: &mut Candidate<'pat, 'tcx>,
+        bindings: &mut Vec<Binding<'tcx>>,
+        ascriptions: &mut Vec<Ascription<'tcx>>,
+        match_pairs: &mut SmallVec<[MatchPair<'pat, 'tcx>; 1]>,
     ) -> Result<(), MatchPair<'pat, 'tcx>> {
         match match_pair.pattern.kind {
             PatKind::AscribeUserType {
@@ -151,14 +186,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             } => {
                 // Apply the type ascription to the value at `match_pair.place`, which is the
                 if let Some(source) = match_pair.place.try_to_place(self) {
-                    candidate.ascriptions.push(Ascription {
+                    ascriptions.push(Ascription {
                         annotation: annotation.clone(),
                         source,
                         variance,
                     });
                 }
 
-                candidate.match_pairs.push(MatchPair::new(match_pair.place, subpattern, self));
+                match_pairs.push(MatchPair::new(match_pair.place, subpattern, self));
 
                 Ok(())
             }
@@ -178,7 +213,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 is_primary: _,
             } => {
                 if let Some(source) = match_pair.place.try_to_place(self) {
-                    candidate.bindings.push(Binding {
+                    bindings.push(Binding {
                         span: match_pair.pattern.span,
                         source,
                         var_id: var,
@@ -188,7 +223,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 if let Some(subpattern) = subpattern.as_ref() {
                     // this is the `x @ P` case; have to keep matching against `P` now
-                    candidate.match_pairs.push(MatchPair::new(match_pair.place, subpattern, self));
+                    match_pairs.push(MatchPair::new(match_pair.place, subpattern, self));
                 }
 
                 Ok(())
@@ -206,7 +241,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
 
             PatKind::InlineConstant { subpattern: ref pattern, def: _ } => {
-                candidate.match_pairs.push(MatchPair::new(match_pair.place, pattern, self));
+                match_pairs.push(MatchPair::new(match_pair.place, pattern, self));
 
                 Ok(())
             }
@@ -222,13 +257,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             PatKind::Slice { ref prefix, ref slice, ref suffix } => {
                 if prefix.is_empty() && slice.is_some() && suffix.is_empty() {
                     // irrefutable
-                    self.prefix_slice_suffix(
-                        &mut candidate.match_pairs,
-                        &match_pair.place,
-                        prefix,
-                        slice,
-                        suffix,
-                    );
+                    self.prefix_slice_suffix(match_pairs, &match_pair.place, prefix, slice, suffix);
                     Ok(())
                 } else {
                     Err(match_pair)
@@ -248,35 +277,27 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     || !adt_def.is_variant_list_non_exhaustive());
                 if irrefutable {
                     let place_builder = match_pair.place.downcast(adt_def, variant_index);
-                    candidate
-                        .match_pairs
-                        .extend(self.field_match_pairs(place_builder, subpatterns));
+                    match_pairs.extend(self.field_match_pairs(place_builder, subpatterns));
                     Ok(())
                 } else {
                     Err(match_pair)
                 }
             }
 
             PatKind::Array { ref prefix, ref slice, ref suffix } => {
-                self.prefix_slice_suffix(
-                    &mut candidate.match_pairs,
-                    &match_pair.place,
-                    prefix,
-                    slice,
-                    suffix,
-                );
+                self.prefix_slice_suffix(match_pairs, &match_pair.place, prefix, slice, suffix);
                 Ok(())
             }
 
             PatKind::Leaf { ref subpatterns } => {
                 // tuple struct, match subpats (if any)
-                candidate.match_pairs.extend(self.field_match_pairs(match_pair.place, subpatterns));
+                match_pairs.extend(self.field_match_pairs(match_pair.place, subpatterns));
                 Ok(())
             }
 
             PatKind::Deref { ref subpattern } => {
                 let place_builder = match_pair.place.deref();
-                candidate.match_pairs.push(MatchPair::new(place_builder, subpattern, self));
+                match_pairs.push(MatchPair::new(place_builder, subpattern, self));
                 Ok(())
             }