Incomplete rebase

Author: x17jiri

compiler/rustc_middle/src/thir.rs

@@ -568,6 +568,7 @@ pub struct Arm<'tcx> {
     pub lint_level: LintLevel,
     pub scope: region::Scope,
     pub span: Span,
+    pub is_cold: bool,
 }
 
 #[derive(Copy, Clone, Debug, HashStable)]

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

@@ -369,7 +369,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let arm = &self.thir[arm];
                 let has_match_guard =
                     if arm.guard.is_some() { HasMatchGuard::Yes } else { HasMatchGuard::No };
-                (&*arm.pattern, has_match_guard)
+                (&*arm.pattern, has_match_guard, arm.is_cold)
             })
             .collect();
         let built_tree = self.lower_match_tree(
@@ -467,6 +467,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         EmitStorageLive::Yes,
                     );
 
+                    // TODO - make arm_block cold
+
                     this.fixed_temps_scope = old_dedup_scope;
 
                     if let Some(source_scope) = scope {
@@ -676,7 +678,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             irrefutable_pat.span,
             &initializer,
             irrefutable_pat.span,
-            vec![(irrefutable_pat, HasMatchGuard::No)],
+            vec![(irrefutable_pat, HasMatchGuard::No, false)],
             false,
         );
         let [branch] = built_tree.branches.try_into().unwrap();
@@ -1072,6 +1074,9 @@ struct Candidate<'tcx> {
     /// whether the enclosing match arm has a guard.
     has_guard: bool,
 
+    /// Whether this 'Candidate' comes from a cold arm.
+    is_cold: bool,
+
     /// Holds extra pattern data that was prepared by [`FlatPat`], including bindings and
     /// ascriptions that must be established if this candidate succeeds.
     extra_data: PatternExtraData<'tcx>,
@@ -1103,22 +1108,25 @@ impl<'tcx> Candidate<'tcx> {
         place: PlaceBuilder<'tcx>,
         pattern: &Pat<'tcx>,
         has_guard: HasMatchGuard,
+        is_cold: bool,
         cx: &mut Builder<'_, 'tcx>,
     ) -> Self {
         // Use `FlatPat` to build simplified match pairs, then immediately
         // incorporate them into a new candidate.
         Self::from_flat_pat(
             FlatPat::new(place, pattern, cx),
             matches!(has_guard, HasMatchGuard::Yes),
+            is_cold,
         )
     }
 
     /// Incorporates an already-simplified [`FlatPat`] into a new candidate.
-    fn from_flat_pat(flat_pat: FlatPat<'tcx>, has_guard: bool) -> Self {
+    fn from_flat_pat(flat_pat: FlatPat<'tcx>, has_guard: bool, is_cold: bool) -> Self {
         Candidate {
             match_pairs: flat_pat.match_pairs,
             extra_data: flat_pat.extra_data,
             has_guard,
+            is_cold,
             subcandidates: Vec::new(),
             or_span: None,
             otherwise_block: None,
@@ -1484,7 +1492,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         scrutinee_span: Span,
         scrutinee_place_builder: &PlaceBuilder<'tcx>,
         match_start_span: Span,
-        patterns: Vec<(&Pat<'tcx>, HasMatchGuard)>,
+        patterns: Vec<(&Pat<'tcx>, HasMatchGuard, bool)>,
         refutable: bool,
     ) -> BuiltMatchTree<'tcx> {
         // Assemble the initial list of candidates. These top-level candidates are 1:1 with the
@@ -1493,8 +1501,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // match arms directly.
         let mut candidates: Vec<Candidate<'_>> = patterns
             .into_iter()
-            .map(|(pat, has_guard)| {
-                Candidate::new(scrutinee_place_builder.clone(), pat, has_guard, self)
+            .map(|(pat, has_guard, is_cold)| {
+                Candidate::new(scrutinee_place_builder.clone(), pat, has_guard, is_cold, self)
             })
             .collect();
 
@@ -1866,7 +1874,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         candidate.subcandidates = pats
             .into_vec()
             .into_iter()
-            .map(|flat_pat| Candidate::from_flat_pat(flat_pat, candidate.has_guard))
+            .map(|flat_pat| {
+                Candidate::from_flat_pat(flat_pat, candidate.has_guard, candidate.is_cold)
+            })
             .collect();
         candidate.subcandidates[0].false_edge_start_block = candidate.false_edge_start_block;
     }
@@ -2346,7 +2356,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             expr_span,
             &scrutinee,
             pat.span,
-            vec![(pat, HasMatchGuard::No)],
+            vec![(pat, HasMatchGuard::No, false)],
             true,
         );
         let [branch] = built_tree.branches.try_into().unwrap();

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -1005,13 +1005,15 @@ impl<'tcx> ThirBuildCx<'tcx> {
     }
 
     fn convert_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) -> ArmId {
+        let attrs = self.tcx.hir().attrs(arm.hir_id);
         let arm = Arm {
             pattern: self.pattern_from_hir(&arm.pat),
             guard: arm.guard.as_ref().map(|g| self.mirror_expr(g)),
             body: self.mirror_expr(arm.body),
             lint_level: LintLevel::Explicit(arm.hir_id),
             scope: region::Scope { local_id: arm.hir_id.local_id, data: region::ScopeData::Node },
             span: arm.span,
+            is_cold: attrs.iter().any(|a| a.name_or_empty() == sym::cold),
         };
         self.thir.arms.push(arm)
     }

compiler/rustc_mir_build/src/thir/print.rs

@@ -623,7 +623,7 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
         print_indented!(self, "Arm {", depth_lvl);
 
         let arm = &self.thir.arms[arm_id];
-        let Arm { pattern, guard, body, lint_level, scope, span } = arm;
+        let Arm { pattern, guard, body, lint_level, scope, span, is_cold } = arm;
 
         print_indented!(self, "pattern: ", depth_lvl + 1);
         self.print_pat(pattern, depth_lvl + 2);
@@ -640,6 +640,7 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
         print_indented!(self, format!("lint_level: {:?}", lint_level), depth_lvl + 1);
         print_indented!(self, format!("scope: {:?}", scope), depth_lvl + 1);
         print_indented!(self, format!("span: {:?}", span), depth_lvl + 1);
+        print_indented!(self, format!("is_cold: {:?}", is_cold), depth_lvl + 1);
         print_indented!(self, "}", depth_lvl);
     }