Implementation of #[cold] on match arms. Simplify before rebase

Author: x17jiri

compiler/rustc_middle/src/thir.rs

@@ -522,6 +522,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/build/matches/mod.rs

@@ -19,7 +19,7 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::thir::{self, *};
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{sym, Symbol};
 use rustc_span::{BytePos, Pos, Span};
 use rustc_target::abi::VariantIdx;
 use smallvec::{smallvec, SmallVec};
@@ -292,8 +292,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .map(|arm| {
                 let arm = &self.thir[arm];
                 let arm_has_guard = arm.guard.is_some();
-                let arm_candidate =
-                    Candidate::new(scrutinee.clone(), &arm.pattern, arm_has_guard, self);
+                let arm_is_cold = arm.is_cold;
+                let arm_candidate = Candidate::new(
+                    scrutinee.clone(),
+                    &arm.pattern,
+                    arm_has_guard,
+                    arm_is_cold,
+                    self,
+                );
                 (arm, arm_candidate)
             })
             .collect()
@@ -444,6 +450,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         false,
                     );
 
+                    // TODO - make arm_block cold
+
                     this.fixed_temps_scope = old_dedup_scope;
 
                     if let Some(source_scope) = scope {
@@ -652,7 +660,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         initializer: PlaceBuilder<'tcx>,
         set_match_place: bool,
     ) -> BlockAnd<()> {
-        let mut candidate = Candidate::new(initializer.clone(), irrefutable_pat, false, self);
+        let mut candidate =
+            Candidate::new(initializer.clone(), irrefutable_pat, false, false, self);
         let fake_borrow_temps = self.lower_match_tree(
             block,
             irrefutable_pat.span,
@@ -950,6 +959,9 @@ struct Candidate<'pat, 'tcx> {
     /// Whether this `Candidate` has a guard.
     has_guard: bool,
 
+    /// Whether this 'Candidate' comes from a cold arm.
+    is_cold: bool,
+
     /// All of these must be satisfied...
     match_pairs: SmallVec<[MatchPair<'pat, 'tcx>; 1]>,
 
@@ -976,11 +988,13 @@ impl<'tcx, 'pat> Candidate<'pat, 'tcx> {
         place: PlaceBuilder<'tcx>,
         pattern: &'pat Pat<'tcx>,
         has_guard: bool,
+        is_cold: bool,
         cx: &Builder<'_, 'tcx>,
     ) -> Self {
         Candidate {
             span: pattern.span,
             has_guard,
+            is_cold,
             match_pairs: smallvec![MatchPair::new(place, pattern, cx)],
             bindings: Vec::new(),
             ascriptions: Vec::new(),
@@ -1500,7 +1514,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         debug!("candidate={:#?}\npats={:#?}", candidate, pats);
         let mut or_candidates: Vec<_> = pats
             .iter()
-            .map(|pat| Candidate::new(place.clone(), pat, candidate.has_guard, self))
+            .map(|pat| {
+                Candidate::new(place.clone(), pat, candidate.has_guard, candidate.is_cold, self)
+            })
             .collect();
         let mut or_candidate_refs: Vec<_> = or_candidates.iter_mut().collect();
         let otherwise = if candidate.otherwise_block.is_some() {
@@ -1890,9 +1906,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let expr_span = self.thir[expr_id].span;
         let expr_place_builder = unpack!(block = self.lower_scrutinee(block, expr_id, expr_span));
         let wildcard = Pat::wildcard_from_ty(pat.ty);
-        let mut guard_candidate = Candidate::new(expr_place_builder.clone(), pat, false, self);
+        let mut guard_candidate =
+            Candidate::new(expr_place_builder.clone(), pat, false, false, self);
         let mut otherwise_candidate =
-            Candidate::new(expr_place_builder.clone(), &wildcard, false, self);
+            Candidate::new(expr_place_builder.clone(), &wildcard, false, false, self);
         let fake_borrow_temps = self.lower_match_tree(
             block,
             pat.span,
@@ -2386,8 +2403,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let (matching, failure) = self.in_if_then_scope(*let_else_scope, else_block_span, |this| {
             let scrutinee = unpack!(block = this.lower_scrutinee(block, init_id, initializer_span));
             let pat = Pat { ty: pattern.ty, span: else_block_span, kind: PatKind::Wild };
-            let mut wildcard = Candidate::new(scrutinee.clone(), &pat, false, this);
-            let mut candidate = Candidate::new(scrutinee.clone(), pattern, false, this);
+            let mut wildcard = Candidate::new(scrutinee.clone(), &pat, false, false, this);
+            let mut candidate = Candidate::new(scrutinee.clone(), pattern, false, false, this);
             let fake_borrow_temps = this.lower_match_tree(
                 block,
                 initializer_span,

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

@@ -127,7 +127,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> Vec<Candidate<'pat, 'tcx>> {
         pats.iter()
             .map(|box pat| {
-                let mut candidate = Candidate::new(place.clone(), pat, candidate.has_guard, self);
+                let mut candidate = Candidate::new(
+                    place.clone(),
+                    pat,
+                    candidate.has_guard,
+                    candidate.is_cold,
+                    self,
+                );
                 self.simplify_candidate(&mut candidate);
                 candidate
             })

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

@@ -855,13 +855,15 @@ impl<'tcx> Cx<'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 { 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

@@ -588,7 +588,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);
@@ -605,6 +605,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);
     }