Auto merge of rust-lang#128299 - DianQK:clone-copy, r=<try>

Simplify the canonical clone method and the copy-like forms to copy

Fixes rust-lang#128081. Currently being blocked by rust-lang#128265.

`@rustbot` label +S-blocked

r? `@saethlin`

Author: bors

compiler/rustc_index/src/vec.rs

@@ -188,6 +188,16 @@ impl<I: Idx, T> IndexVec<I, T> {
         let min_new_len = elem.index() + 1;
         self.raw.resize_with(min_new_len, fill_value);
     }
+
+    #[inline]
+    pub fn reset_all(&mut self, elem: T)
+    where
+        T: Copy,
+    {
+        for e in self.raw.iter_mut() {
+            *e = elem;
+        }
+    }
 }
 
 /// `IndexVec` is often used as a map, so it provides some map-like APIs.

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -2,6 +2,7 @@
 
 use rustc_ast::attr;
 use rustc_hir::LangItem;
+use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::mir::*;
 use rustc_middle::ty::layout::ValidityRequirement;
@@ -60,8 +61,8 @@ impl<'tcx> MirPass<'tcx> for InstSimplify {
                     _ => {}
                 }
             }
-
             ctx.simplify_primitive_clone(block.terminator.as_mut().unwrap(), &mut block.statements);
+            ctx.simplify_copy_like(&mut block.statements);
             ctx.simplify_intrinsic_assert(block.terminator.as_mut().unwrap());
             ctx.simplify_nounwind_call(block.terminator.as_mut().unwrap());
             simplify_duplicate_switch_targets(block.terminator.as_mut().unwrap());
@@ -207,6 +208,95 @@ impl<'tcx> InstSimplifyContext<'tcx, '_> {
         }
     }
 
+    /// Transform `Aggregate(Adt, [(*_1).0, (*_1).1])` ==> `Copy(*_1)`.
+    /// This comes from the simplification of the clone method by `simplify_primitive_clone`.
+    fn simplify_copy_like(&self, statements: &mut Vec<Statement<'tcx>>) {
+        let mut assignments = IndexVec::from_elem(None::<Place<'tcx>>, self.local_decls);
+        for statement in statements {
+            match statement.kind {
+                StatementKind::Assign(box (dest, ref mut rvalue)) => {
+                    if let Rvalue::Aggregate(_, fields) = rvalue {
+                        let mut from_local = None;
+                        if fields.iter_enumerated().all(|(index, field)| {
+                            let Some(from_place) = field
+                                .place()
+                                .and_then(|p| p.as_local())
+                                .and_then(|l| assignments[l])
+                            else {
+                                return false;
+                            };
+                            // All fields must come from the same local.
+                            if let Some(from_local) = from_local {
+                                if from_place.local != from_local {
+                                    return false;
+                                }
+                            } else {
+                                // We can only copy the same type.
+                                let Some(from_ty) =
+                                    self.local_decls[from_place.local].ty.builtin_deref(false)
+                                else {
+                                    return false;
+                                };
+                                let dest_ty = dest.ty(self.local_decls, self.tcx).ty;
+                                if dest_ty != from_ty {
+                                    return false;
+                                };
+                                from_local = Some(from_place.local);
+                            }
+                            // For more complex scenarios, we expect to get this simplified projection within a complete pipeline.
+                            let [ProjectionElem::Deref, ProjectionElem::Field(from_index, _)] =
+                                *from_place.projection.as_slice()
+                            else {
+                                return false;
+                            };
+                            from_index == index
+                        }) {
+                            if let Some(local) = from_local {
+                                if self.should_simplify(&statement.source_info, rvalue) {
+                                    *rvalue = Rvalue::Use(Operand::Copy(Place {
+                                        local,
+                                        projection: self
+                                            .tcx
+                                            .mk_place_elems(&[ProjectionElem::Deref]),
+                                    }));
+                                }
+                            }
+                        }
+                    }
+                    // Collect available assignments, including those transformed from `Aggregate`.
+                    if let Some(local) = dest.as_local() {
+                        assignments[local] = if let Rvalue::Use(operand) = rvalue
+                            && let Some(place) = operand.place()
+                        {
+                            if let Some(rvalue_local) = place.as_local() {
+                                let place = assignments[rvalue_local];
+                                if operand.is_move() {
+                                    assignments[rvalue_local] = None;
+                                }
+                                place
+                            } else {
+                                Some(place)
+                            }
+                        } else {
+                            // This assignment generally comes from debuginfo (e.g., Ref),
+                            // but we still need to check if a local is being overridden.
+                            None
+                        };
+                    } else {
+                        // We don't handle projection, so we drop all previous assignments.
+                        assignments.reset_all(None);
+                    }
+                }
+                StatementKind::StorageLive(_)
+                | StatementKind::StorageDead(_)
+                | StatementKind::Nop => {}
+                _ => {
+                    assignments.reset_all(None);
+                }
+            }
+        }
+    }
+
     fn simplify_cast(&self, rvalue: &mut Rvalue<'tcx>) {
         if let Rvalue::Cast(kind, operand, cast_ty) = rvalue {
             let operand_ty = operand.ty(self.local_decls, self.tcx);

tests/codegen/clone_as_copy.rs

@@ -0,0 +1,40 @@
+//@ revisions: DEBUGINFO NODEBUGINFO
+//@ compile-flags: -O -Cno-prepopulate-passes
+//@ [DEBUGINFO] compile-flags: -Cdebuginfo=full
+
+// From https://github.com/rust-lang/rust/issues/128081.
+// Ensure that we only generate a memcpy instruction.
+
+#![crate_type = "lib"]
+
+#[derive(Clone)]
+struct SubCloneAndCopy {
+    v1: u32,
+    v2: u32,
+}
+
+#[derive(Clone)]
+struct CloneOnly {
+    v1: u8,
+    v2: u8,
+    v3: u8,
+    v4: u8,
+    v5: u8,
+    v6: u8,
+    v7: u8,
+    v8: u8,
+    v9: u8,
+    v_sub: SubCloneAndCopy,
+    v_large: [u8; 256],
+}
+
+// CHECK-LABEL: define {{.*}}@clone_only(
+#[no_mangle]
+pub fn clone_only(v: &CloneOnly) -> CloneOnly {
+    // CHECK-NOT: call {{.*}}clone
+    // CHECK-NOT: store i8
+    // CHECK-NOT: store i32
+    // CHECK: call void @llvm.memcpy
+    // CHECK-NEXT: ret void
+    v.clone()
+}

tests/mir-opt/instsimplify/clone.rs

@@ -0,0 +1,17 @@
+//@ test-mir-pass: InstSimplify-after-simplifycfg
+//@ compile-flags: -Zmir-enable-passes=+InstSimplify-before-inline,+ReferencePropagation,+SimplifyCfg-after-unreachable-enum-branching
+
+// Check if we have transformed the default clone to copy in the specific pipeline.
+
+// EMIT_MIR clone.{impl#0}-clone.InstSimplify-after-simplifycfg.diff
+
+// CHECK-LABEL: ::clone(
+// CHECK-NOT: = AllCopy { {{.*}} };
+// CHECK: _0 = (*_1);
+// CHECK: return;
+#[derive(Clone)]
+struct AllCopy {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}

tests/mir-opt/instsimplify/clone.{impl#0}-clone.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,32 @@
+- // MIR for `<impl at $DIR/clone.rs:12:10: 12:15>::clone` before InstSimplify-after-simplifycfg
++ // MIR for `<impl at $DIR/clone.rs:12:10: 12:15>::clone` after InstSimplify-after-simplifycfg
+  
+  fn <impl at $DIR/clone.rs:12:10: 12:15>::clone(_1: &AllCopy) -> AllCopy {
+      debug self => _1;
+      let mut _0: AllCopy;
+      let mut _2: i32;
+      let mut _3: &i32;
+      let _4: &i32;
+      let mut _5: u64;
+      let mut _6: &u64;
+      let _7: &u64;
+      let mut _8: [i8; 3];
+      let mut _9: &[i8; 3];
+      let _10: &[i8; 3];
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_5);
+          _5 = ((*_1).1: u64);
+          StorageLive(_8);
+          _8 = ((*_1).2: [i8; 3]);
+-         _0 = AllCopy { a: move _2, b: move _5, c: move _8 };
++         _0 = (*_1);
+          StorageDead(_8);
+          StorageDead(_5);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,47 @@
+- // MIR for `all_copy` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy` after InstSimplify-after-simplifycfg
+  
+  fn all_copy(_1: &AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+-         _0 = AllCopy { a: move _5, b: move _6, c: move _7 };
++         _0 = (*_1);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_different_type.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,46 @@
+- // MIR for `all_copy_different_type` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_different_type` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_different_type(_1: &AllCopy) -> AllCopy2 {
+      debug v => _1;
+      let mut _0: AllCopy2;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+          _0 = AllCopy2 { a: move _5, b: move _6, c: move _7 };
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_has_changed.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,47 @@
+- // MIR for `all_copy_has_changed` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_has_changed` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_has_changed(_1: &mut AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          ((*_1).0: i32) = const 1_i32;
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+          _0 = AllCopy { a: move _5, b: move _6, c: move _7 };
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_move.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,46 @@
+- // MIR for `all_copy_move` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_move` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_move(_1: AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let _2: i32;
+      let mut _5: i32;
+      let mut _6: u64;
+      let mut _7: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = (_1.0: i32);
+          StorageLive(_3);
+          _3 = (_1.1: u64);
+          StorageLive(_4);
+          _4 = (_1.2: [i8; 3]);
+          StorageLive(_5);
+          _5 = _2;
+          StorageLive(_6);
+          _6 = _3;
+          StorageLive(_7);
+          _7 = _4;
+          _0 = AllCopy { a: move _5, b: move _6, c: move _7 };
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_ret_2.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,68 @@
+- // MIR for `all_copy_ret_2` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_ret_2` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_ret_2(_1: &AllCopy) -> (AllCopy, AllCopy) {
+      debug v => _1;
+      let mut _0: (AllCopy, AllCopy);
+      let _2: i32;
+      let mut _5: AllCopy;
+      let mut _6: i32;
+      let mut _7: u64;
+      let mut _8: [i8; 3];
+      let mut _9: AllCopy;
+      let mut _10: i32;
+      let mut _11: u64;
+      let mut _12: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = _2;
+          StorageLive(_7);
+          _7 = _3;
+          StorageLive(_8);
+          _8 = _4;
+-         _5 = AllCopy { a: move _6, b: move _7, c: move _8 };
++         _5 = (*_1);
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_9);
+          StorageLive(_10);
+          _10 = _2;
+          StorageLive(_11);
+          _11 = _3;
+          StorageLive(_12);
+          _12 = _4;
+-         _9 = AllCopy { a: move _10, b: move _11, c: move _12 };
++         _9 = (*_1);
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageDead(_10);
+          _0 = (move _5, move _9);
+          StorageDead(_9);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_use_changed.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,53 @@
+- // MIR for `all_copy_use_changed` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_use_changed` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_use_changed(_1: &mut AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let mut _2: i32;
+      let mut _3: i32;
+      let mut _6: i32;
+      let mut _7: u64;
+      let mut _8: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _4: u64;
+          scope 2 {
+              debug b => _4;
+              let _5: [i8; 3];
+              scope 3 {
+                  debug c => _5;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          ((*_1).0: i32) = const 1_i32;
+          StorageLive(_3);
+          _3 = ((*_1).0: i32);
+          _2 = move _3;
+          StorageDead(_3);
+          StorageLive(_4);
+          _4 = ((*_1).1: u64);
+          StorageLive(_5);
+          _5 = ((*_1).2: [i8; 3]);
+          StorageLive(_6);
+          _6 = _2;
+          StorageLive(_7);
+          _7 = _4;
+          StorageLive(_8);
+          _8 = _5;
+-         _0 = AllCopy { a: move _6, b: move _7, c: move _8 };
++         _0 = (*_1);
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.all_copy_use_changed_2.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,52 @@
+- // MIR for `all_copy_use_changed_2` before InstSimplify-after-simplifycfg
++ // MIR for `all_copy_use_changed_2` after InstSimplify-after-simplifycfg
+  
+  fn all_copy_use_changed_2(_1: &mut AllCopy) -> AllCopy {
+      debug v => _1;
+      let mut _0: AllCopy;
+      let mut _2: i32;
+      let mut _5: i32;
+      let mut _6: i32;
+      let mut _7: u64;
+      let mut _8: [i8; 3];
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).0: i32);
+          StorageLive(_3);
+          _3 = ((*_1).1: u64);
+          StorageLive(_4);
+          _4 = ((*_1).2: [i8; 3]);
+          ((*_1).0: i32) = const 1_i32;
+          StorageLive(_5);
+          _5 = ((*_1).0: i32);
+          _2 = move _5;
+          StorageDead(_5);
+          StorageLive(_6);
+          _6 = _2;
+          StorageLive(_7);
+          _7 = _3;
+          StorageLive(_8);
+          _8 = _4;
+          _0 = AllCopy { a: move _6, b: move _7, c: move _8 };
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.empty_struct_1.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,13 @@
+- // MIR for `empty_struct_1` before InstSimplify-after-simplifycfg
++ // MIR for `empty_struct_1` after InstSimplify-after-simplifycfg
+  
+  fn empty_struct_1(_1: &EmptyStruct1) -> EmptyStruct1 {
+      debug v => _1;
+      let mut _0: EmptyStruct1;
+  
+      bb0: {
+          _0 = EmptyStruct1;
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.empty_struct_2.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,13 @@
+- // MIR for `empty_struct_2` before InstSimplify-after-simplifycfg
++ // MIR for `empty_struct_2` after InstSimplify-after-simplifycfg
+  
+  fn empty_struct_2(_1: &EmptyStruct2) -> EmptyStruct2 {
+      debug v => _1;
+      let mut _0: EmptyStruct2;
+  
+      bb0: {
+          _0 = EmptyStruct2;
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.nest_copy.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,68 @@
+- // MIR for `nest_copy` before InstSimplify-after-simplifycfg
++ // MIR for `nest_copy` after InstSimplify-after-simplifycfg
+  
+  fn nest_copy(_1: &NestCopy) -> NestCopy {
+      debug v => _1;
+      let mut _0: NestCopy;
+      let _2: i32;
+      let mut _6: i32;
+      let mut _7: u64;
+      let mut _8: [i8; 3];
+      let mut _10: i32;
+      let mut _11: AllCopy;
+      scope 1 {
+          debug a => _2;
+          let _3: u64;
+          scope 2 {
+              debug b => _3;
+              let _4: [i8; 3];
+              scope 3 {
+                  debug c => _4;
+                  let _5: AllCopy;
+                  scope 4 {
+                      debug all_copy => _5;
+                      let _9: i32;
+                      scope 5 {
+                          debug d => _9;
+                      }
+                  }
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = (((*_1).1: AllCopy).0: i32);
+          StorageLive(_3);
+          _3 = (((*_1).1: AllCopy).1: u64);
+          StorageLive(_4);
+          _4 = (((*_1).1: AllCopy).2: [i8; 3]);
+          StorageLive(_5);
+          StorageLive(_6);
+          _6 = _2;
+          StorageLive(_7);
+          _7 = _3;
+          StorageLive(_8);
+          _8 = _4;
+          _5 = AllCopy { a: move _6, b: move _7, c: move _8 };
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageLive(_9);
+          _9 = ((*_1).0: i32);
+          StorageLive(_10);
+          _10 = _9;
+          StorageLive(_11);
+          _11 = move _5;
+          _0 = NestCopy { d: move _10, all_copy: move _11 };
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instsimplify/copy_like.rs

@@ -0,0 +1,160 @@
+//@ test-mir-pass: InstSimplify-after-simplifycfg
+
+struct AllCopy {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}
+
+// EMIT_MIR copy_like.all_copy.InstSimplify-after-simplifycfg.diff
+fn all_copy(v: &AllCopy) -> AllCopy {
+    // CHECK-LABEL: fn all_copy(
+    // CHECK: bb0: {
+    // CHECK-NOT: = AllCopy { {{.*}} };
+    // CHECK: _0 = (*_1);
+    let a = v.a;
+    let b = v.b;
+    let c = v.c;
+    AllCopy { a, b, c }
+}
+
+// FIXME: This can be transformed into `Copy`.
+// EMIT_MIR copy_like.all_copy_move.InstSimplify-after-simplifycfg.diff
+fn all_copy_move(v: AllCopy) -> AllCopy {
+    // CHECK-LABEL: fn all_copy_move(
+    // CHECK: bb0: {
+    // CHECK-NOT: _0 = (*_1);
+    // CHECK: = AllCopy { {{.*}} };
+    let a = v.a;
+    let b = v.b;
+    let c = v.c;
+    AllCopy { a, b, c }
+}
+
+// EMIT_MIR copy_like.all_copy_ret_2.InstSimplify-after-simplifycfg.diff
+fn all_copy_ret_2(v: &AllCopy) -> (AllCopy, AllCopy) {
+    // CHECK-LABEL: fn all_copy_ret_2(
+    // CHECK: bb0: {
+    // CHECK-NOT: = AllCopy { {{.*}} };
+    // CHECK: [[V1:_.*]] = (*_1);
+    // CHECK: [[V2:_.*]] = (*_1);
+    // CHECK: _0 = (move [[V1]], move [[V2]]);
+    let a = v.a;
+    let b = v.b;
+    let c = v.c;
+    (AllCopy { a, b, c }, AllCopy { a, b, c })
+}
+
+struct AllCopy2 {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}
+
+// EMIT_MIR copy_like.all_copy_different_type.InstSimplify-after-simplifycfg.diff
+fn all_copy_different_type(v: &AllCopy) -> AllCopy2 {
+    // CHECK-LABEL: fn all_copy_different_type(
+    // CHECK: bb0: {
+    // CHECK: _0 = AllCopy2 { {{.*}} };
+    let a = v.a;
+    let b = v.b;
+    let c = v.c;
+    AllCopy2 { a, b, c }
+}
+
+struct SameType {
+    a: i32,
+    b: i32,
+}
+
+// EMIT_MIR copy_like.same_type_different_index.InstSimplify-after-simplifycfg.diff
+fn same_type_different_index(v: &SameType) -> SameType {
+    // CHECK-LABEL: fn same_type_different_index(
+    // CHECK: bb0: {
+    // CHECK: _0 = SameType { {{.*}} };
+    let a = v.b;
+    let b = v.a;
+    SameType { a, b }
+}
+
+// EMIT_MIR copy_like.all_copy_has_changed.InstSimplify-after-simplifycfg.diff
+fn all_copy_has_changed(v: &mut AllCopy) -> AllCopy {
+    // CHECK-LABEL: fn all_copy_has_changed(
+    // CHECK: bb0: {
+    // CHECK: _0 = AllCopy { {{.*}} };
+    let a = v.a;
+    let b = v.b;
+    let c = v.c;
+    v.a = 1;
+    AllCopy { a, b, c }
+}
+
+// EMIT_MIR copy_like.all_copy_use_changed.InstSimplify-after-simplifycfg.diff
+fn all_copy_use_changed(v: &mut AllCopy) -> AllCopy {
+    // CHECK-LABEL: fn all_copy_use_changed(
+    // CHECK: bb0: {
+    // CHECK-NOT: = AllCopy { {{.*}} };
+    // CHECK: _0 = (*_1);
+    let mut a = v.a;
+    v.a = 1;
+    a = v.a;
+    let b = v.b;
+    let c = v.c;
+    AllCopy { a, b, c }
+}
+
+// We deleted the records for b and c,
+// because we couldn't easily determine which field had been updated.
+// EMIT_MIR copy_like.all_copy_use_changed_2.InstSimplify-after-simplifycfg.diff
+fn all_copy_use_changed_2(v: &mut AllCopy) -> AllCopy {
+    // CHECK-LABEL: fn all_copy_use_changed_2(
+    // CHECK: bb0: {
+    // CHECK-NOT: _0 = (*_1);
+    // CHECK: = AllCopy { {{.*}} };
+    let mut a = v.a;
+    let b = v.b;
+    let c = v.c;
+    v.a = 1;
+    a = v.a;
+    AllCopy { a, b, c }
+}
+
+struct NestCopy {
+    d: i32,
+    all_copy: AllCopy,
+}
+
+// FIXME: Consider supporting multi-level fields?
+// (Note: clone becomes a single-level field after inlining)
+// EMIT_MIR copy_like.nest_copy.InstSimplify-after-simplifycfg.diff
+fn nest_copy(v: &NestCopy) -> NestCopy {
+    // CHECK-LABEL: fn nest_copy(
+    // CHECK: bb0: {
+    // CHECK: = AllCopy { {{.*}} };
+    // CHECK: = NestCopy { {{.*}} };
+    let a = v.all_copy.a;
+    let b = v.all_copy.b;
+    let c = v.all_copy.c;
+    let all_copy = AllCopy { a, b, c };
+    let d = v.d;
+    NestCopy { d, all_copy }
+}
+
+struct EmptyStruct1;
+struct EmptyStruct2 {}
+
+// EMIT_MIR copy_like.empty_struct_1.InstSimplify-after-simplifycfg.diff
+fn empty_struct_1(v: &EmptyStruct1) -> EmptyStruct1 {
+    // CHECK-LABEL: fn empty_struct_1(
+    // CHECK: bb0: {
+    // CHECK: _0 = EmptyStruct1;
+    EmptyStruct1
+}
+
+// EMIT_MIR copy_like.empty_struct_2.InstSimplify-after-simplifycfg.diff
+fn empty_struct_2(v: &EmptyStruct2) -> EmptyStruct2 {
+    // CHECK-LABEL: fn empty_struct_2(
+    // CHECK: bb0: {
+    // CHECK: _0 = EmptyStruct2;
+    EmptyStruct2 {}
+}

tests/mir-opt/instsimplify/copy_like.same_type_different_index.InstSimplify-after-simplifycfg.diff

@@ -0,0 +1,35 @@
+- // MIR for `same_type_different_index` before InstSimplify-after-simplifycfg
++ // MIR for `same_type_different_index` after InstSimplify-after-simplifycfg
+  
+  fn same_type_different_index(_1: &SameType) -> SameType {
+      debug v => _1;
+      let mut _0: SameType;
+      let _2: i32;
+      let mut _4: i32;
+      let mut _5: i32;
+      scope 1 {
+          debug a => _2;
+          let _3: i32;
+          scope 2 {
+              debug b => _3;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = ((*_1).1: i32);
+          StorageLive(_3);
+          _3 = ((*_1).0: i32);
+          StorageLive(_4);
+          _4 = _2;
+          StorageLive(_5);
+          _5 = _3;
+          _0 = SameType { a: move _4, b: move _5 };
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

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

@@ -0,0 +1,21 @@
+// MIR for `clone_as_copy` after PreCodegen
+
+fn clone_as_copy(_1: &CopyLikeStruct) -> CopyLikeStruct {
+    debug v => _1;
+    let mut _0: CopyLikeStruct;
+    scope 1 (inlined <CopyLikeStruct as Clone>::clone) {
+        debug self => _1;
+        let _2: &AllCopy;
+        scope 2 (inlined <AllCopy as Clone>::clone) {
+            debug self => _2;
+        }
+    }
+
+    bb0: {
+        StorageLive(_2);
+        _2 = &((*_1).1: AllCopy);
+        _0 = (*_1);
+        StorageDead(_2);
+        return;
+    }
+}

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

@@ -0,0 +1,28 @@
+//@ compile-flags: -Cdebuginfo=full
+
+// Check if we have transformed the nested clone to the copy in the complete pipeline.
+
+#[derive(Clone)]
+struct AllCopy {
+    a: i32,
+    b: u64,
+    c: [i8; 3],
+}
+
+#[derive(Clone)]
+struct CopyLikeStruct {
+    a: i32,
+    b: AllCopy,
+    c: [i8; 3],
+}
+
+// EMIT_MIR clone_as_copy.clone_as_copy.PreCodegen.after.mir
+#[inline(never)]
+fn clone_as_copy(v: &CopyLikeStruct) -> CopyLikeStruct {
+    // CHECK-LABEL: fn clone_as_copy(
+    // CHECK-NOT: = AllCopy { {{.*}} };
+    // CHECK-NOT: = CopyLikeStruct { {{.*}} };
+    // CHECK: _0 = (*_1);
+    // CHECK: return;
+    v.clone()
+}

tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir

@@ -3,13 +3,9 @@
 fn <impl at $DIR/no_inlined_clone.rs:9:10: 9:15>::clone(_1: &Foo) -> Foo {
     debug self => _1;
     let mut _0: Foo;
-    let mut _2: i32;
 
     bb0: {
-        StorageLive(_2);
-        _2 = ((*_1).0: i32);
-        _0 = Foo { a: move _2 };
-        StorageDead(_2);
+        _0 = (*_1);
         return;
     }
 }