Auto merge of #122551 - RayMuir:copy_fmt, r=saethlin

Added "copy" to Debug fmt for copy operands

In MIR's debug mode (--emit mir) the printing for Operands is slightly inconsistent.

The RValues - values on the right side of an Assign - are usually printed with their Operand when they are Places.

Example:
_2 = move _3

But for arguments, the operand is omitted.

_2 = _1

I propose a change be made, to display the place with the operand.

_2 = copy _1

Move and copy have different semantics, meaning this difference is important and helpful to the user. It also adds consistency to the pretty printing.

-- EDIT --

 Consider this example Rust program and its MIR output with the **updated pretty printer.**

This was generated with the arguments --emit mir --crate-type lib -Zmir-opt-level=0 (Otherwise, it's optimised away since it's a junk program).

```rust
fn main(foo: i32) {
    let v = 10;

    if v == 20 {
        foo;
    }
    else {
        v;
    }
}
```

```MIR
// WARNING: This output format is intended for human consumers only
// and is subject to change without notice. Knock yourself out.
fn main(_1: i32) -> () {
    debug foo => _1;
    let mut _0: ();
    let _2: i32;
    let mut _3: bool;
    let mut _4: i32;
    let _5: i32;
    let _6: i32;
    scope 1 {
        debug v => _2;
    }

    bb0: {
        StorageLive(_2);
        _2 = const 10_i32;
        StorageLive(_3);
        StorageLive(_4);
        _4 = copy _2;
        _3 = Eq(move _4, const 20_i32);
        switchInt(move _3) -> [0: bb2, otherwise: bb1];
    }

    bb1: {
        StorageDead(_4);
        StorageLive(_5);
        _5 = copy _1;
        StorageDead(_5);
        _0 = const ();
        goto -> bb3;
    }

    bb2: {
        StorageDead(_4);
        StorageLive(_6);
        _6 = copy _2;
        StorageDead(_6);
        _0 = const ();
        goto -> bb3;
    }

    bb3: {
        StorageDead(_3);
        StorageDead(_2);
        return;
    }
}
```

In this example program, we can see that when we move a place, it is preceded by "move". e.g. ``` _3 = Eq(move _4, const 20_i32);```. However, when we copy a place such as ```_5 = _1;```, it is not preceded by the operand in the original printout. I propose to change the print to include the copy ```_5 = copy _1``` as in this example.

Regarding the arguments part. When I originally submitted this PR, I was under the impression this only affected the print for arguments to a function, but actually, it affects anything that uses a copy. This is preferable anyway with regard to consistency. The PR is about making ```copy``` explicit.

1 files changed, 5 insertions, 5 deletions

diff --git a/tests/mir-opt/dataflow-const-prop/enum.rs b/tests/mir-opt/dataflow-const-prop/enum.rs
index 37304e3a270..207e29e63df 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.rs
+++ b/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;
 }