Auto merge of rust-lang#129931 - DianQK:match-br-copy, r=<try>

mir-opt: Merge all branch BBs into a single copy statement

rust-lang#128299 simplified
```rust
match a {
    Foo::A(x) => Foo::A(*x),
    Foo::B => Foo::B
}
```
to
```rust
match a {
    Foo::A(x) => a, // copy a
    Foo::B => Foo::B
}
```

The switch branch can be simplified into a single copy statement. This PR implements a relatively general simplification.

Author: bors

compiler/rustc_mir_transform/src/lib.rs

@@ -86,6 +86,7 @@ mod lower_intrinsics;
 mod lower_slice_len;
 mod match_branches;
 mod mentioned_items;
+mod merge_branches;
 mod multiple_return_terminators;
 mod nrvo;
 mod post_drop_elaboration;
@@ -611,6 +612,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             &dead_store_elimination::DeadStoreElimination::Initial,
             &gvn::GVN,
             &simplify::SimplifyLocals::AfterGVN,
+            &merge_branches::MergeBranchSimplification,
             &dataflow_const_prop::DataflowConstProp,
             &single_use_consts::SingleUseConsts,
             &o1(simplify_branches::SimplifyConstCondition::AfterConstProp),

compiler/rustc_mir_transform/src/merge_branches.rs

@@ -0,0 +1,287 @@
+//! This pass attempts to merge all branches to eliminate switch terminator.
+//! Ideally, we could combine it with `MatchBranchSimplification`, as these two passes
+//! match and merge statements with different patterns. Given the compile time and
+//! code complexity, we have not merged them into a more general pass for now.
+use rustc_const_eval::const_eval::mk_eval_cx_for_const_val;
+use rustc_index::bit_set::BitSet;
+use rustc_middle::mir::patch::MirPatch;
+use rustc_middle::mir::*;
+use rustc_middle::ty;
+use rustc_middle::ty::util::Discr;
+use rustc_middle::ty::{ParamEnv, TyCtxt};
+use rustc_mir_dataflow::impls::{MaybeTransitiveLiveLocals, borrowed_locals};
+use rustc_mir_dataflow::{Analysis, ResultsCursor};
+
+pub(super) struct MergeBranchSimplification;
+
+impl<'tcx> crate::MirPass<'tcx> for MergeBranchSimplification {
+    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
+        sess.mir_opt_level() >= 2
+    }
+
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        let def_id = body.source.def_id();
+        let param_env = tcx.param_env_reveal_all_normalized(def_id);
+
+        let borrowed_locals = borrowed_locals(body);
+        let mut stmt_live_result = StatementLiveResult::new(tcx, body, &borrowed_locals);
+        for i in 0..body.basic_blocks.len() {
+            let bbs = &*body.basic_blocks;
+            let switch_bb_idx = BasicBlock::from_usize(i);
+            let Some((switch_discr, targets)) = bbs[switch_bb_idx].terminator().kind.as_switch()
+            else {
+                continue;
+            };
+            // Check if the copy source matches the following pattern.
+            // _2 = discriminant(*_1); // "*_1" is the expected the copy source.
+            // switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1];
+            let Some(&Statement {
+                kind: StatementKind::Assign(box (discr_place, Rvalue::Discriminant(src_place))),
+                ..
+            }) = bbs[switch_bb_idx].statements.last()
+            else {
+                continue;
+            };
+            if switch_discr.place() != Some(discr_place) {
+                continue;
+            }
+            let src_ty = src_place.ty(body.local_decls(), tcx);
+            if !src_ty.ty.is_enum() || src_ty.variant_index.is_some() {
+                continue;
+            }
+            // We require that the possible target blocks all be distinct.
+            if !targets.is_distinct() {
+                continue;
+            }
+            if !bbs[targets.otherwise()].is_empty_unreachable() {
+                continue;
+            }
+            // Check that destinations are identical, and if not, then don't optimize this block.
+            let mut targets_iter = targets.iter();
+            let first_terminator_kind = &bbs[targets_iter.next().unwrap().1].terminator().kind;
+            if !targets_iter.all(|(_, other_target)| {
+                first_terminator_kind == &bbs[other_target].terminator().kind
+            }) {
+                continue;
+            }
+            if let Some(dest_place) = can_simplify_to_copy(
+                tcx,
+                param_env,
+                body,
+                targets,
+                src_place,
+                src_ty,
+                &mut stmt_live_result,
+            ) {
+                let statement_index = bbs[switch_bb_idx].statements.len();
+                let parent_end = Location { block: switch_bb_idx, statement_index };
+                let mut patch = MirPatch::new(body);
+                patch.add_assign(parent_end, dest_place, Rvalue::Use(Operand::Copy(src_place)));
+                patch.patch_terminator(switch_bb_idx, first_terminator_kind.clone());
+                patch.apply(body);
+                super::simplify::remove_dead_blocks(body);
+                // After modifying the MIR, the result of `MaybeTransitiveLiveLocals` may become invalid,
+                // keeping it simple to process only once.
+                break;
+            }
+        }
+    }
+}
+
+struct StatementLiveResult<'tcx, 'mir, 'a> {
+    tcx: TyCtxt<'tcx>,
+    body: &'mir Body<'tcx>,
+    result: Option<ResultsCursor<'mir, 'tcx, MaybeTransitiveLiveLocals<'a>>>,
+    borrowed_locals: &'a BitSet<Local>,
+}
+
+impl<'tcx, 'mir, 'a> StatementLiveResult<'tcx, 'mir, 'a> {
+    fn new(tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx>, borrowed_locals: &'a BitSet<Local>) -> Self {
+        Self { tcx, body, result: None, borrowed_locals }
+    }
+
+    fn is_live(&mut self, loc: Location, local: Local) -> bool {
+        if self.borrowed_locals.contains(local) {
+            return true;
+        }
+        let maybe_live = self.result.get_or_insert_with(|| {
+            MaybeTransitiveLiveLocals::new(&self.borrowed_locals)
+                .into_engine(self.tcx, self.body)
+                .iterate_to_fixpoint()
+                .into_results_cursor(self.body)
+        });
+        maybe_live.seek_before_primary_effect(loc);
+        maybe_live.get().contains(local)
+    }
+}
+
+/// The GVN simplified
+/// ```ignore (syntax-highlighting-only)
+/// match a {
+///     Foo::A(x) => Foo::A(*x),
+///     Foo::B => Foo::B
+/// }
+/// ```
+/// to
+/// ```ignore (syntax-highlighting-only)
+/// match a {
+///     Foo::A(_x) => a, // copy a
+///     Foo::B => Foo::B
+/// }
+/// ```
+/// This function answers whether it can be simplified to a copy statement
+/// by returning the copy destination.
+fn can_simplify_to_copy<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    body: &Body<'tcx>,
+    targets: &SwitchTargets,
+    src_place: Place<'tcx>,
+    src_ty: tcx::PlaceTy<'tcx>,
+    stmt_live_result: &mut StatementLiveResult<'tcx, '_, '_>,
+) -> Option<Place<'tcx>> {
+    let mut targets_iter = targets.iter();
+    let dest_place = targets_iter.next().and_then(|(index, target)| {
+        find_copy_assign(tcx, param_env, body, index, target, src_place, src_ty, stmt_live_result)
+    })?;
+    let dest_ty = dest_place.ty(body.local_decls(), tcx);
+    if dest_ty.ty != src_ty.ty || dest_ty.variant_index.is_some() {
+        return None;
+    }
+    if targets_iter.any(|(other_index, other_target)| {
+        Some(dest_place)
+            != find_copy_assign(
+                tcx,
+                param_env,
+                body,
+                other_index,
+                other_target,
+                src_place,
+                src_ty,
+                stmt_live_result,
+            )
+    }) {
+        return None;
+    }
+    Some(dest_place)
+}
+
+fn find_copy_assign<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    body: &Body<'tcx>,
+    index: u128,
+    target_block: BasicBlock,
+    src_place: Place<'tcx>,
+    src_ty: tcx::PlaceTy<'tcx>,
+    stmt_live_result: &mut StatementLiveResult<'tcx, '_, '_>,
+) -> Option<Place<'tcx>> {
+    let statements = &body.basic_blocks[target_block].statements;
+    if statements.is_empty() {
+        return None;
+    }
+    let assign_stmt = if statements.len() == 1 {
+        0
+    } else {
+        // We are matching a statement copied from the source to the same destination from the BB,
+        // and dead statements can be ignored.
+        // We can treat the rvalue is the source if it's equal to the source.
+        let mut lived_stmts: BitSet<usize> = BitSet::new_filled(statements.len());
+        let mut expected_assign_stmt = None;
+        for (statement_index, statement) in statements.iter().enumerate().rev() {
+            let loc = Location { block: target_block, statement_index };
+            if let StatementKind::Assign(assign) = &statement.kind {
+                if !assign.1.is_safe_to_remove() {
+                    return None;
+                }
+            }
+            match &statement.kind {
+                StatementKind::Assign(box (dest_place, _))
+                | StatementKind::SetDiscriminant { place: box dest_place, .. }
+                | StatementKind::Deinit(box dest_place) => {
+                    if dest_place.is_indirect() {
+                        return None;
+                    }
+                    if !stmt_live_result.is_live(loc, dest_place.local) {
+                        lived_stmts.remove(statement_index);
+                    } else if matches!(statement.kind, StatementKind::Assign(_))
+                        && expected_assign_stmt.is_none()
+                    {
+                        // There is only one statement that cannot be ignored
+                        // that can be used as an expected copy statement.
+                        expected_assign_stmt = Some(statement_index);
+                        lived_stmts.remove(statement_index);
+                    } else {
+                        return None;
+                    }
+                }
+                StatementKind::StorageLive(_)
+                | StatementKind::StorageDead(_)
+                | StatementKind::Nop => (),
+
+                StatementKind::Retag(_, _)
+                | StatementKind::Coverage(_)
+                | StatementKind::Intrinsic(_)
+                | StatementKind::ConstEvalCounter
+                | StatementKind::PlaceMention(_)
+                | StatementKind::FakeRead(_)
+                | StatementKind::AscribeUserType(_, _) => {
+                    return None;
+                }
+            }
+        }
+        let expected_assign = expected_assign_stmt?;
+        // We can ignore the paired StorageLive and StorageDead.
+        let mut storage_live_locals: BitSet<Local> = BitSet::new_empty(body.local_decls.len());
+        for stmt_index in lived_stmts.iter() {
+            let statement = &statements[stmt_index];
+            match &statement.kind {
+                StatementKind::StorageLive(local) if storage_live_locals.insert(*local) => {}
+                StatementKind::StorageDead(local) if storage_live_locals.remove(*local) => {}
+                StatementKind::Nop => {}
+                _ => return None,
+            }
+        }
+        if !storage_live_locals.is_empty() {
+            return None;
+        }
+        expected_assign
+    };
+    let Statement { kind: StatementKind::Assign(box (dest_place, ref rvalue)), .. } =
+        statements[assign_stmt]
+    else {
+        return None;
+    };
+    let dest_ty = dest_place.ty(body.local_decls(), tcx);
+    if dest_ty.ty != src_ty.ty || dest_ty.variant_index.is_some() {
+        return None;
+    }
+    let ty::Adt(def, _) = dest_ty.ty.kind() else {
+        return None;
+    };
+    match rvalue {
+        // Check if `_3 = const Foo::B` can be transformed to `_3 = copy *_1`.
+        Rvalue::Use(Operand::Constant(box constant))
+            if let Const::Val(const_, ty) = constant.const_ =>
+        {
+            let (ecx, op) = mk_eval_cx_for_const_val(tcx.at(constant.span), param_env, const_, ty)?;
+            let variant = ecx.read_discriminant(&op).discard_err()?;
+            if !def.variants()[variant].fields.is_empty() {
+                return None;
+            }
+            let Discr { val, .. } = ty.discriminant_for_variant(tcx, variant)?;
+            if val != index {
+                return None;
+            }
+        }
+        Rvalue::Use(Operand::Copy(place)) if *place == src_place => {}
+        // Check if `_3 = Foo::B` can be transformed to `_3 = copy *_1`.
+        Rvalue::Aggregate(box AggregateKind::Adt(_, variant_index, _, _, None), fields)
+            if fields.is_empty()
+                && let Some(Discr { val, .. }) =
+                    src_ty.ty.discriminant_for_variant(tcx, *variant_index)
+                && val == index => {}
+        _ => return None,
+    }
+    Some(dest_place)
+}

tests/codegen/match-optimizes-away.rs

@@ -1,5 +1,5 @@
-//
-//@ compile-flags: -O
+//@ compile-flags: -O -Cno-prepopulate-passes
+
 #![crate_type = "lib"]
 
 pub enum Three {
@@ -19,8 +19,9 @@ pub enum Four {
 #[no_mangle]
 pub fn three_valued(x: Three) -> Three {
     // CHECK-LABEL: @three_valued
-    // CHECK-NEXT: {{^.*:$}}
-    // CHECK-NEXT: ret i8 %0
+    // CHECK-SAME: (i8{{.*}} [[X:%x]])
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i8 [[X]]
     match x {
         Three::A => Three::A,
         Three::B => Three::B,
@@ -31,8 +32,9 @@ pub fn three_valued(x: Three) -> Three {
 #[no_mangle]
 pub fn four_valued(x: Four) -> Four {
     // CHECK-LABEL: @four_valued
-    // CHECK-NEXT: {{^.*:$}}
-    // CHECK-NEXT: ret i16 %0
+    // CHECK-SAME: (i16{{.*}} [[X:%x]])
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i16 [[X]]
     match x {
         Four::A => Four::A,
         Four::B => Four::B,

tests/codegen/try_question_mark_nop.rs

@@ -1,10 +1,5 @@
 //@ compile-flags: -O -Z merge-functions=disabled --edition=2021
 //@ only-x86_64
-// FIXME: Remove the `min-llvm-version`.
-//@ revisions: NINETEEN TWENTY
-//@[NINETEEN] min-llvm-version: 19
-//@[NINETEEN] ignore-llvm-version: 20-99
-//@[TWENTY] min-llvm-version: 20
 
 #![crate_type = "lib"]
 #![feature(try_blocks)]
@@ -16,10 +11,7 @@ use std::ptr::NonNull;
 #[no_mangle]
 pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
     // CHECK: start:
-    // NINETEEN-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %0 to i1
-    // NINETEEN-NEXT: [[FIRST:%.*]] = select i1 [[TRUNC]], i32 %0
-    // NINETEEN-NEXT: insertvalue { i32, i32 } poison, i32 [[FIRST]], 0
-    // TWENTY-NEXT: insertvalue { i32, i32 } poison, i32 %0, 0
+    // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: insertvalue { i32, i32 }
     // CHECK-NEXT: ret { i32, i32 }
     match x {

tests/mir-opt/merge_br/merge_br.no_fields.MergeBranchSimplification.diff

@@ -0,0 +1,34 @@
+- // MIR for `no_fields` before MergeBranchSimplification
++ // MIR for `no_fields` after MergeBranchSimplification
+  
+  fn no_fields(_1: NoFields) -> NoFields {
+      debug a => _1;
+      let mut _0: NoFields;
+      let mut _2: isize;
+  
+      bb0: {
+          _2 = discriminant(_1);
+-         switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1];
++         _0 = copy _1;
++         goto -> bb1;
+      }
+  
+      bb1: {
+-         unreachable;
+-     }
+- 
+-     bb2: {
+-         _0 = NoFields::B;
+-         goto -> bb4;
+-     }
+- 
+-     bb3: {
+-         _0 = NoFields::A;
+-         goto -> bb4;
+-     }
+- 
+-     bb4: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.no_fields_failed.MergeBranchSimplification.diff

@@ -0,0 +1,32 @@
+- // MIR for `no_fields_failed` before MergeBranchSimplification
++ // MIR for `no_fields_failed` after MergeBranchSimplification
+  
+  fn no_fields_failed(_1: NoFields) -> NoFields {
+      debug a => _1;
+      let mut _0: NoFields;
+      let mut _2: isize;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = NoFields::A;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = NoFields::B;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.no_fields_mismatch_type_failed.MergeBranchSimplification.diff

@@ -0,0 +1,32 @@
+- // MIR for `no_fields_mismatch_type_failed` before MergeBranchSimplification
++ // MIR for `no_fields_mismatch_type_failed` after MergeBranchSimplification
+  
+  fn no_fields_mismatch_type_failed(_1: NoFields) -> NoFields2 {
+      debug a => _1;
+      let mut _0: NoFields2;
+      let mut _2: isize;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = NoFields2::B;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = NoFields2::A;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.no_fields_ref.MergeBranchSimplification.diff

@@ -0,0 +1,34 @@
+- // MIR for `no_fields_ref` before MergeBranchSimplification
++ // MIR for `no_fields_ref` after MergeBranchSimplification
+  
+  fn no_fields_ref(_1: &NoFields) -> NoFields {
+      debug a => _1;
+      let mut _0: NoFields;
+      let mut _2: isize;
+  
+      bb0: {
+          _2 = discriminant((*_1));
+-         switchInt(move _2) -> [0: bb3, 1: bb2, otherwise: bb1];
++         _0 = copy (*_1);
++         goto -> bb1;
+      }
+  
+      bb1: {
+-         unreachable;
+-     }
+- 
+-     bb2: {
+-         _0 = NoFields::B;
+-         goto -> bb4;
+-     }
+- 
+-     bb3: {
+-         _0 = NoFields::A;
+-         goto -> bb4;
+-     }
+- 
+-     bb4: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.option.MergeBranchSimplification.diff

@@ -0,0 +1,41 @@
+- // MIR for `option` before MergeBranchSimplification
++ // MIR for `option` after MergeBranchSimplification
+  
+  fn option(_1: Option<i32>) -> Option<i32> {
+      debug a => _1;
+      let mut _0: std::option::Option<i32>;
+      let mut _2: isize;
+      let _3: i32;
+      scope 1 {
+          debug _b => _3;
+      }
+  
+      bb0: {
+          _2 = discriminant(_1);
+-         switchInt(move _2) -> [0: bb2, 1: bb3, otherwise: bb1];
+-     }
+- 
+-     bb1: {
+-         unreachable;
+-     }
+- 
+-     bb2: {
+-         _0 = Option::<i32>::None;
+-         goto -> bb4;
+-     }
+- 
+-     bb3: {
+-         StorageLive(_3);
+-         _3 = copy ((_1 as Some).0: i32);
+          _0 = copy _1;
+-         StorageDead(_3);
+-         goto -> bb4;
++         goto -> bb1;
+      }
+  
+-     bb4: {
++     bb1: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.option_dse_failed.MergeBranchSimplification.diff

@@ -0,0 +1,34 @@
+- // MIR for `option_dse_failed` before MergeBranchSimplification
++ // MIR for `option_dse_failed` after MergeBranchSimplification
+  
+  fn option_dse_failed(_1: Option<i32>, _2: &mut i32) -> Option<i32> {
+      debug a => _1;
+      debug b => _2;
+      let mut _0: std::option::Option<i32>;
+      let mut _3: isize;
+  
+      bb0: {
+          _3 = discriminant(_1);
+          switchInt(move _3) -> [0: bb2, 1: bb3, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = Option::<i32>::None;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          (*_2) = const 1_i32;
+          _0 = copy _1;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  

tests/mir-opt/merge_br/merge_br.rs

@@ -0,0 +1,90 @@
+//@ test-mir-pass: MergeBranchSimplification
+//@ compile-flags: -Cdebuginfo=2
+
+pub enum NoFields {
+    A,
+    B,
+}
+
+pub enum NoFields2 {
+    A,
+    B,
+}
+
+// EMIT_MIR merge_br.no_fields.MergeBranchSimplification.diff
+pub fn no_fields(a: NoFields) -> NoFields {
+    // CHECK-LABEL: no_fields(
+    // CHECK: bb0: {
+    // CHECK-NEXT: _{{.*}} = discriminant([[SRC:_1]]);
+    // CHECK-NEXT: _0 = copy [[SRC]];
+    // CHECK-NEXT return;
+    match a {
+        NoFields::A => NoFields::A,
+        NoFields::B => NoFields::B,
+    }
+}
+
+// EMIT_MIR merge_br.no_fields_ref.MergeBranchSimplification.diff
+pub fn no_fields_ref(a: &NoFields) -> NoFields {
+    // CHECK-LABEL: no_fields_ref(
+    // CHECK: bb0: {
+    // CHECK-NEXT: _{{.*}} = discriminant([[SRC:\(\*_1\)]]);
+    // CHECK-NEXT: _0 = copy [[SRC]];
+    // CHECK-NEXT return;
+    match a {
+        NoFields::A => NoFields::A,
+        NoFields::B => NoFields::B,
+    }
+}
+
+// EMIT_MIR merge_br.no_fields_mismatch_type_failed.MergeBranchSimplification.diff
+pub fn no_fields_mismatch_type_failed(a: NoFields) -> NoFields2 {
+    // CHECK-LABEL: no_fields_mismatch_type_failed(
+    // CHECK: bb0: {
+    // CHECK-NEXT: _{{.*}} = discriminant([[SRC:_1]]);
+    // CHECK-NOT: _0 = copy [[SRC]];
+    match a {
+        NoFields::A => NoFields2::A,
+        NoFields::B => NoFields2::B,
+    }
+}
+
+// EMIT_MIR merge_br.no_fields_failed.MergeBranchSimplification.diff
+pub fn no_fields_failed(a: NoFields) -> NoFields {
+    // CHECK-LABEL: no_fields_failed(
+    // CHECK: bb0: {
+    // CHECK-NEXT: _{{.*}} = discriminant([[SRC:_1]]);
+    // CHECK-NOT: _0 = copy [[SRC]];
+    match a {
+        NoFields::A => NoFields::B,
+        NoFields::B => NoFields::A,
+    }
+}
+
+// EMIT_MIR merge_br.option.MergeBranchSimplification.diff
+pub fn option(a: Option<i32>) -> Option<i32> {
+    // CHECK-LABEL: option(
+    // CHECK: bb0: {
+    // CHECK-NEXT: _{{.*}} = discriminant([[SRC:_1]]);
+    // CHECK-NEXT: _0 = copy [[SRC]];
+    // CHECK-NEXT return;
+    match a {
+        Some(_b) => a,
+        None => None,
+    }
+}
+
+// EMIT_MIR merge_br.option_dse_failed.MergeBranchSimplification.diff
+pub fn option_dse_failed(a: Option<i32>, b: &mut i32) -> Option<i32> {
+    // CHECK-LABEL: option_dse_failed(
+    // CHECK: bb0: {
+    // CHECK-NEXT: [[DISCR:_.*]] = discriminant([[SRC:_1]]);
+    // CHECK-NEXT: switchInt(move [[DISCR]])
+    match a {
+        Some(_) => {
+            *b = 1;
+            a
+        }
+        None => None,
+    }
+}

tests/mir-opt/pre-codegen/clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir

@@ -5,22 +5,23 @@ fn enum_clone_as_copy(_1: &Enum1) -> Enum1 {
     let mut _0: Enum1;
     scope 1 (inlined <Enum1 as Clone>::clone) {
         debug self => _1;
-        let mut _2: isize;
+        let _2: &AllCopy;
         let mut _3: &AllCopy;
-        let mut _4: &NestCopy;
+        let _4: &NestCopy;
+        let mut _5: &NestCopy;
         scope 2 {
-            debug __self_0 => _3;
+            debug __self_0 => _2;
             scope 6 (inlined <AllCopy as Clone>::clone) {
                 debug self => _3;
             }
         }
         scope 3 {
             debug __self_0 => _4;
             scope 4 (inlined <NestCopy as Clone>::clone) {
-                debug self => _4;
-                let _5: &AllCopy;
+                debug self => _5;
+                let _6: &AllCopy;
                 scope 5 (inlined <AllCopy as Clone>::clone) {
-                    debug self => _5;
+                    debug self => _6;
                 }
             }
         }
@@ -30,33 +31,14 @@ fn enum_clone_as_copy(_1: &Enum1) -> Enum1 {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_4);
-        _2 = discriminant((*_1));
-        switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4];
-    }
-
-    bb1: {
-        _3 = &(((*_1) as A).0: AllCopy);
-        _0 = copy (*_1);
-        goto -> bb3;
-    }
-
-    bb2: {
-        _4 = &(((*_1) as B).0: NestCopy);
         StorageLive(_5);
-        _5 = &((((*_1) as B).0: NestCopy).1: AllCopy);
-        StorageDead(_5);
+        StorageLive(_6);
         _0 = copy (*_1);
-        goto -> bb3;
-    }
-
-    bb3: {
+        StorageDead(_6);
+        StorageDead(_5);
         StorageDead(_4);
         StorageDead(_3);
         StorageDead(_2);
         return;
     }
-
-    bb4: {
-        unreachable;
-    }
 }

tests/mir-opt/pre-codegen/clone_as_copy.rs

@@ -32,12 +32,12 @@ fn clone_as_copy(v: &NestCopy) -> NestCopy {
     v.clone()
 }
 
-// FIXME: We can merge into exactly one assignment statement.
+// We can merge into exactly one assignment statement.
 // EMIT_MIR clone_as_copy.enum_clone_as_copy.PreCodegen.after.mir
 fn enum_clone_as_copy(v: &Enum1) -> Enum1 {
     // CHECK-LABEL: fn enum_clone_as_copy(
     // CHECK-NOT: = Enum1::
     // CHECK: _0 = copy (*_1);
-    // CHECK: _0 = copy (*_1);
+    // CHECK-NOT: _0 = copy (*_1);
     v.clone()
 }

tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir

@@ -3,38 +3,17 @@
 fn old(_1: Result<T, E>) -> Result<T, E> {
     debug x => _1;
     let mut _0: std::result::Result<T, E>;
-    let mut _2: isize;
-    let _3: T;
-    let _4: E;
+    let _2: T;
+    let _3: E;
     scope 1 {
-        debug v => _3;
+        debug v => _2;
     }
     scope 2 {
-        debug e => _4;
+        debug e => _3;
     }
 
     bb0: {
-        _2 = discriminant(_1);
-        switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4];
-    }
-
-    bb1: {
-        _3 = copy ((_1 as Ok).0: T);
-        _0 = copy _1;
-        goto -> bb3;
-    }
-
-    bb2: {
-        _4 = copy ((_1 as Err).0: E);
         _0 = copy _1;
-        goto -> bb3;
-    }
-
-    bb3: {
         return;
     }
-
-    bb4: {
-        unreachable;
-    }
 }