Abstract over a single step

Author: Nadrieril

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

@@ -1063,6 +1063,33 @@ pub(crate) struct Test<'tcx> {
 #[derive(Copy, Clone, Debug)]
 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...
+    place: PlaceBuilder<'tcx>,
+    /// ... depending on the result, branch to one of these candidate lists...
+    target_candidates: Vec<Vec<&'a mut Candidate<'pat, 'tcx>>>,
+    /// ... if it doesn't match, continue with these...
+    remaining_candidates: &'a mut [&'c mut Candidate<'pat, 'tcx>],
+    /// ... and if nothing matches, continue to this block.
+    otherwise_block: &'a mut Option<BasicBlock>,
+    /// Track places that need fake borrows.
+    fake_borrows: &'a mut Option<FxIndexSet<Place<'tcx>>>,
+}
+
+impl<'b, 'c, 'pat, 'tcx> std::fmt::Debug for MatchAutomatonStep<'b, 'c, 'pat, 'tcx> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MatchAutomatonStep")
+            .field("test", &self.test)
+            .field("place", &self.place)
+            .finish()
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Main matching algorithm
 
@@ -1699,59 +1726,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         debug!("tested_candidates: {}", total_candidate_count - candidates.len());
         debug!("untested_candidates: {}", candidates.len());
 
-        // HACK(matthewjasper) This is a closure so that we can let the test
-        // create its blocks before the rest of the match. This currently
-        // improves the speed of llvm when optimizing long string literal
-        // matches
-        let make_target_blocks = move |this: &mut Self| -> Vec<BasicBlock> {
-            // The block that we should branch to if none of the
-            // `target_candidates` match. This is either the block where we
-            // start matching the untested candidates if there are any,
-            // otherwise it's the `otherwise_block`.
-            let remainder_start = &mut None;
-            let remainder_start =
-                if candidates.is_empty() { &mut *otherwise_block } else { remainder_start };
-
-            // For each outcome of test, process the candidates that still
-            // apply. Collect a list of blocks where control flow will
-            // branch if one of the `target_candidate` sets is not
-            // exhaustive.
-            let target_blocks: Vec<_> = target_candidates
-                .into_iter()
-                .map(|mut candidates| {
-                    if !candidates.is_empty() {
-                        let candidate_start = this.cfg.start_new_block();
-                        this.match_candidates(
-                            span,
-                            scrutinee_span,
-                            candidate_start,
-                            remainder_start,
-                            &mut *candidates,
-                            fake_borrows,
-                        );
-                        candidate_start
-                    } else {
-                        *remainder_start.get_or_insert_with(|| this.cfg.start_new_block())
-                    }
-                })
-                .collect();
-
-            if !candidates.is_empty() {
-                let remainder_start = remainder_start.unwrap_or_else(|| this.cfg.start_new_block());
-                this.match_candidates(
-                    span,
-                    scrutinee_span,
-                    remainder_start,
-                    otherwise_block,
-                    candidates,
-                    fake_borrows,
-                );
-            };
-
-            target_blocks
+        let step = MatchAutomatonStep {
+            span,
+            test,
+            place: match_place,
+            remaining_candidates: candidates,
+            target_candidates,
+            otherwise_block,
+            fake_borrows,
         };
-
-        self.perform_test(span, scrutinee_span, block, &match_place, &test, make_target_blocks);
+        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

@@ -23,6 +23,8 @@ use rustc_target::abi::VariantIdx;
 
 use std::cmp::Ordering;
 
+use super::MatchAutomatonStep;
+
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Identifies what test is needed to decide if `match_pair` is applicable.
     ///
@@ -147,16 +149,72 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
     }
 
-    #[instrument(skip(self, make_target_blocks, place_builder), level = "debug")]
+    #[instrument(skip(self), level = "debug")]
     pub(super) fn perform_test(
         &mut self,
         match_start_span: Span,
         scrutinee_span: Span,
         block: BasicBlock,
-        place_builder: &PlaceBuilder<'tcx>,
-        test: &Test<'tcx>,
-        make_target_blocks: impl FnOnce(&mut Self) -> Vec<BasicBlock>,
+        step: MatchAutomatonStep<'_, '_, '_, 'tcx>,
     ) {
+        let test = &step.test;
+        let place_builder = &step.place;
+        // HACK(matthewjasper) This is a closure so that we can let the test
+        // create its blocks before the rest of the match. This currently
+        // improves the speed of llvm when optimizing long string literal
+        // matches
+        let make_target_blocks = move |this: &mut Self| -> Vec<BasicBlock> {
+            // The block that we should branch to if none of the
+            // `target_candidates` match. This is either the block where we
+            // start matching the untested candidates if there are any,
+            // otherwise it's the `otherwise_block`.
+            let remainder_start = &mut None;
+            let remainder_start = if step.remaining_candidates.is_empty() {
+                &mut *step.otherwise_block
+            } else {
+                remainder_start
+            };
+
+            // For each outcome of test, process the candidates that still
+            // apply. Collect a list of blocks where control flow will
+            // branch if one of the `target_candidate` sets is not
+            // exhaustive.
+            let target_blocks: Vec<_> = step
+                .target_candidates
+                .into_iter()
+                .map(|mut candidates| {
+                    if !candidates.is_empty() {
+                        let candidate_start = this.cfg.start_new_block();
+                        this.match_candidates(
+                            step.span,
+                            scrutinee_span,
+                            candidate_start,
+                            remainder_start,
+                            &mut *candidates,
+                            step.fake_borrows,
+                        );
+                        candidate_start
+                    } else {
+                        *remainder_start.get_or_insert_with(|| this.cfg.start_new_block())
+                    }
+                })
+                .collect();
+
+            if !step.remaining_candidates.is_empty() {
+                let remainder_start = remainder_start.unwrap_or_else(|| this.cfg.start_new_block());
+                this.match_candidates(
+                    step.span,
+                    scrutinee_span,
+                    remainder_start,
+                    step.otherwise_block,
+                    step.remaining_candidates,
+                    step.fake_borrows,
+                );
+            };
+
+            target_blocks
+        };
+
         let place = place_builder.to_place(self);
         let place_ty = place.ty(&self.local_decls, self.tcx);
         debug!(?place, ?place_ty,);