Recorder checks - from intuitively cheapest to most expensive

Author: simonvandel

compiler/rustc_mir/src/transform/early_otherwise_branch.rs

@@ -240,30 +240,14 @@ impl<'a, 'tcx> Helper<'a, 'tcx> {
         if is_switch(terminator) {
             let this_bb_discr_info = self.find_switch_discriminant_info(bb, terminator)?;
 
-            // The layouts of the two ADTs have to be equal for this optimization to apply
-            let layout_of_adt =
-                |ty: Ty<'tcx>| self.tcx.layout_of(self.param_env.and(ty)).ok().map(|x| x.layout);
-            let layout_lhs = layout_of_adt(discr_info.type_adt_matched_on);
-            let layout_rhs = layout_of_adt(this_bb_discr_info.type_adt_matched_on);
-            if layout_lhs != layout_rhs {
-                trace!("NO: Layouts do not match. LHS: {:?}, RHS: {:?}", layout_lhs, layout_rhs);
-                return None;
-            }
-
-            // the otherwise branch of the two switches have to point to the same bb
+            // The otherwise branch of the two switches have to point to the same bb
             if discr_info.otherwise_bb != this_bb_discr_info.otherwise_bb {
                 trace!("NO: otherwise target is not the same");
                 return None;
             }
 
-            // check that the value being matched on is the same. The
-            if this_bb_discr_info.targets_with_values.iter().find(|x| x.1 == value).is_none() {
-                trace!("NO: values being matched on are not the same");
-                return None;
-            }
-
-            // only allow optimization if the left and right of the tuple being matched are the same variants.
-            // so the following should not optimize
+            // Only allow optimization if the left and right of the tuple being matched
+            // are the same variants. So the following should not optimize
             //  ```rust
             // let x: Option<()>;
             // let y: Option<()>;
@@ -272,7 +256,8 @@ impl<'a, 'tcx> Helper<'a, 'tcx> {
             //     _ => {}
             // }
             //  ```
-            // We check this by seeing that the value of the first discriminant is the only other discriminant value being used as a target in the second switch
+            // We check this by seeing that the value of the first discriminant is the only
+            // other discriminant value being used as a target in the second switch
             if !(this_bb_discr_info.targets_with_values.len() == 1
                 && this_bb_discr_info.targets_with_values[0].1 == value)
             {
@@ -282,7 +267,23 @@ impl<'a, 'tcx> Helper<'a, 'tcx> {
                 return None;
             }
 
-            // if we reach this point, the optimization applies, and we should be able to optimize this case
+            // check that the value being matched on is the same. The
+            if this_bb_discr_info.targets_with_values.iter().find(|x| x.1 == value).is_none() {
+                trace!("NO: values being matched on are not the same");
+                return None;
+            }
+
+            // The layouts of the two ADTs have to be equal for this optimization to apply
+            let layout_of_adt =
+                |ty: Ty<'tcx>| self.tcx.layout_of(self.param_env.and(ty)).ok().map(|x| x.layout);
+            let layout_lhs = layout_of_adt(discr_info.type_adt_matched_on);
+            let layout_rhs = layout_of_adt(this_bb_discr_info.type_adt_matched_on);
+            if layout_lhs != layout_rhs {
+                trace!("NO: Layouts do not match. LHS: {:?}, RHS: {:?}", layout_lhs, layout_rhs);
+                return None;
+            }
+
+            // If we reach this point, the optimization applies, and we should be able to optimize this case
             // store the info that is needed to apply the optimization
 
             Some(OptimizationInfo {