Account for unops when suggesting cloning

estebank · estebank · commit bce78102c31c · 2024-04-11T16:41:41.000Z
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1034,27 +1034,32 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
             } else {
                 ".clone()".to_owned()
             };
-        if let Some(clone_trait_def) = tcx.lang_items().clone_trait()
-            && self
-                .infcx
-                .type_implements_trait(clone_trait_def, [ty], self.param_env)
-                .must_apply_modulo_regions()
+        let mut sugg = Vec::with_capacity(2);
+        let mut inner_expr = expr;
+        while let hir::ExprKind::AddrOf(.., inner) | hir::ExprKind::Unary(hir::UnOp::Deref, inner) =
+            &inner_expr.kind
         {
-            let msg = if let ty::Adt(def, _) = ty.kind()
-                && [tcx.get_diagnostic_item(sym::Arc), tcx.get_diagnostic_item(sym::Rc)]
-                    .contains(&Some(def.did()))
-            {
-                "clone the value to increment its reference count"
-            } else {
-                "consider cloning the value if the performance cost is acceptable"
-            };
-            err.span_suggestion_verbose(
-                span.shrink_to_hi(),
-                msg,
-                suggestion,
-                Applicability::MachineApplicable,
-            );
+            inner_expr = inner;
         }
+        if inner_expr.span.lo() != expr.span.lo() {
+            sugg.push((expr.span.with_hi(inner_expr.span.lo()), String::new()));
+        }
+        let span = if inner_expr.span.hi() != expr.span.hi() {
+            // Account for `(*x)` to suggest `x.clone()`.
+            expr.span.with_lo(inner_expr.span.hi())
+        } else {
+            span.shrink_to_hi()
+        };
+        sugg.push((span, suggestion));
+        let msg = if let ty::Adt(def, _) = ty.kind()
+            && [tcx.get_diagnostic_item(sym::Arc), tcx.get_diagnostic_item(sym::Rc)]
+                .contains(&Some(def.did()))
+        {
+            "clone the value to increment its reference count"
+        } else {
+            "consider cloning the value if the performance cost is acceptable"
+        };
+        err.multipart_suggestion_verbose(msg, sugg, Applicability::MachineApplicable);
     }
 
     fn suggest_adding_bounds(&self, err: &mut Diag<'_>, ty: Ty<'tcx>, def_id: DefId, span: Span) {
diff --git a/tests/ui/associated-types/associated-types-outlives.stderr b/tests/ui/associated-types/associated-types-outlives.stderr
@@ -13,8 +13,9 @@ LL |         return f(y);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |         's: loop { y = denormalise(&x.clone()); break }
-   |                                      ++++++++
+LL -         's: loop { y = denormalise(&x); break }
+LL +         's: loop { y = denormalise(x.clone()); break }
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/binop/binop-move-semantics.stderr b/tests/ui/binop/binop-move-semantics.stderr
@@ -54,8 +54,9 @@ LL |     use_mut(n); use_imm(m);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let m = &x.clone();
-   |               ++++++++
+LL -     let m = &x;
+LL +     let m = x.clone();
+   |
 
 error[E0505]: cannot move out of `y` because it is borrowed
   --> $DIR/binop-move-semantics.rs:23:5
diff --git a/tests/ui/borrowck/borrow-tuple-fields.stderr b/tests/ui/borrowck/borrow-tuple-fields.stderr
@@ -13,8 +13,9 @@ LL |     r.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let r = &x.0.clone();
-   |                 ++++++++
+LL -     let r = &x.0;
+LL +     let r = x.0.clone();
+   |
 
 error[E0502]: cannot borrow `x.0` as mutable because it is also borrowed as immutable
   --> $DIR/borrow-tuple-fields.rs:18:13
@@ -50,8 +51,9 @@ LL |     r.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let r = &x.0.clone();
-   |                 ++++++++
+LL -     let r = &x.0;
+LL +     let r = x.0.clone();
+   |
 
 error[E0502]: cannot borrow `x.0` as mutable because it is also borrowed as immutable
   --> $DIR/borrow-tuple-fields.rs:33:13
diff --git a/tests/ui/borrowck/borrowck-bad-nested-calls-move.stderr b/tests/ui/borrowck/borrowck-bad-nested-calls-move.stderr
@@ -13,8 +13,9 @@ LL |         a);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |         &*a.clone(),
-   |            ++++++++
+LL -         &*a,
+LL +         a.clone(),
+   |
 
 error[E0505]: cannot move out of `a` because it is borrowed
   --> $DIR/borrowck-bad-nested-calls-move.rs:32:9
@@ -30,8 +31,9 @@ LL |         a);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |         &*a.clone(),
-   |            ++++++++
+LL -         &*a,
+LL +         a.clone(),
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/borrowck/borrowck-field-sensitivity.stderr b/tests/ui/borrowck/borrowck-field-sensitivity.stderr
@@ -52,8 +52,9 @@ LL |     drop(**p);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p = &x.b.clone();
-   |                 ++++++++
+LL -     let p = &x.b;
+LL +     let p = x.b.clone();
+   |
 
 error[E0505]: cannot move out of `x.b` because it is borrowed
   --> $DIR/borrowck-field-sensitivity.rs:41:14
@@ -69,8 +70,9 @@ LL |     drop(**p);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p = &x.b.clone();
-   |                 ++++++++
+LL -     let p = &x.b;
+LL +     let p = x.b.clone();
+   |
 
 error[E0499]: cannot borrow `x.a` as mutable more than once at a time
   --> $DIR/borrowck-field-sensitivity.rs:48:13
diff --git a/tests/ui/borrowck/borrowck-loan-blocks-move-cc.stderr b/tests/ui/borrowck/borrowck-loan-blocks-move-cc.stderr
@@ -16,8 +16,9 @@ LL |     w.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let w = &v.clone();
-   |               ++++++++
+LL -     let w = &v;
+LL +     let w = v.clone();
+   |
 
 error[E0505]: cannot move out of `v` because it is borrowed
   --> $DIR/borrowck-loan-blocks-move-cc.rs:24:19
@@ -37,8 +38,9 @@ LL |     w.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let w = &v.clone();
-   |               ++++++++
+LL -     let w = &v;
+LL +     let w = v.clone();
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/borrowck/borrowck-loan-blocks-move.stderr b/tests/ui/borrowck/borrowck-loan-blocks-move.stderr
@@ -12,8 +12,9 @@ LL |     w.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let w = &v.clone();
-   |               ++++++++
+LL -     let w = &v;
+LL +     let w = v.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr b/tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr
@@ -13,8 +13,9 @@ LL |     b.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let b = &a.clone();
-   |               ++++++++
+LL -     let b = &a;
+LL +     let b = a.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr b/tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr
@@ -13,8 +13,9 @@ LL |     p.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p: &isize = &*t0.clone(); // Freezes `*t0`
-   |                         ++++++++
+LL -     let p: &isize = &*t0; // Freezes `*t0`
+LL +     let p: &isize = t0.clone(); // Freezes `*t0`
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/borrowck-move-subcomponent.stderr b/tests/ui/borrowck/borrowck-move-subcomponent.stderr
@@ -12,8 +12,9 @@ LL |   f(pb);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |   let pb = &a.clone();
-   |              ++++++++
+LL -   let pb = &a;
+LL +   let pb = a.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/borrowck-multiple-captures.stderr b/tests/ui/borrowck/borrowck-multiple-captures.stderr
@@ -17,8 +17,9 @@ LL |     borrow(&*p1);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p1 = &x1.clone();
-   |                 ++++++++
+LL -     let p1 = &x1;
+LL +     let p1 = x1.clone();
+   |
 
 error[E0505]: cannot move out of `x2` because it is borrowed
   --> $DIR/borrowck-multiple-captures.rs:12:19
@@ -38,8 +39,9 @@ LL |     borrow(&*p2);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p2 = &x2.clone();
-   |                 ++++++++
+LL -     let p2 = &x2;
+LL +     let p2 = x2.clone();
+   |
 
 error[E0382]: use of moved value: `x1`
   --> $DIR/borrowck-multiple-captures.rs:27:19
@@ -106,8 +108,9 @@ LL |     borrow(&*p);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let p = &x.clone();
-   |               ++++++++
+LL -     let p = &x;
+LL +     let p = x.clone();
+   |
 
 error[E0382]: use of moved value: `x`
   --> $DIR/borrowck-multiple-captures.rs:52:14
diff --git a/tests/ui/borrowck/borrowck-unary-move.stderr b/tests/ui/borrowck/borrowck-unary-move.stderr
@@ -12,8 +12,9 @@ LL |     *y
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let y = &*x.clone();
-   |                ++++++++
+LL -     let y = &*x;
+LL +     let y = x.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/borrowck/clone-on-ref.fixed b/tests/ui/borrowck/clone-on-ref.fixed
@@ -9,7 +9,7 @@ fn foo<T: Default + Clone>(list: &mut Vec<T>) {
     drop(cloned_items);
 }
 fn bar<T: std::fmt::Display + Clone>(x: T) {
-    let a = &x.clone();
+    let a = x.clone();
     let b = a.clone();
     drop(x);
     //~^ ERROR cannot move out of `x` because it is borrowed
@@ -19,7 +19,7 @@ fn bar<T: std::fmt::Display + Clone>(x: T) {
 #[derive(Clone)]
 struct A;
 fn qux(x: A) {
-    let a = &x.clone();
+    let a = x.clone();
     let b = a.clone();
     drop(x);
     //~^ ERROR cannot move out of `x` because it is borrowed
diff --git a/tests/ui/borrowck/clone-on-ref.stderr b/tests/ui/borrowck/clone-on-ref.stderr
@@ -38,8 +38,9 @@ LL | fn bar<T: std::fmt::Display + Clone>(x: T) {
    |                             +++++++
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let a = &x.clone();
-   |               ++++++++
+LL -     let a = &x;
+LL +     let a = x.clone();
+   |
 
 error[E0505]: cannot move out of `x` because it is borrowed
   --> $DIR/clone-on-ref.rs:23:10
@@ -63,8 +64,9 @@ LL | struct A;
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let a = &x.clone();
-   |               ++++++++
+LL -     let a = &x;
+LL +     let a = x.clone();
+   |
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/btreemap/btreemap_dropck.stderr b/tests/ui/btreemap/btreemap_dropck.stderr
@@ -12,8 +12,9 @@ LL | }
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let _map = BTreeMap::from_iter([((), PrintOnDrop(&s.clone()))]);
-   |                                                        ++++++++
+LL -     let _map = BTreeMap::from_iter([((), PrintOnDrop(&s))]);
+LL +     let _map = BTreeMap::from_iter([((), PrintOnDrop(s.clone()))]);
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0504.stderr b/tests/ui/error-codes/E0504.stderr
@@ -16,8 +16,9 @@ LL |     println!("main function: {}", fancy_ref.num);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let fancy_ref = &fancy_num.clone();
-   |                               ++++++++
+LL -     let fancy_ref = &fancy_num;
+LL +     let fancy_ref = fancy_num.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0505.stderr b/tests/ui/error-codes/E0505.stderr
@@ -13,8 +13,9 @@ LL |         _ref_to_val.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |         let _ref_to_val: &Value = &x.clone();
-   |                                     ++++++++
+LL -         let _ref_to_val: &Value = &x;
+LL +         let _ref_to_val: &Value = x.clone();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr
@@ -13,8 +13,9 @@ LL |     println!("{}", y);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let y = f(&x.clone(), ());
-   |                 ++++++++
+LL -     let y = f(&x, ());
+LL +     let y = f(x.clone(), ());
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
@@ -30,8 +30,9 @@ LL |     println!("{}", y);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let y = f(&x.clone(), ());
-   |                 ++++++++
+LL -     let y = f(&x, ());
+LL +     let y = f(x.clone(), ());
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type.stderr
@@ -13,8 +13,9 @@ LL |     println!("{}", y);
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let y = f(&x.clone(), ());
-   |                 ++++++++
+LL -     let y = f(&x, ());
+LL +     let y = f(x.clone(), ());
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/closure-access-spans.stderr b/tests/ui/nll/closure-access-spans.stderr
@@ -60,8 +60,9 @@ LL |     r.use_ref();
    |
 help: consider cloning the value if the performance cost is acceptable
    |
-LL |     let r = &x.clone();
-   |               ++++++++
+LL -     let r = &x;
+LL +     let r = x.clone();
+   |
 
 error[E0382]: borrow of moved value: `x`
   --> $DIR/closure-access-spans.rs:35:5
diff --git a/tests/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr b/tests/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr
diff --git a/tests/ui/span/send-is-not-static-std-sync.stderr b/tests/ui/span/send-is-not-static-std-sync.stderr
diff --git a/tests/ui/suggestions/borrow-for-loop-head.stderr b/tests/ui/suggestions/borrow-for-loop-head.stderr
diff --git a/tests/ui/unop-move-semantics.stderr b/tests/ui/unop-move-semantics.stderr
diff --git a/tests/ui/variance/variance-issue-20533.stderr b/tests/ui/variance/variance-issue-20533.stderr

Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ LL \| return f(y);`
`13`	`13`	`\|`
`14`	`14`	`help: consider cloning the value if the performance cost is acceptable`
`15`	`15`	`\|`
`16`		`-LL \| 's: loop { y = denormalise(&x.clone()); break }`
`17`		`- \| ++++++++`
	`16`	`+LL - 's: loop { y = denormalise(&x); break }`
	`17`	`+LL + 's: loop { y = denormalise(x.clone()); break }`
	`18`	`+ \|`
`18`	`19`
`19`	`20`	`error: aborting due to 1 previous error`
`20`	`21`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,9 @@ LL \| use_mut(n); use_imm(m);`
`54`	`54`	`\|`
`55`	`55`	`help: consider cloning the value if the performance cost is acceptable`
`56`	`56`	`\|`
`57`		`-LL \| let m = &x.clone();`
`58`		`- \| ++++++++`
	`57`	`+LL - let m = &x;`
	`58`	`+LL + let m = x.clone();`
	`59`	`+ \|`
`59`	`60`
`60`	`61`	error[E0505]: cannot move out of `y` because it is borrowed
`61`	`62`	`--> $DIR/binop-move-semantics.rs:23:5`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ LL \| r.use_ref();`
`13`	`13`	`\|`
`14`	`14`	`help: consider cloning the value if the performance cost is acceptable`
`15`	`15`	`\|`
`16`		`-LL \| let r = &x.0.clone();`
`17`		`- \| ++++++++`
	`16`	`+LL - let r = &x.0;`
	`17`	`+LL + let r = x.0.clone();`
	`18`	`+ \|`
`18`	`19`
`19`	`20`	error[E0502]: cannot borrow `x.0` as mutable because it is also borrowed as immutable
`20`	`21`	`--> $DIR/borrow-tuple-fields.rs:18:13`
`@@ -50,8 +51,9 @@ LL \| r.use_ref();`
`50`	`51`	`\|`
`51`	`52`	`help: consider cloning the value if the performance cost is acceptable`
`52`	`53`	`\|`
`53`		`-LL \| let r = &x.0.clone();`
`54`		`- \| ++++++++`
	`54`	`+LL - let r = &x.0;`
	`55`	`+LL + let r = x.0.clone();`
	`56`	`+ \|`
`55`	`57`
`56`	`58`	error[E0502]: cannot borrow `x.0` as mutable because it is also borrowed as immutable
`57`	`59`	`--> $DIR/borrow-tuple-fields.rs:33:13`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ LL \| a);`
`13`	`13`	`\|`
`14`	`14`	`help: consider cloning the value if the performance cost is acceptable`
`15`	`15`	`\|`
`16`		`-LL \| &*a.clone(),`
`17`		`- \| ++++++++`
	`16`	`+LL - &*a,`
	`17`	`+LL + a.clone(),`
	`18`	`+ \|`
`18`	`19`
`19`	`20`	error[E0505]: cannot move out of `a` because it is borrowed
`20`	`21`	`--> $DIR/borrowck-bad-nested-calls-move.rs:32:9`
`@@ -30,8 +31,9 @@ LL \| a);`
`30`	`31`	`\|`
`31`	`32`	`help: consider cloning the value if the performance cost is acceptable`
`32`	`33`	`\|`
`33`		`-LL \| &*a.clone(),`
`34`		`- \| ++++++++`
	`34`	`+LL - &*a,`
	`35`	`+LL + a.clone(),`
	`36`	`+ \|`
`35`	`37`
`36`	`38`	`error: aborting due to 2 previous errors`
`37`	`39`
Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,9 @@ LL \| drop(**p);`
`52`	`52`	`\|`
`53`	`53`	`help: consider cloning the value if the performance cost is acceptable`
`54`	`54`	`\|`
`55`		`-LL \| let p = &x.b.clone();`
`56`		`- \| ++++++++`
	`55`	`+LL - let p = &x.b;`
	`56`	`+LL + let p = x.b.clone();`
	`57`	`+ \|`
`57`	`58`
`58`	`59`	error[E0505]: cannot move out of `x.b` because it is borrowed
`59`	`60`	`--> $DIR/borrowck-field-sensitivity.rs:41:14`
`@@ -69,8 +70,9 @@ LL \| drop(**p);`
`69`	`70`	`\|`
`70`	`71`	`help: consider cloning the value if the performance cost is acceptable`
`71`	`72`	`\|`
`72`		`-LL \| let p = &x.b.clone();`
`73`		`- \| ++++++++`
	`73`	`+LL - let p = &x.b;`
	`74`	`+LL + let p = x.b.clone();`
	`75`	`+ \|`
`74`	`76`
`75`	`77`	error[E0499]: cannot borrow `x.a` as mutable more than once at a time
`76`	`78`	`--> $DIR/borrowck-field-sensitivity.rs:48:13`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,9 @@ LL \| w.use_ref();`
`16`	`16`	`\|`
`17`	`17`	`help: consider cloning the value if the performance cost is acceptable`
`18`	`18`	`\|`
`19`		`-LL \| let w = &v.clone();`
`20`		`- \| ++++++++`
	`19`	`+LL - let w = &v;`
	`20`	`+LL + let w = v.clone();`
	`21`	`+ \|`
`21`	`22`
`22`	`23`	error[E0505]: cannot move out of `v` because it is borrowed
`23`	`24`	`--> $DIR/borrowck-loan-blocks-move-cc.rs:24:19`
`@@ -37,8 +38,9 @@ LL \| w.use_ref();`
`37`	`38`	`\|`
`38`	`39`	`help: consider cloning the value if the performance cost is acceptable`
`39`	`40`	`\|`
`40`		`-LL \| let w = &v.clone();`
`41`		`- \| ++++++++`
	`41`	`+LL - let w = &v;`
	`42`	`+LL + let w = v.clone();`
	`43`	`+ \|`
`42`	`44`
`43`	`45`	`error: aborting due to 2 previous errors`
`44`	`46`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,9 @@ LL \| w.use_ref();`
`12`	`12`	`\|`
`13`	`13`	`help: consider cloning the value if the performance cost is acceptable`
`14`	`14`	`\|`
`15`		`-LL \| let w = &v.clone();`
`16`		`- \| ++++++++`
	`15`	`+LL - let w = &v;`
	`16`	`+LL + let w = v.clone();`
	`17`	`+ \|`
`17`	`18`
`18`	`19`	`error: aborting due to 1 previous error`
`19`	`20`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ LL \| b.use_ref();`
`13`	`13`	`\|`
`14`	`14`	`help: consider cloning the value if the performance cost is acceptable`
`15`	`15`	`\|`
`16`		`-LL \| let b = &a.clone();`
`17`		`- \| ++++++++`
	`16`	`+LL - let b = &a;`
	`17`	`+LL + let b = a.clone();`
	`18`	`+ \|`
`18`	`19`
`19`	`20`	`error: aborting due to 1 previous error`
`20`	`21`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,9 @@ LL \| p.use_ref();`
`13`	`13`	`\|`
`14`	`14`	`help: consider cloning the value if the performance cost is acceptable`
`15`	`15`	`\|`
`16`		-LL \| let p: &isize = &t0.clone(); // Freezes `t0`
`17`		`- \| ++++++++`
	`16`	+LL - let p: &isize = &t0; // Freezes `t0`
	`17`	+LL + let p: &isize = t0.clone(); // Freezes `*t0`
	`18`	`+ \|`
`18`	`19`
`19`	`20`	`error: aborting due to 1 previous error`
`20`	`21`