Unroll

Author: Nadrieril

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

@@ -1170,13 +1170,33 @@ 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(
+            self.simplify_candidate(
                 &mut candidate.bindings,
                 &mut candidate.ascriptions,
                 &mut candidate.match_pairs,
-                &mut candidate.subcandidates,
-                candidate.has_guard,
             );
+
+            split_or_candidate |= {
+                if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place, .. }] =
+                    &*candidate.match_pairs
+                {
+                    // Split a candidate in which the only match-pair is an or-pattern into multiple
+                    // candidates. This is so that
+                    //
+                    // match x {
+                    //     0 | 1 => { ... },
+                    //     2 | 3 => { ... },
+                    // }
+                    //
+                    // only generates a single switch.
+                    candidate.subcandidates =
+                        self.create_or_subcandidates(place, pats, candidate.has_guard);
+                    candidate.match_pairs.pop();
+                    true
+                } else {
+                    false
+                }
+            };
         }
 
         ensure_sufficient_stack(|| {

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

@@ -20,42 +20,8 @@ use std::mem;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Simplify a candidate so that all match pairs require a test.
-    ///
-    /// This method will also split a candidate, in which the only
-    /// match-pair is an or-pattern, into multiple candidates.
-    /// This is so that
-    ///
-    /// match x {
-    ///     0 | 1 => { ... },
-    ///     2 | 3 => { ... },
-    /// }
-    ///
-    /// only generates a single switch. If this happens this method returns
-    /// `true`.
     #[instrument(skip(self), level = "debug")]
     pub(super) fn simplify_candidate<'pat>(
-        &mut self,
-        bindings: &mut Vec<Binding<'tcx>>,
-        ascriptions: &mut Vec<Ascription<'tcx>>,
-        match_pairs: &mut Vec<MatchPair<'pat, 'tcx>>,
-        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>>,
@@ -144,7 +110,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Given `candidate` that has a single or-pattern for its match-pairs,
     /// creates a fresh candidate for each of its input subpatterns passed via
     /// `pats`.
-    fn create_or_subcandidates<'pat>(
+    pub(super) fn create_or_subcandidates<'pat>(
         &mut self,
         place: &PlaceBuilder<'tcx>,
         pats: &'pat [Box<Pat<'tcx>>],
@@ -157,9 +123,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     &mut candidate.bindings,
                     &mut candidate.ascriptions,
                     &mut candidate.match_pairs,
-                    &mut candidate.subcandidates,
-                    candidate.has_guard,
                 );
+
+                if let [MatchPair { pattern: Pat { kind: PatKind::Or { pats }, .. }, place, .. }] =
+                    &*candidate.match_pairs
+                {
+                    candidate.subcandidates =
+                        self.create_or_subcandidates(place, pats, candidate.has_guard);
+                    candidate.match_pairs.pop();
+                }
                 candidate
             })
             .collect()