Tighten the loop a little bit

Author: Nadrieril

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

@@ -1065,8 +1065,6 @@ pub(crate) struct ArmHasGuard(pub(crate) bool);
 
 /// A single step in the match algorithm.
 pub(crate) struct MatchAutomatonStep<'a, 'c, 'pat, 'tcx> {
-    /// FIXME: probably the span of the match.
-    span: Span,
     /// Perform this test...
     test: Test<'tcx>,
     /// ... on this place...
@@ -1112,7 +1110,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// exhaustive in Rust. But during processing we sometimes divide
     /// up the list of candidates and recurse with a non-exhaustive
     /// list. This is important to keep the size of the generated code
-    /// under control. See [`Builder::test_candidates`] for more details.
+    /// under control. See [`Builder::build_test_step`] for more details.
     ///
     /// If `fake_borrows` is `Some`, then places which need fake borrows
     /// will be added to it.
@@ -1348,7 +1346,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     }
 
     /// Tests a candidate where there are only or-patterns left to test, or
-    /// forwards to [Builder::test_candidates].
+    /// forwards to [Builder::build_test_step].
     ///
     /// Given a pattern `(P | Q, R | S)` we (in principle) generate a CFG like
     /// so:
@@ -1416,14 +1414,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         match first_candidate.match_pairs[0].pattern.kind {
             PatKind::Or { .. } => (),
             _ => {
-                self.test_candidates(
-                    span,
-                    scrutinee_span,
-                    candidates,
-                    block,
-                    otherwise_block,
-                    fake_borrows,
-                );
+                let step = self.build_test_step(candidates, otherwise_block, fake_borrows);
+                self.perform_test(span, scrutinee_span, block, step);
                 return;
             }
         }
@@ -1653,15 +1645,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// In addition to avoiding exponential-time blowups, this algorithm
     /// also has the nice property that each guard and arm is only generated
     /// once.
-    fn test_candidates<'pat, 'b, 'c>(
+    fn build_test_step<'pat, 'b, 'c>(
         &mut self,
-        span: Span,
-        scrutinee_span: Span,
         mut candidates: &'b mut [&'c mut Candidate<'pat, 'tcx>],
-        block: BasicBlock,
-        otherwise_block: &mut Option<BasicBlock>,
-        fake_borrows: &mut Option<FxIndexSet<Place<'tcx>>>,
-    ) {
+        otherwise_block: &'b mut Option<BasicBlock>,
+        fake_borrows: &'b mut Option<FxIndexSet<Place<'tcx>>>,
+    ) -> MatchAutomatonStep<'b, 'c, 'pat, 'tcx> {
         // extract the match-pair from the highest priority candidate
         let match_pair = &candidates.first().unwrap().match_pairs[0];
         let mut test = self.test(match_pair);
@@ -1700,7 +1689,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // those N possible outcomes, create a (initially empty)
         // vector of candidates. Those are the candidates that still
         // apply if the test has that particular outcome.
-        debug!("test_candidates: test={:?} match_pair={:?}", test, match_pair);
+        debug!("build_test_step: test={:?} match_pair={:?}", test, match_pair);
         let mut target_candidates: Vec<Vec<&mut Candidate<'pat, 'tcx>>> = vec![];
         target_candidates.resize_with(test.targets(), Default::default);
 
@@ -1726,16 +1715,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         debug!("tested_candidates: {}", total_candidate_count - candidates.len());
         debug!("untested_candidates: {}", candidates.len());
 
-        let step = MatchAutomatonStep {
-            span,
+        MatchAutomatonStep {
             test,
             place: match_place,
             remaining_candidates: candidates,
             target_candidates,
             otherwise_block,
             fake_borrows,
-        };
-        self.perform_test(span, scrutinee_span, block, step);
+        }
     }
 
     /// Determine the fake borrows that are needed from a set of places that

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

@@ -186,7 +186,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     if !candidates.is_empty() {
                         let candidate_start = this.cfg.start_new_block();
                         this.match_candidates(
-                            step.span,
+                            match_start_span,
                             scrutinee_span,
                             candidate_start,
                             remainder_start,
@@ -203,7 +203,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             if !step.remaining_candidates.is_empty() {
                 let remainder_start = remainder_start.unwrap_or_else(|| this.cfg.start_new_block());
                 this.match_candidates(
-                    step.span,
+                    match_start_span,
                     scrutinee_span,
                     remainder_start,
                     step.otherwise_block,