Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1

I also added test cases to make sure the optimization can fire on all of
these cases:

```rust
fn case_1(o: Option<u8>) -> Option<u8> {
  match o {
    Some(u) => Some(u),
    None => None,
  }
}

fn case2(r: Result<u8, i32>) -> Result<u8, i32> {
  match r {
    Ok(u) => Ok(u),
    Err(i) => Err(i),
  }
}

fn case3(r: Result<u8, i32>) -> Result<u8, i32> {
  let u = r?;
  Ok(u)
}

```

Without MIR inlining, this still does not completely optimize away the
`?` operator because the `Try::into_result()`, `From::from()` and
`Try::from_error()` calls still exist. This does move us a bit closer to
that goal though because:

- We can now run the pass on mir-opt-level=1

- We no longer depend on the copy propagation pass running which is
  unlikely to stabilize anytime soon.

Author: wesleywiser

src/librustc_mir/transform/mod.rs

@@ -311,12 +311,11 @@ fn run_optimization_passes<'tcx>(
             &const_prop::ConstProp,
             &simplify_branches::SimplifyBranches::new("after-const-prop"),
             &deaggregator::Deaggregator,
+            &simplify_try::SimplifyArmIdentity,
+            &simplify_try::SimplifyBranchSame,
             &copy_prop::CopyPropagation,
             &simplify_branches::SimplifyBranches::new("after-copy-prop"),
             &remove_noop_landing_pads::RemoveNoopLandingPads,
-            &simplify::SimplifyCfg::new("after-remove-noop-landing-pads"),
-            &simplify_try::SimplifyArmIdentity,
-            &simplify_try::SimplifyBranchSame,
             &simplify::SimplifyCfg::new("final"),
             &simplify::SimplifyLocals,
             &add_call_guards::CriticalCallEdges,

src/librustc_mir/transform/simplify_try.rs

@@ -13,15 +13,19 @@ use crate::transform::{simplify, MirPass, MirSource};
 use itertools::Itertools as _;
 use rustc::mir::*;
 use rustc::ty::{Ty, TyCtxt};
+use rustc_index::vec::IndexVec;
 use rustc_target::abi::VariantIdx;
+use std::iter::{Enumerate, Peekable};
+use std::slice::Iter;
 
 /// Simplifies arms of form `Variant(x) => Variant(x)` to just a move.
 ///
 /// This is done by transforming basic blocks where the statements match:
 ///
 /// ```rust
 /// _LOCAL_TMP = ((_LOCAL_1 as Variant ).FIELD: TY );
-/// ((_LOCAL_0 as Variant).FIELD: TY) = move _LOCAL_TMP;
+/// _TMP_2 = _LOCAL_TMP;
+/// ((_LOCAL_0 as Variant).FIELD: TY) = move _TMP_2;
 /// discriminant(_LOCAL_0) = VAR_IDX;
 /// ```
 ///
@@ -32,50 +36,306 @@ use rustc_target::abi::VariantIdx;
 /// ```
 pub struct SimplifyArmIdentity;
 
+#[derive(Debug)]
+struct ArmIdentityInfo<'tcx> {
+    /// Storage location for the variant's field
+    local_temp_0: Local,
+    /// Storage location holding the variant being read from
+    local_1: Local,
+    /// The variant field being read from
+    vf_s0: VarField<'tcx>,
+    /// Index of the statement which loads the variant being read
+    get_variant_field_stmt: usize,
+
+    /// Tracks each assignment to a temporary of the variant's field
+    field_tmp_assignments: Vec<(Local, Local)>,
+
+    /// Storage location holding the variant's field that was read from
+    local_tmp_s1: Local,
+    /// Storage location holding the enum that we are writing to
+    local_0: Local,
+    /// The variant field being written to
+    vf_s1: VarField<'tcx>,
+
+    /// Storage location that the discriminant is being written to
+    set_discr_local: Local,
+    /// The variant being written
+    set_discr_var_idx: VariantIdx,
+
+    /// Index of the statement that should be overwritten as a move
+    stmt_to_overwrite: usize,
+    /// SourceInfo for the new move
+    source_info: SourceInfo,
+
+    /// Indices of matching Storage{Live,Dead} statements encountered.
+    /// (StorageLive index,, StorageDead index, Local)
+    storage_stmts: Vec<(usize, usize, Local)>,
+
+    /// The statements that should be removed (turned into nops)
+    stmts_to_remove: Vec<usize>,
+}
+
+fn get_arm_identity_info<'a, 'tcx>(stmts: &'a [Statement<'tcx>]) -> Option<ArmIdentityInfo<'tcx>> {
+    // This can't possibly match unless there are at least 3 statements in the block
+    // so fail fast on tiny blocks.
+    if stmts.len() < 3 {
+        return None;
+    }
+
+    let mut tmp_assigns = Vec::new();
+    let mut nop_stmts = Vec::new();
+    let mut storage_stmts = Vec::new();
+    let mut storage_live_stmts = Vec::new();
+    let mut storage_dead_stmts = Vec::new();
+
+    type StmtIter<'a, 'tcx> = Peekable<Enumerate<Iter<'a, Statement<'tcx>>>>;
+
+    fn is_storage_stmt<'tcx>(stmt: &Statement<'tcx>) -> bool {
+        matches!(stmt.kind, StatementKind::StorageLive(_) | StatementKind::StorageDead(_))
+    }
+
+    fn try_eat_storage_stmts<'a, 'tcx>(
+        stmt_iter: &mut StmtIter<'a, 'tcx>,
+        storage_live_stmts: &mut Vec<(usize, Local)>,
+        storage_dead_stmts: &mut Vec<(usize, Local)>,
+    ) {
+        while stmt_iter.peek().map(|(_, stmt)| is_storage_stmt(stmt)).unwrap_or(false) {
+            let (idx, stmt) = stmt_iter.next().unwrap();
+
+            if let StatementKind::StorageLive(l) = stmt.kind {
+                storage_live_stmts.push((idx, l));
+            } else if let StatementKind::StorageDead(l) = stmt.kind {
+                storage_dead_stmts.push((idx, l));
+            }
+        }
+    }
+
+    fn is_tmp_storage_stmt<'tcx>(stmt: &Statement<'tcx>) -> bool {
+        if let StatementKind::Assign(box (place, Rvalue::Use(op))) = &stmt.kind {
+            if let Operand::Copy(p) | Operand::Move(p) = op {
+                return place.as_local().is_some() && p.as_local().is_some();
+            }
+        }
+
+        false
+    }
+
+    fn try_eat_assign_tmp_stmts<'a, 'tcx>(
+        stmt_iter: &mut StmtIter<'a, 'tcx>,
+        tmp_assigns: &mut Vec<(Local, Local)>,
+        nop_stmts: &mut Vec<usize>,
+    ) {
+        while stmt_iter.peek().map(|(_, stmt)| is_tmp_storage_stmt(stmt)).unwrap_or(false) {
+            let (idx, stmt) = stmt_iter.next().unwrap();
+
+            if let StatementKind::Assign(box (place, Rvalue::Use(op))) = &stmt.kind {
+                if let Operand::Copy(p) | Operand::Move(p) = op {
+                    tmp_assigns.push((place.as_local().unwrap(), p.as_local().unwrap()));
+                    nop_stmts.push(idx);
+                }
+            }
+        }
+    }
+
+    fn find_storage_live_dead_stmts_for_local<'tcx>(
+        l: Local,
+        stmts: &[Statement<'tcx>],
+    ) -> Option<(usize, usize)> {
+        trace!("looking for {:?}", l);
+        let mut storage_live_stmt = None;
+        let mut storage_dead_stmt = None;
+        for (idx, stmt) in stmts.iter().enumerate() {
+            if stmt.kind == StatementKind::StorageLive(l) {
+                storage_live_stmt = Some(idx);
+            } else if stmt.kind == StatementKind::StorageDead(l) {
+                storage_dead_stmt = Some(idx);
+            }
+        }
+
+        Some((storage_live_stmt?, storage_dead_stmt.unwrap_or(usize::MAX)))
+    }
+
+    // Try to match the expected MIR structure with the basic block we're processing.
+    // We want to see something that looks like:
+    // ```
+    // (StorageLive(_) | StorageDead(_));*
+    // _LOCAL_INTO = ((_LOCAL_FROM as Variant).FIELD: TY);
+    // (StorageLive(_) | StorageDead(_));*
+    // (tmp_n+1 = tmp_n);*
+    // (StorageLive(_) | StorageDead(_));*
+    // (tmp_n+1 = tmp_n);*
+    // ((LOCAL_FROM as Variant).FIELD: TY) = move tmp;
+    // discriminant(LOCAL_FROM) = VariantIdx;
+    // (StorageLive(_) | StorageDead(_));*
+    // ```
+    let mut stmt_iter = stmts.iter().enumerate().peekable();
+
+    try_eat_storage_stmts(&mut stmt_iter, &mut storage_live_stmts, &mut storage_dead_stmts);
+
+    let (get_variant_field_stmt, stmt) = stmt_iter.next()?;
+    let (local_tmp_s0, local_1, vf_s0) = match_get_variant_field(stmt)?;
+
+    try_eat_storage_stmts(&mut stmt_iter, &mut storage_live_stmts, &mut storage_dead_stmts);
+
+    try_eat_assign_tmp_stmts(&mut stmt_iter, &mut tmp_assigns, &mut nop_stmts);
+
+    try_eat_storage_stmts(&mut stmt_iter, &mut storage_live_stmts, &mut storage_dead_stmts);
+
+    try_eat_assign_tmp_stmts(&mut stmt_iter, &mut tmp_assigns, &mut nop_stmts);
+
+    let (idx, stmt) = stmt_iter.next()?;
+    let (local_tmp_s1, local_0, vf_s1) = match_set_variant_field(stmt)?;
+    nop_stmts.push(idx);
+
+    let (idx, stmt) = stmt_iter.next()?;
+    let (set_discr_local, set_discr_var_idx) = match_set_discr(stmt)?;
+    let discr_stmt_source_info = stmt.source_info;
+    nop_stmts.push(idx);
+
+    try_eat_storage_stmts(&mut stmt_iter, &mut storage_live_stmts, &mut storage_dead_stmts);
+
+    for (live_idx, live_local) in storage_live_stmts {
+        if let Some(i) = storage_dead_stmts.iter().rposition(|(_, l)| *l == live_local) {
+            let (dead_idx, _) = storage_dead_stmts.swap_remove(i);
+            storage_stmts.push((live_idx, dead_idx, live_local));
+
+            if live_local == local_tmp_s0 {
+                nop_stmts.push(get_variant_field_stmt);
+            }
+        }
+    }
+
+    nop_stmts.sort();
+
+    // Use one of the statements we're going to discard between the point
+    // where the storage location for the variant field becomes live and
+    // is killed.
+    let (live_idx, daed_idx) = find_storage_live_dead_stmts_for_local(local_tmp_s0, stmts)?;
+    let stmt_to_overwrite =
+        nop_stmts.iter().find(|stmt_idx| live_idx < **stmt_idx && **stmt_idx < daed_idx);
+
+    Some(ArmIdentityInfo {
+        local_temp_0: local_tmp_s0,
+        local_1,
+        vf_s0,
+        get_variant_field_stmt,
+        field_tmp_assignments: tmp_assigns,
+        local_tmp_s1,
+        local_0,
+        vf_s1,
+        set_discr_local,
+        set_discr_var_idx,
+        stmt_to_overwrite: *stmt_to_overwrite?,
+        source_info: discr_stmt_source_info,
+        storage_stmts,
+        stmts_to_remove: nop_stmts,
+    })
+}
+
+fn optimization_applies<'tcx>(
+    opt_info: &ArmIdentityInfo<'tcx>,
+    local_decls: &IndexVec<Local, LocalDecl<'tcx>>,
+) -> bool {
+    trace!("testing if optimization applies...");
+
+    // FIXME(wesleywiser): possible relax this restriction?
+    if opt_info.local_0 == opt_info.local_1 {
+        trace!("NO: moving into ourselves");
+        return false;
+    } else if opt_info.vf_s0 != opt_info.vf_s1 {
+        trace!("NO: the field-and-variant information do not match");
+        return false;
+    } else if local_decls[opt_info.local_0].ty != local_decls[opt_info.local_1].ty {
+        // FIXME(Centril,oli-obk): possibly relax to same layout?
+        trace!("NO: source and target locals have different types");
+        return false;
+    } else if (opt_info.local_0, opt_info.vf_s0.var_idx)
+        != (opt_info.set_discr_local, opt_info.set_discr_var_idx)
+    {
+        trace!("NO: the discriminants do not match");
+        return false;
+    }
+
+    // Verify the assigment chain consists of the form b = a; c = b; d = c; etc...
+    if opt_info.field_tmp_assignments.len() == 0 {
+        trace!("NO: no assignments found");
+    }
+    let mut last_assigned_to = opt_info.field_tmp_assignments[0].1;
+    let source_local = last_assigned_to;
+    for (l, r) in &opt_info.field_tmp_assignments {
+        if *r != last_assigned_to {
+            trace!("NO: found unexpected assignment {:?} = {:?}", l, r);
+            return false;
+        }
+
+        last_assigned_to = *l;
+    }
+
+    if source_local != opt_info.local_temp_0 {
+        trace!(
+            "NO: start of assignment chain does not match enum variant temp: {:?} != {:?}",
+            source_local,
+            opt_info.local_temp_0
+        );
+        return false;
+    } else if last_assigned_to != opt_info.local_tmp_s1 {
+        trace!(
+            "NO: end of assignemnt chain does not match written enum temp: {:?} != {:?}",
+            last_assigned_to,
+            opt_info.local_tmp_s1
+        );
+        return false;
+    }
+
+    trace!("SUCCESS: optimization applies!");
+    return true;
+}
+
 impl<'tcx> MirPass<'tcx> for SimplifyArmIdentity {
-    fn run_pass(&self, _: TyCtxt<'tcx>, _: MirSource<'tcx>, body: &mut BodyAndCache<'tcx>) {
+    fn run_pass(&self, _: TyCtxt<'tcx>, source: MirSource<'tcx>, body: &mut BodyAndCache<'tcx>) {
+        trace!("running SimplifyArmIdentity on {:?}", source);
         let (basic_blocks, local_decls) = body.basic_blocks_and_local_decls_mut();
         for bb in basic_blocks {
-            // Need 3 statements:
-            let (s0, s1, s2) = match &mut *bb.statements {
-                [s0, s1, s2] => (s0, s1, s2),
-                _ => continue,
-            };
+            if let Some(opt_info) = get_arm_identity_info(&bb.statements) {
+                trace!("got opt_info = {:#?}", opt_info);
+                if !optimization_applies(&opt_info, local_decls) {
+                    debug!("optimization skipped for {:?}", source);
+                    continue;
+                }
 
-            // Pattern match on the form we want:
-            let (local_tmp_s0, local_1, vf_s0) = match match_get_variant_field(s0) {
-                None => continue,
-                Some(x) => x,
-            };
-            let (local_tmp_s1, local_0, vf_s1) = match match_set_variant_field(s1) {
-                None => continue,
-                Some(x) => x,
-            };
-            if local_tmp_s0 != local_tmp_s1
-                // Avoid moving into ourselves.
-                || local_0 == local_1
-                // The field-and-variant information match up.
-                || vf_s0 != vf_s1
-                // Source and target locals have the same type.
-                // FIXME(Centril | oli-obk): possibly relax to same layout?
-                || local_decls[local_0].ty != local_decls[local_1].ty
-                // We're setting the discriminant of `local_0` to this variant.
-                || Some((local_0, vf_s0.var_idx)) != match_set_discr(s2)
-            {
-                continue;
-            }
+                // Also remove unused Storage{Live,Dead} statements which correspond
+                // to temps used previously.
+                for (live_idx, dead_idx, local) in &opt_info.storage_stmts {
+                    // The temporary that we've read the variant field into is scoped to this block,
+                    // so we can remove the assignment.
+                    if *local == opt_info.local_temp_0 {
+                        bb.statements[opt_info.get_variant_field_stmt].make_nop();
+                    }
 
-            // Right shape; transform!
-            s0.source_info = s2.source_info;
-            match &mut s0.kind {
-                StatementKind::Assign(box (place, rvalue)) => {
-                    *place = local_0.into();
-                    *rvalue = Rvalue::Use(Operand::Move(local_1.into()));
+                    for (left, right) in &opt_info.field_tmp_assignments {
+                        if local == left || local == right {
+                            bb.statements[*live_idx].make_nop();
+                            bb.statements[*dead_idx].make_nop();
+                        }
+                    }
                 }
-                _ => unreachable!(),
+
+                // Right shape; transform
+                for stmt_idx in opt_info.stmts_to_remove {
+                    bb.statements[stmt_idx].make_nop();
+                }
+
+                let stmt = &mut bb.statements[opt_info.stmt_to_overwrite];
+                stmt.source_info = opt_info.source_info;
+                stmt.kind = StatementKind::Assign(box (
+                    opt_info.local_0.into(),
+                    Rvalue::Use(Operand::Move(opt_info.local_1.into())),
+                ));
+
+                bb.statements.retain(|stmt| stmt.kind != StatementKind::Nop);
+
+                trace!("block is now {:?}", bb.statements);
             }
-            s1.make_nop();
-            s2.make_nop();
         }
     }
 }
@@ -129,7 +389,7 @@ fn match_set_discr<'tcx>(stmt: &Statement<'tcx>) -> Option<(Local, VariantIdx)>
     }
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Debug)]
 struct VarField<'tcx> {
     field: Field,
     field_ty: Ty<'tcx>,

src/test/mir-opt/simplify-arm-identity.rs

@@ -39,9 +39,14 @@ fn main() {
 //     }
 //     ...
 //     bb3: {
+//         StorageLive(_4);
 //         _4 = ((_1 as Foo).0: u8);
-//         ((_2 as Foo).0: u8) = move _4;
+//         StorageLive(_5);
+//         _5 = _4;
+//         ((_2 as Foo).0: u8) = move _5;
 //         discriminant(_2) = 0;
+//         StorageDead(_5);
+//         StorageDead(_4);
 //         goto -> bb4;
 //     }
 //     ...
@@ -65,9 +70,14 @@ fn main() {
 //     }
 //     ...
 //     bb3: {
+//         StorageLive(_4);
 //         _4 = ((_1 as Foo).0: u8);
-//         ((_2 as Foo).0: u8) = move _4;
+//         StorageLive(_5);
+//         _5 = _4;
+//         ((_2 as Foo).0: u8) = move _5;
 //         discriminant(_2) = 0;
+//         StorageDead(_5);
+//         StorageDead(_4);
 //         goto -> bb4;
 //     }
 //     ...

src/test/mir-opt/simplify-arm.rs

@@ -0,0 +1,380 @@
+// compile-flags: -Z mir-opt-level=1
+
+fn id(o: Option<u8>) -> Option<u8> {
+    match o {
+        Some(v) => Some(v),
+        None => None,
+    }
+}
+
+fn id_result(r: Result<u8, i32>) -> Result<u8, i32> {
+    match r {
+        Ok(x) => Ok(x),
+        Err(y) => Err(y),
+    }
+}
+
+fn id_try(r: Result<u8, i32>) -> Result<u8, i32> {
+    let x = r?;
+    Ok(x)
+}
+
+fn main() {
+    id(None);
+    id_result(Ok(4));
+    id_try(Ok(4));
+}
+
+// END RUST SOURCE
+// START rustc.id.SimplifyArmIdentity.before.mir
+// debug o => _1;
+// let mut _0: std::option::Option<u8>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// scope 1 {
+//   debug v => _3;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   switchInt(move _2) -> [0isize: bb1, 1isize: bb3, otherwise: bb2];
+// }
+// bb1: {
+//   discriminant(_0) = 0;
+//   goto -> bb4;
+// }
+// bb2: {
+//   unreachable;
+// }
+// bb3: {
+//   StorageLive(_3);
+//   _3 = ((_1 as Some).0: u8);
+//   StorageLive(_4);
+//   _4 = _3;
+//   ((_0 as Some).0: u8) = move _4;
+//   discriminant(_0) = 1;
+//   StorageDead(_4);
+//   StorageDead(_3);
+//   goto -> bb4;
+// }
+// bb4: {
+//   return;
+// }
+// END rustc.id.SimplifyArmIdentity.before.mir
+// START rustc.id.SimplifyArmIdentity.after.mir
+// debug o => _1;
+// let mut _0: std::option::Option<u8>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// scope 1 {
+//   debug v => _3;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   switchInt(move _2) -> [0isize: bb1, 1isize: bb3, otherwise: bb2];
+// }
+// bb1: {
+//   discriminant(_0) = 0;
+//   goto -> bb4;
+// }
+// bb2: {
+//   unreachable;
+// }
+// bb3: {
+//   _0 = move _1;
+//   goto -> bb4;
+// }
+// bb4: {
+//   return;
+// }
+// END rustc.id.SimplifyArmIdentity.after.mir
+
+// START rustc.id_result.SimplifyArmIdentity.before.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// let _5: i32;
+// let mut _6: i32;
+// scope 1 {
+//   debug x => _3;
+// }
+// scope 2 {
+//   debug y => _5;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   switchInt(move _2) -> [0isize: bb3, 1isize: bb1, otherwise: bb2];
+// }
+// bb1: {
+//   StorageLive(_5);
+//   _5 = ((_1 as Err).0: i32);
+//   StorageLive(_6);
+//   _6 = _5;
+//   ((_0 as Err).0: i32) = move _6;
+//   discriminant(_0) = 1;
+//   StorageDead(_6);
+//   StorageDead(_5);
+//   goto -> bb4;
+// }
+// bb2: {
+//   unreachable;
+// }
+// bb3: {
+//   StorageLive(_3);
+//   _3 = ((_1 as Ok).0: u8);
+//   StorageLive(_4);
+//   _4 = _3;
+//   ((_0 as Ok).0: u8) = move _4;
+//   discriminant(_0) = 0;
+//   StorageDead(_4);
+//   StorageDead(_3);
+//   goto -> bb4;
+// }
+// bb4: {
+//   return;
+// }
+// END rustc.id_result.SimplifyArmIdentity.before.mir
+// START rustc.id_result.SimplifyArmIdentity.after.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// let _5: i32;
+// let mut _6: i32;
+// scope 1 {
+//   debug x => _3;
+// }
+// scope 2 {
+//   debug y => _5;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   switchInt(move _2) -> [0isize: bb3, 1isize: bb1, otherwise: bb2];
+// }
+// bb1: {
+//   _0 = move _1;
+//   goto -> bb4;
+// }
+// bb2: {
+//   unreachable;
+// }
+// bb3: {
+//   _0 = move _1;
+//   goto -> bb4;
+// }
+// bb4: {
+//   return;
+// }
+// END rustc.id_result.SimplifyArmIdentity.after.mir
+// START rustc.id_result.SimplifyBranchSame.before.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// let _5: i32;
+// let mut _6: i32;
+// scope 1 {
+//   debug x => _3;
+// }
+// scope 2 {
+//   debug y => _5;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   switchInt(move _2) -> [0isize: bb3, 1isize: bb1, otherwise: bb2];
+// }
+// bb1: {
+//   _0 = move _1;
+//   goto -> bb4;
+// }
+// bb2: {
+//   unreachable;
+// }
+// bb3: {
+//   _0 = move _1;
+//   goto -> bb4;
+// }
+// bb4: {
+//   return;
+// }
+// END rustc.id_result.SimplifyBranchSame.before.mir
+// START rustc.id_result.SimplifyBranchSame.after.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let mut _2: isize;
+// let _3: u8;
+// let mut _4: u8;
+// let _5: i32;
+// let mut _6: i32;
+// scope 1 {
+//   debug x => _3;
+// }
+// scope 2 {
+//   debug y => _5;
+// }
+// bb0: {
+//   _2 = discriminant(_1);
+//   goto -> bb1;
+// }
+// bb1: {
+//   _0 = move _1;
+//   goto -> bb2;
+// }
+// bb2: {
+//   return;
+// }
+// END rustc.id_result.SimplifyBranchSame.after.mir
+
+// START rustc.id_try.SimplifyArmIdentity.before.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let _2: u8;
+// let mut _3: std::result::Result<u8, i32>;
+// let mut _4: std::result::Result<u8, i32>;
+// let mut _5: isize;
+// let _6: i32;
+// let mut _7: !;
+// let mut _8: i32;
+// let mut _9: i32;
+// let _10: u8;
+// let mut _11: u8;
+// scope 1 {
+//   debug x => _2;
+// }
+// scope 2 {
+//   debug err => _6;
+//   scope 3 {
+//   }
+// }
+// scope 4 {
+//   debug val => _10;
+//   scope 5 {
+//   }
+// }
+// bb0: {
+//   StorageLive(_2);
+//   StorageLive(_3);
+//   StorageLive(_4);
+//   _4 = _1;
+//   _3 = const <std::result::Result<u8, i32> as std::ops::Try>::into_result(move _4) -> bb1;
+// }
+// bb1: {
+//   StorageDead(_4);
+//   _5 = discriminant(_3);
+//   switchInt(move _5) -> [0isize: bb2, 1isize: bb4, otherwise: bb3];
+// }
+// bb2: {
+//   StorageLive(_10);
+//   _10 = ((_3 as Ok).0: u8);
+//   _2 = _10;
+//   StorageDead(_10);
+//   StorageDead(_3);
+//   StorageLive(_11);
+//   _11 = _2;
+//   ((_0 as Ok).0: u8) = move_ 11;
+//   discriminant(_0) = 0;
+//   StorageDead(_11);
+//   StorageDead(_2);
+//   goto -> bb5;
+// }
+// bb3: {
+//   unreachable;
+// }
+// bb4: {
+//   StorageLive(_6);
+//   _6 = ((_3 as Err).0: i32);
+//   StorageLive(_8);
+//   StorageLive(_9);
+//   _9 = _6;
+//   _8 = const <i32 as std::convert::From<i32>>::from(move _9) -> bb6;
+// }
+// bb5: {
+//   return;
+// }
+// bb6: {
+//   StorageDead(_9);
+//   _0 = const <std::result::Result<u8, i32> as std::ops::Try>::from_error(move _8) -> bb7;
+// }
+// bb7: {
+//   StorageDead(_8);
+//   StorageDead(_6);
+//   StorageDead(_3);
+//   StorageDead(_2);
+//   goto -> bb5;
+// }
+// END rustc.id_try.SimplifyArmIdentity.before.mir
+// START rustc.id_try.SimplifyArmIdentity.after.mir
+// debug r => _1;
+// let mut _0: std::result::Result<u8, i32>;
+// let _2: u8;
+// let mut _3: std::result::Result<u8, i32>;
+// let mut _4: std::result::Result<u8, i32>;
+// let mut _5: isize;
+// let _6: i32;
+// let mut _7: !;
+// let mut _8: i32;
+// let mut _9: i32;
+// let _10: u8;
+// let mut _11: u8;
+// scope 1 {
+//   debug x => _2;
+// }
+// scope 2 {
+//   debug err => _6;
+//   scope 3 {
+//   }
+// }
+// scope 4 {
+//   debug val => _10;
+//   scope 5 {
+//   }
+// }
+// bb0: {
+//   StorageLive(_2);
+//   StorageLive(_3);
+//   StorageLive(_4);
+//   _4 = _1;
+//   _3 = const <std::result::Result<u8, i32> as std::ops::Try>::into_result(move _4) -> bb1;
+// }
+// bb1: {
+//   StorageDead(_4);
+//   _5 = discriminant(_3);
+//   switchInt(move _5) -> [0isize: bb2, 1isize: bb4, otherwise: bb3];
+// }
+// bb2: {
+//   _0 = move _3;
+//   StorageDead(_3);
+//   StorageDead(_2);
+//   goto -> bb5;
+// }
+// bb3: {
+//   unreachable;
+// }
+// bb4: {
+//   StorageLive(_6);
+//   _6 = ((_3 as Err).0: i32);
+//   StorageLive(_8);
+//   StorageLive(_9);
+//   _9 = _6;
+//   _8 = const <i32 as std::convert::From<i32>>::from(move _9) -> bb6;
+// }
+// bb5: {
+//   return;
+// }
+// bb6: {
+//   StorageDead(_9);
+//   _0 = const <std::result::Result<u8, i32> as std::ops::Try>::from_error(move _8) -> bb7;
+// }
+// bb7: {
+//   StorageDead(_8);
+//   StorageDead(_6);
+//   StorageDead(_3);
+//   StorageDead(_2);
+//   goto -> bb5;
+// }
+// END rustc.id_try.SimplifyArmIdentity.after.mir

src/test/mir-opt/simplify_try.rs

@@ -23,16 +23,16 @@ fn main() {
 //     let _10: u32;
 //     let mut _11: u32;
 //     scope 1 {
-//         debug y => _10;
+//         debug y => _2;
 //     }
 //     scope 2 {
 //         debug err => _6;
 //         scope 3 {
 //             scope 7 {
-//                 debug t => _6;
+//                 debug t => _9;
 //             }
 //             scope 8 {
-//                 debug v => _6;
+//                 debug v => _8;
 //                 let mut _12: i32;
 //             }
 //         }
@@ -43,22 +43,49 @@ fn main() {
 //         }
 //     }
 //     scope 6 {
-//         debug self => _1;
+//         debug self => _4;
 //     }
 //     bb0: {
-//         _5 = discriminant(_1);
+//         StorageLive(_2);
+//         StorageLive(_3);
+//         StorageLive(_4);
+//         _4 = _1;
+//         _3 = move _4;
+//         StorageDead(_4);
+//         _5 = discriminant(_3);
 //         switchInt(move _5) -> [0isize: bb1, otherwise: bb2];
 //     }
 //     bb1: {
-//         _10 = ((_1 as Ok).0: u32);
-//         ((_0 as Ok).0: u32) = move _10;
+//         StorageLive(_10);
+//         _10 = ((_3 as Ok).0: u32);
+//         _2 = _10;
+//         StorageDead(_10);
+//         StorageDead(_3);
+//         StorageLive(_11);
+//         _11 = _2;
+//         ((_0 as Ok).0: u32) = move _11;
 //         discriminant(_0) = 0;
+//         StorageDead(_11);
+//         StorageDead(_2);
 //         goto -> bb3;
 //     }
 //     bb2: {
-//         _6 = ((_1 as Err).0: i32);
-//         ((_0 as Err).0: i32) = move _6;
+//         StorageLive(_6);
+//         _6 = ((_3 as Err).0: i32);
+//         StorageLive(_8);
+//         StorageLive(_9);
+//         _9 = _6;
+//         _8 = move _9;
+//         StorageDead(_9);
+//         StorageLive(_12);
+//         _12 = move _8;
+//         ((_0 as Err).0: i32) = move _12;
 //         discriminant(_0) = 1;
+//         StorageDead(_12);
+//         StorageDead(_8);
+//         StorageDead(_6);
+//         StorageDead(_3);
+//         StorageDead(_2);
 //         goto -> bb3;
 //     }
 //     bb3: {
@@ -82,16 +109,16 @@ fn main() {
 //     let _10: u32;
 //     let mut _11: u32;
 //     scope 1 {
-//         debug y => _10;
+//         debug y => _2;
 //     }
 //     scope 2 {
 //         debug err => _6;
 //         scope 3 {
 //             scope 7 {
-//                 debug t => _6;
+//                 debug t => _9;
 //             }
 //             scope 8 {
-//                 debug v => _6;
+//                 debug v => _8;
 //                 let mut _12: i32;
 //             }
 //         }
@@ -102,22 +129,28 @@ fn main() {
 //         }
 //     }
 //     scope 6 {
-//         debug self => _1;
+//         debug self => _4;
 //     }
 //     bb0: {
-//         _5 = discriminant(_1);
+//         StorageLive(_2);
+//         StorageLive(_3);
+//         StorageLive(_4);
+//         _4 = _1;
+//         _3 = move _4;
+//         StorageDead(_4);
+//         _5 = discriminant(_3);
 //         switchInt(move _5) -> [0isize: bb1, otherwise: bb2];
 //     }
 //     bb1: {
-//         _0 = move _1;
-//         nop;
-//         nop;
+//         _0 = move _3;
+//         StorageDead(_3);
+//         StorageDead(_2);
 //         goto -> bb3;
 //     }
 //     bb2: {
-//         _0 = move _1;
-//         nop;
-//         nop;
+//         _0 = move _3;
+//         StorageDead(_3);
+//         StorageDead(_2);
 //         goto -> bb3;
 //     }
 //     bb3: {
@@ -141,16 +174,16 @@ fn main() {
 //     let _10: u32;
 //     let mut _11: u32;
 //     scope 1 {
-//         debug y => _10;
+//         debug y => _2;
 //     }
 //     scope 2 {
 //         debug err => _6;
 //         scope 3 {
 //             scope 7 {
-//                 debug t => _6;
+//                 debug t => _9;
 //             }
 //             scope 8 {
-//                 debug v => _6;
+//                 debug v => _8;
 //                 let mut _12: i32;
 //             }
 //         }
@@ -161,16 +194,22 @@ fn main() {
 //         }
 //     }
 //     scope 6 {
-//         debug self => _1;
+//         debug self => _4;
 //     }
 //     bb0: {
-//         _5 = discriminant(_1);
+//         StorageLive(_2);
+//         StorageLive(_3);
+//         StorageLive(_4);
+//         _4 = _1;
+//         _3 = move _4;
+//         StorageDead(_4);
+//         _5 = discriminant(_3);
 //         goto -> bb1;
 //     }
 //     bb1: {
-//         _0 = move _1;
-//         nop;
-//         nop;
+//         _0 = move _3;
+//         StorageDead(_3);
+//         StorageDead(_2);
 //         goto -> bb2;
 //     }
 //     bb2: {
@@ -183,34 +222,39 @@ fn main() {
 // fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i32> {
 //     debug x => _1;
 //     let mut _0: std::result::Result<u32, i32>;
-//     let mut _2: isize;
-//     let _3: i32;
-//     let _4: u32;
+//     let _2: u32;
+//     let mut _3: isize;
+//     let _4: i32;
+//     let mut _5: i32;
+//     let mut _6: i32;
+//     let _7: u32;
 //     scope 1 {
-//         debug y => _4;
+//         debug y => _2;
 //     }
 //     scope 2 {
-//         debug err => _3;
+//         debug err => _4;
 //         scope 3 {
 //             scope 7 {
-//                 debug t => _3;
+//                 debug t => _6;
 //             }
 //             scope 8 {
-//                 debug v => _3;
+//                 debug v => _5;
 //             }
 //         }
 //     }
 //     scope 4 {
-//         debug val => _4;
+//         debug val => _7;
 //         scope 5 {
 //         }
 //     }
 //     scope 6 {
 //         debug self => _1;
 //     }
 //     bb0: {
-//         _2 = discriminant(_1);
+//         StorageLive(_2);
+//         _3 = discriminant(_1);
 //         _0 = move _1;
+//         StorageDead(_2);
 //         return;
 //     }
 // }

src/test/mir-opt/simplify_try_if_let.rs

@@ -0,0 +1,203 @@
+// compile-flags: -Zmir-opt-level=1
+// ignore-tidy-linelength
+
+use std::ptr::NonNull;
+
+pub struct LinkedList {
+    head: Option<NonNull<Node>>,
+    tail: Option<NonNull<Node>>,
+}
+
+pub struct Node {
+    next: Option<NonNull<Node>>,
+}
+
+impl LinkedList {
+    pub fn new() -> Self {
+        Self { head: None, tail: None }
+    }
+
+    pub fn append(&mut self, other: &mut Self) {
+        match self.tail {
+            None => { },
+            Some(mut tail) => {
+                // `as_mut` is okay here because we have exclusive access to the entirety
+                // of both lists.
+                if let Some(other_head) = other.head.take() {
+                    unsafe {
+                        tail.as_mut().next = Some(other_head);
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    let mut one = LinkedList::new();
+    let mut two = LinkedList::new();
+    one.append(&mut two);
+}
+
+// END RUST SOURCE
+// START rustc.{{impl}}-append.SimplifyArmIdentity.before.mir
+// debug self => _1;
+// debug other => _2;
+// let mut _0: ();
+// let mut _3: isize;
+// let mut _4: std::ptr::NonNull<Node>;
+// let mut _5: std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _6: &mut std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _7: isize;
+// let mut _9: std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _10: std::ptr::NonNull<Node>;
+// let mut _11: &mut Node;
+// let mut _12: &mut std::ptr::NonNull<Node>;
+// scope 1 {
+//     debug tail => _4;
+//     let _8: std::ptr::NonNull<Node>;
+//     scope 2 {
+//         debug other_head => _8;
+//         scope 3 {
+//         }
+//     }
+// }
+// bb0: {
+//     _3 = discriminant(((*_1).1: std::option::Option<std::ptr::NonNull<Node>>));
+//     switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2];
+// }
+// bb1: {
+//     StorageLive(_4);
+//     _4 = ((((*_1).1: std::option::Option<std::ptr::NonNull<Node>>) as Some).0: std::ptr::NonNull<Node>);
+//     StorageLive(_5);
+//     StorageLive(_6);
+//     _6 = &mut ((*_2).0: std::option::Option<std::ptr::NonNull<Node>>);
+//     _5 = const std::option::Option::<std::ptr::NonNull<Node>>::take(move _6) -> bb4;
+// }
+// bb2: {
+//     unreachable;
+// }
+// bb3: {
+//     nop;
+//     goto -> bb9;
+// }
+// bb4: {
+//     StorageDead(_6);
+//     _7 = discriminant(_5);
+//     switchInt(move _7) -> [1isize: bb6, otherwise: bb5];
+// }
+// bb5: {
+//     nop;
+//     goto -> bb8;
+// }
+// bb6: {
+//     StorageLive(_8);
+//     _8 = ((_5 as Some).0: std::ptr::NonNull<Node>);
+//     StorageLive(_9);
+//     StorageLive(_10);
+//     _10 = _8;
+//     ((_9 as Some).0: std::ptr::NonNull<Node>) = move _10;
+//     discriminant(_9) = 1;
+//     StorageDead(_10);
+//     StorageLive(_11);
+//     StorageLive(_12);
+//     _12 = &mut _4;
+//     _11 = const std::ptr::NonNull::<Node>::as_mut(move _12) -> bb7;
+// }
+// bb7: {
+//     StorageDead(_12);
+//     ((*_11).0: std::option::Option<std::ptr::NonNull<Node>>) = move _9;
+//     StorageDead(_9);
+//     StorageDead(_11);
+//     nop;
+//     StorageDead(_8);
+//     goto -> bb8;
+// }
+// bb8: {
+//     StorageDead(_5);
+//     StorageDead(_4);
+//     goto -> bb9;
+// }
+// bb9: {
+//     return;
+// }
+// END rustc.{{impl}}-append.SimplifyArmIdentity.before.mir
+
+// START rustc.{{impl}}-append.SimplifyArmIdentity.after.mir
+// debug self => _1;
+// debug other => _2;
+// let mut _0: ();
+// let mut _3: isize;
+// let mut _4: std::ptr::NonNull<Node>;
+// let mut _5: std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _6: &mut std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _7: isize;
+// let mut _9: std::option::Option<std::ptr::NonNull<Node>>;
+// let mut _10: std::ptr::NonNull<Node>;
+// let mut _11: &mut Node;
+// let mut _12: &mut std::ptr::NonNull<Node>;
+// scope 1 {
+//     debug tail => _4;
+//     let _8: std::ptr::NonNull<Node>;
+//     scope 2 {
+//         debug other_head => _8;
+//         scope 3 {
+//         }
+//     }
+// }
+// bb0: {
+//     _3 = discriminant(((*_1).1: std::option::Option<std::ptr::NonNull<Node>>));
+//     switchInt(move _3) -> [0isize: bb3, 1isize: bb1, otherwise: bb2];
+// }
+// bb1: {
+//     StorageLive(_4);
+//     _4 = ((((*_1).1: std::option::Option<std::ptr::NonNull<Node>>) as Some).0: std::ptr::NonNull<Node>);
+//     StorageLive(_5);
+//     StorageLive(_6);
+//     _6 = &mut ((*_2).0: std::option::Option<std::ptr::NonNull<Node>>);
+//     _5 = const std::option::Option::<std::ptr::NonNull<Node>>::take(move _6) -> bb4;
+// }
+// bb2: {
+//     unreachable;
+// }
+// bb3: {
+//     nop;
+//     goto -> bb9;
+// }
+// bb4: {
+//     StorageDead(_6);
+//     _7 = discriminant(_5);
+//     switchInt(move _7) -> [1isize: bb6, otherwise: bb5];
+// }
+// bb5: {
+//     nop;
+//     goto -> bb8;
+// }
+// bb6: {
+//     StorageLive(_8);
+//     _8 = ((_5 as Some).0: std::ptr::NonNull<Node>);
+//     StorageLive(_9);
+//     _9 = move _5;
+//     StorageLive(_11);
+//     StorageLive(_12);
+//     _12 = &mut _4;
+//     _11 = const std::ptr::NonNull::<Node>::as_mut(move _12) -> bb7;
+// }
+// bb7: {
+//     StorageDead(_12);
+//     ((*_11).0: std::option::Option<std::ptr::NonNull<Node>>) = move _9;
+//     StorageDead(_9);
+//     StorageDead(_11);
+//     nop;
+//     StorageDead(_8);
+//     goto -> bb8;
+// }
+// bb8: {
+//     StorageDead(_5);
+//     StorageDead(_4);
+//     goto -> bb9;
+// }
+// bb9: {
+//     return;
+// }
+// END rustc.{{impl}}-append.SimplifyArmIdentity.after.mir