Update mir-opt filechecks

tests/mir-opt/array_index_is_temporary.rs

@@ -15,7 +15,7 @@ fn main() {
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[y]] = const 1_usize;
-    // CHECK: [[tmp:_.*]] = [[y]];
+    // CHECK: [[tmp:_.*]] = copy [[y]];
     // CHECK: [[x]][[[tmp]]] =
     let mut x = [42, 43, 44];
     let mut y = 1;

tests/mir-opt/box_expr.rs

@@ -7,7 +7,7 @@
 fn main() {
     // CHECK-LABEL: fn main(
     // CHECK:   [[box:_.*]] = ShallowInitBox(
-    // CHECK:   [[ptr:_.*]] = ((([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>).0: *const S);
+    // CHECK:   [[ptr:_.*]] = copy ((([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>).0: *const S);
     // CHECK:   (*[[ptr]]) = S::new() -> [return: [[ret:bb.*]], unwind: [[unwind:bb.*]]];
     // CHECK: [[ret]]: {
     // CHECK:   [[box2:_.*]] = move [[box]];

tests/mir-opt/building/match/sort_candidates.rs

@@ -25,7 +25,7 @@ fn disjoint_ranges(x: i32, b: bool) -> u32 {
     // CHECK-LABEL: fn disjoint_ranges(
     // CHECK: debug b => _2;
     // CHECK: bb0: {
-    // CHECK: switchInt(_2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
+    // CHECK: switchInt(copy _2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
     // CHECK: [[jump]]: {
     // CHECK-NEXT: _0 = const 3_u32;
     // CHECK-NEXT: return;

tests/mir-opt/building/while_storage.rs

@@ -15,7 +15,7 @@ fn while_loop(c: bool) {
     // CHECK: bb1: {
     // CHECK-NEXT:     StorageLive(_3);
     // CHECK-NEXT:     StorageLive(_2);
-    // CHECK-NEXT:     _2 = _1;
+    // CHECK-NEXT:     _2 = copy _1;
     // CHECK-NEXT:     _3 = get_bool(move _2) -> [return: bb2, unwind
     // CHECK: bb2: {
     // CHECK-NEXT:     switchInt(move _3) -> [0: bb3, otherwise: bb4];
@@ -29,7 +29,7 @@ fn while_loop(c: bool) {
     // CHECK-NEXT:     StorageDead(_2);
     // CHECK-NEXT:     StorageLive(_5);
     // CHECK-NEXT:     StorageLive(_4);
-    // CHECK-NEXT:     _4 = _1;
+    // CHECK-NEXT:     _4 = copy _1;
     // CHECK-NEXT:     _5 = get_bool(move _4) -> [return: bb5, unwind
     // CHECK: bb5: {
     // CHECK-NEXT:     switchInt(move _5) -> [0: bb6, otherwise: bb7];

tests/mir-opt/const_prop/address_of_pair.rs

@@ -10,13 +10,13 @@ pub fn fn0() -> bool {
     // CHECK: (*[[ptr]]) = const true;
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
-    // CHECK: [[tmp:_.*]] = ([[pair]].1: bool);
+    // CHECK: [[tmp:_.*]] = copy ([[pair]].1: bool);
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
     // CHECK: [[ret]] = Not(move [[tmp]]);
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
-    // CHECK: _0 = [[ret]];
+    // CHECK: _0 = copy [[ret]];
     let mut pair = (1, false);
     let ptr = core::ptr::addr_of_mut!(pair.1);
     pair = (1, false);

tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs

@@ -8,7 +8,7 @@ fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug a => [[a:_.*]];
     // CHECK: debug _b => [[b:_.*]];
-    // CHECK: [[b]] = (*[[a]])[3 of 4];
+    // CHECK: [[b]] = copy (*[[a]])[3 of 4];
     let a: *const [_] = &[1, 2, 3];
     unsafe {
         let _b = (*a)[3];

tests/mir-opt/const_prop/boxes.rs

@@ -11,8 +11,8 @@ fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug x => [[x:_.*]];
     // CHECK: (*{{_.*}}) = const 42_i32;
-    // CHECK: [[tmp:_.*]] = (*{{_.*}});
-    // CHECK: [[x]] = [[tmp]];
+    // CHECK: [[tmp:_.*]] = copy (*{{_.*}});
+    // CHECK: [[x]] = copy [[tmp]];
     let x = *(#[rustc_box]
     Box::new(42))
         + 0;

tests/mir-opt/const_prop/indirect_mutation.rs

@@ -10,7 +10,7 @@ fn foo() {
     // CHECK: _1 = const (1_i32,);
     // CHECK: _2 = &mut (_1.0: i32);
     // CHECK: (*_2) = const 5_i32;
-    // CHECK: _4 = (_1.0: i32);
+    // CHECK: _4 = copy (_1.0: i32);
     // CHECK: _3 = Eq(move _4, const 5_i32);
 
     let mut u = (1,);
@@ -25,7 +25,7 @@ fn bar() {
     // CHECK: debug y => _4;
     // CHECK: _3 = &raw mut (_1.0: i32);
     // CHECK: (*_3) = const 5_i32;
-    // CHECK: _5 = (_1.0: i32);
+    // CHECK: _5 = copy (_1.0: i32);
     // CHECK: _4 = Eq(move _5, const 5_i32);
 
     let mut v = (1,);

tests/mir-opt/const_prop/mutable_variable.rs

@@ -7,7 +7,7 @@ fn main() {
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const 42_i32;
     // CHECK: [[x]] = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = 42;
     x = 99;
     let y = x;

tests/mir-opt/const_prop/mutable_variable_aggregate.rs

@@ -8,7 +8,7 @@ fn main() {
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const (42_i32, 43_i32);
     // CHECK: ([[x]].1: i32) = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = (42, 43);
     x.1 = 99;
     let y = x;

tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs

@@ -10,7 +10,7 @@ fn main() {
     // CHECK: [[x]] = const (42_i32, 43_i32);
     // CHECK: [[z]] = &mut [[x]];
     // CHECK: ((*[[z]]).1: i32) = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = (42, 43);
     let z = &mut x;
     z.1 = 99;

tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs

@@ -9,7 +9,7 @@ fn main() {
     // CHECK: [[x]] = foo()
     // CHECK: ([[x]].1: i32) = const 99_i32;
     // CHECK: ([[x]].0: i32) = const 42_i32;
-    // CHECK: [[y]] = ([[x]].1: i32);
+    // CHECK: [[y]] = copy ([[x]].1: i32);
     let mut x: (i32, i32) = foo();
     x.1 = 99;
     x.0 = 42;

tests/mir-opt/const_prop/mutable_variable_no_prop.rs

@@ -9,9 +9,9 @@ fn main() {
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const 42_u32;
-    // CHECK: [[tmp:_.*]] = (*{{_.*}});
+    // CHECK: [[tmp:_.*]] = copy (*{{_.*}});
     // CHECK: [[x]] = move [[tmp]];
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = 42;
     unsafe {
         x = STATIC;

tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs

@@ -11,9 +11,9 @@ fn main() {
     // CHECK: debug z => [[z:_.*]];
     // CHECK: [[a]] = foo()
     // CHECK: [[x]] = const (1_i32, 2_i32);
-    // CHECK: ([[x]].1: i32) = [[a]];
-    // CHECK: [[y]] = ([[x]].1: i32);
-    // CHECK: [[z]] = ([[x]].0: i32);
+    // CHECK: ([[x]].1: i32) = copy [[a]];
+    // CHECK: [[y]] = copy ([[x]].1: i32);
+    // CHECK: [[z]] = copy ([[x]].0: i32);
     let a = foo();
     let mut x: (i32, i32) = (1, 2);
     x.1 = a;

tests/mir-opt/const_prop/overwrite_with_const_with_params.rs

@@ -15,7 +15,7 @@ fn size_of<T>() -> usize {
     // CHECK-LABEL: fn size_of(
     // CHECK: _1 = const 0_usize;
     // CHECK-NEXT: _1 = const SizeOfConst::<T>::SIZE;
-    // CHECK-NEXT: _0 = _1;
+    // CHECK-NEXT: _0 = copy _1;
     let mut a = 0;
     a = SizeOfConst::<T>::SIZE;
     a

tests/mir-opt/const_prop/pointer_expose_provenance.rs

@@ -10,7 +10,7 @@ fn main() {
     // CHECK: [[ptr:_.*]] = const main::FOO;
     // CHECK: [[ref:_.*]] = &raw const (*[[ptr]]);
     // CHECK: [[x:_.*]] = move [[ref]] as usize (PointerExposeProvenance);
-    // CHECK: = read([[x]])
+    // CHECK: = read(copy [[x]])
     const FOO: &i32 = &1;
     let x = FOO as *const i32 as usize;
     read(x);

tests/mir-opt/const_prop/slice_len.rs

@@ -7,7 +7,7 @@
 fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug a => [[a:_.*]];
-    // CHECK: [[slice:_.*]] = {{.*}} as &[u32] (PointerCoercion(Unsize));
+    // CHECK: [[slice:_.*]] = copy {{.*}} as &[u32] (PointerCoercion(Unsize));
     // CHECK: assert(const true,
     // CHECK: [[a]] = const 2_u32;
     let a = (&[1u32, 2, 3] as &[u32])[1];

tests/mir-opt/copy-prop/borrowed_local.rs

@@ -21,11 +21,11 @@ fn compare_address() -> bool {
     // CHECK: bb0: {
     // CHECK-NEXT: _1 = const 5_u8;
     // CHECK-NEXT: _2 = &_1;
-    // CHECK-NEXT: _3 = _1;
+    // CHECK-NEXT: _3 = copy _1;
     // CHECK-NEXT: _4 = &_3;
-    // CHECK-NEXT: _0 = cmp_ref(_2, _4)
+    // CHECK-NEXT: _0 = cmp_ref(copy _2, copy _4)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<u8>(_3)
+    // CHECK-NEXT: _0 = opaque::<u8>(copy _3)
     mir! {
         {
             let a = 5_u8;
@@ -51,9 +51,9 @@ fn borrowed<T: Copy + Freeze>(x: T) -> bool {
     // CHECK-LABEL: fn borrowed(
     // CHECK: bb0: {
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_1)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _1)
     mir! {
         {
             let a = x;
@@ -74,11 +74,11 @@ fn borrowed<T: Copy + Freeze>(x: T) -> bool {
 fn non_freeze<T: Copy>(x: T) -> bool {
     // CHECK-LABEL: fn non_freeze(
     // CHECK: bb0: {
-    // CHECK-NEXT: _2 = _1;
+    // CHECK-NEXT: _2 = copy _1;
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_2)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _2)
     mir! {
         {
             let a = x;

tests/mir-opt/dataflow-const-prop/array_index.rs

@@ -16,6 +16,6 @@ fn main() {
     // CHECK:       {{_.*}} = const 4_usize;
     // CHECK:       {{_.*}} = const true;
     // CHECK:       assert(const true
-    // CHECK:       [[x]] = [[array_lit]][2 of 3];
+    // CHECK:       [[x]] = copy [[array_lit]][2 of 3];
     let x: u32 = [0, 1, 2, 3][2];
 }

tests/mir-opt/dataflow-const-prop/enum.rs

@@ -73,7 +73,7 @@ fn statics() {
     static RC: &E = &E::V2(4);
 
     // CHECK: [[t:_.*]] = const {alloc5: &&E};
-    // CHECK: [[e2]] = (*[[t]]);
+    // CHECK: [[e2]] = copy (*[[t]]);
     let e2 = RC;
 
     // CHECK: switchInt({{move _.*}}) -> {{.*}}
@@ -108,7 +108,7 @@ fn mutate_discriminant() -> u8 {
             // CHECK: [[a:_.*]] = discriminant({{_.*}});
             let a = Discriminant(x);
 
-            // CHECK: switchInt([[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}];
+            // CHECK: switchInt(copy [[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}];
             match a {
                 0 => bb1,
                 _ => bad,
@@ -143,8 +143,8 @@ fn multiple(x: bool, i: u8) {
     //   discriminant(e) => Top
     //   (e as Some).0 => Top
     // CHECK: [[x2]] = const 0_u8;
-    // CHECK: [[some:_.*]] = (({{_.*}} as Some).0: u8)
-    // CHECK: [[x2]] = [[some]];
+    // CHECK: [[some:_.*]] = copy (({{_.*}} as Some).0: u8)
+    // CHECK: [[x2]] = copy [[some]];
     let x2 = match e {
         Some(i) => i,
         None => 0,
@@ -153,7 +153,7 @@ fn multiple(x: bool, i: u8) {
     // Therefore, `x2` should be `Top` here, and no replacement shall happen.
 
     // CHECK-NOT: [[y]] = const
-    // CHECK: [[y]] = [[x2]];
+    // CHECK: [[y]] = copy [[x2]];
     // CHECK-NOT: [[y]] = const
     let y = x2;
 }

tests/mir-opt/dataflow-const-prop/large_array_index.rs

@@ -13,6 +13,6 @@ fn main() {
     // CHECK: {{_.*}} = const 5000_usize;
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true
-    // CHECK: [[x]] = [[array_lit]][2 of 3];
+    // CHECK: [[x]] = copy [[array_lit]][2 of 3];
     let x: u8 = [0_u8; 5000][2];
 }

tests/mir-opt/dataflow-const-prop/ref_without_sb.rs

@@ -24,7 +24,7 @@ fn main() {
     // This should currently not be propagated.
 
     // CHECK-NOT: [[b]] = const
-    // CHECK: [[b]] = [[a]];
+    // CHECK: [[b]] = copy [[a]];
     // CHECK-NOT: [[b]] = const
     let b = a;
 }

tests/mir-opt/dataflow-const-prop/repeat.rs

@@ -14,8 +14,8 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true
 
-    // CHECK-NOT: [[t:_.*]] = [[array_lit]][_
-    // CHECK: [[t:_.*]] = [[array_lit]][2 of 3];
+    // CHECK-NOT: [[t:_.*]] = {{copy|move}} [[array_lit]][_
+    // CHECK: [[t:_.*]] = copy [[array_lit]][2 of 3];
     // CHECK: [[x]] = Add(move [[t]], const 0_u32);
     let x: u32 = [42; 8][2] + 0;
 }

tests/mir-opt/dataflow-const-prop/sibling_ptr.rs

@@ -20,6 +20,6 @@ fn main() {
         *p.add(1) = 1;
     }
 
-    // CHECK: [[x1]] = ({{_.*}}.1: u8);
+    // CHECK: [[x1]] = copy ({{_.*}}.1: u8);
     let x1 = x.1; // should not be propagated
 }

tests/mir-opt/dataflow-const-prop/slice_len.rs

@@ -17,7 +17,7 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true,
 
-    // CHECK: [[local]] = (*{{_.*}})[1 of 2];
+    // CHECK: [[local]] = copy (*{{_.*}})[1 of 2];
     let local = (&[1u32, 2, 3] as &[u32])[1];
 
     // CHECK-NOT: {{_.*}} = Len(
@@ -28,7 +28,7 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true,
 
-    // CHECK-NOT: [[constant]] = (*{{_.*}})[_
-    // CHECK: [[constant]] = (*{{_.*}})[1 of 2];
+    // CHECK-NOT: [[constant]] = {{copy|move}} (*{{_.*}})[_
+    // CHECK: [[constant]] = copy (*{{_.*}})[1 of 2];
     let constant = SLICE[1];
 }

tests/mir-opt/dataflow-const-prop/struct.rs

@@ -46,15 +46,15 @@ fn main() {
     const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]);
 
     // CHECK: [[a1]] = const 4f32;
-    // CHECK: [[b1]] = ({{_.*}}.1: std::option::Option<S>);
-    // CHECK: [[c1]] = ({{_.*}}.2: &[f32]);
+    // CHECK: [[b1]] = copy ({{_.*}}.1: std::option::Option<S>);
+    // CHECK: [[c1]] = copy ({{_.*}}.2: &[f32]);
     let SmallStruct(a1, b1, c1) = SMALL_VAL;
 
     static SMALL_STAT: &SmallStruct = &SmallStruct(9., None, &[13.]);
 
     // CHECK: [[a2]] = const 9f32;
-    // CHECK: [[b2]] = ((*{{_.*}}).1: std::option::Option<S>);
-    // CHECK: [[c2]] = ((*{{_.*}}).2: &[f32]);
+    // CHECK: [[b2]] = copy ((*{{_.*}}).1: std::option::Option<S>);
+    // CHECK: [[c2]] = copy ((*{{_.*}}).2: &[f32]);
     let SmallStruct(a2, b2, c2) = *SMALL_STAT;
 
     // CHECK: [[ss]] = SmallStruct(const 9f32, move {{_.*}}, move {{_.*}});
@@ -63,14 +63,14 @@ fn main() {
     const BIG_VAL: BigStruct = BigStruct(25., None, &[]);
 
     // CHECK: [[a3]] = const 25f32;
-    // CHECK: [[b3]] = ({{_.*}}.1: std::option::Option<S>);
-    // CHECK: [[c3]] = ({{_.*}}.2: &[f32]);
+    // CHECK: [[b3]] = copy ({{_.*}}.1: std::option::Option<S>);
+    // CHECK: [[c3]] = copy ({{_.*}}.2: &[f32]);
     let BigStruct(a3, b3, c3) = BIG_VAL;
 
     static BIG_STAT: &BigStruct = &BigStruct(82., Some(S(35)), &[45., 72.]);
     // CHECK: [[a4]] = const 82f32;
-    // CHECK: [[b4]] = ((*{{_.*}}).1: std::option::Option<S>);
-    // CHECK: [[c4]] = ((*{{_.*}}).2: &[f32]);
+    // CHECK: [[b4]] = copy ((*{{_.*}}).1: std::option::Option<S>);
+    // CHECK: [[c4]] = copy ((*{{_.*}}).2: &[f32]);
     let BigStruct(a4, b4, c4) = *BIG_STAT;
 
     // We arbitrarily limit the size of synthetized values to 4 pointers.

tests/mir-opt/dead-store-elimination/call_arg_copy.rs

@@ -14,7 +14,7 @@ fn use_both(_: i32, _: i32) {}
 // EMIT_MIR call_arg_copy.move_simple.DeadStoreElimination-final.diff
 fn move_simple(x: i32) {
     // CHECK-LABEL: fn move_simple(
-    // CHECK: = use_both(_1, move _1)
+    // CHECK: = use_both(copy _1, move _1)
     use_both(x, x);
 }
 
@@ -28,7 +28,7 @@ struct Packed {
 #[custom_mir(dialect = "analysis")]
 fn move_packed(packed: Packed) {
     // CHECK-LABEL: fn move_packed(
-    // CHECK: = use_both(const 0_i32, (_1.1: i32))
+    // CHECK: = use_both(const 0_i32, copy (_1.1: i32))
     mir! {
         {
             // We have a packed struct, verify that the copy is not turned into a move.

tests/mir-opt/dest-prop/copy_propagation_arg.rs

@@ -41,9 +41,9 @@ fn arg_src(mut x: i32) -> i32 {
     // CHECK-LABEL: fn arg_src(
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
-    // CHECK: [[y]] = [[x]]
+    // CHECK: [[y]] = copy [[x]]
     // CHECK: [[x]] = const 123_i32;
-    // CHECK-NOT: {{_.*}} = [[y]];
+    // CHECK-NOT: {{_.*}} = copy [[y]];
     let y = x;
     x = 123; // Don't propagate this assignment to `y`
     y