mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Peel off explicit (or implicit) deref before suggesting clone on move error in borrowck

Browse source
This commit is contained in:
Michael Goulet 2024-07-26 14:32:19 -04:00
parent e7eae5370e
commit 91acacf85b
45 changed files with 111 additions and 351 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View file

@ -570,11 +570,11 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
} = move_spans
&& can_suggest_clone
{
self.suggest_cloning(err, ty, expr, None, Some(move_spans));
self.suggest_cloning(err, ty, expr, Some(move_spans));
} else if self.suggest_hoisting_call_outside_loop(err, expr) && can_suggest_clone {
// The place where the type moves would be misleading to suggest clone.
// #121466
self.suggest_cloning(err, ty, expr, None, Some(move_spans));
self.suggest_cloning(err, ty, expr, Some(move_spans));
}
}
@ -1236,8 +1236,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
&self,
err: &mut Diag<'_>,
ty: Ty<'tcx>,
mut expr: &'tcx hir::Expr<'tcx>,
mut other_expr: Option<&'tcx hir::Expr<'tcx>>,
expr: &'tcx hir::Expr<'tcx>,
use_spans: Option<UseSpans<'tcx>>,
) {
if let hir::ExprKind::Struct(_, _, Some(_)) = expr.kind {
@ -1249,66 +1248,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
return;
}
if let Some(some_other_expr) = other_expr
&& let Some(parent_binop) =
self.infcx.tcx.hir().parent_iter(expr.hir_id).find_map(|n| {
if let (hir_id, hir::Node::Expr(e)) = n
&& let hir::ExprKind::AssignOp(_binop, target, _arg) = e.kind
&& target.hir_id == expr.hir_id
{
Some(hir_id)
} else {
None
}
})
&& let Some(other_parent_binop) =
self.infcx.tcx.hir().parent_iter(some_other_expr.hir_id).find_map(|n| {
if let (hir_id, hir::Node::Expr(expr)) = n
&& let hir::ExprKind::AssignOp(..) = expr.kind
{
Some(hir_id)
} else {
None
}
})
&& parent_binop == other_parent_binop
{
// Explicitly look for `expr += other_expr;` and avoid suggesting
// `expr.clone() += other_expr;`, instead suggesting `expr += other_expr.clone();`.
other_expr = Some(expr);
expr = some_other_expr;
}
'outer: {
if let ty::Ref(..) = ty.kind() {
// We check for either `let binding = foo(expr, other_expr);` or
// `foo(expr, other_expr);` and if so we don't suggest an incorrect
// `foo(expr, other_expr).clone()`
if let Some(other_expr) = other_expr
&& let Some(parent_let) =
self.infcx.tcx.hir().parent_iter(expr.hir_id).find_map(|n| {
if let (hir_id, hir::Node::LetStmt(_) | hir::Node::Stmt(_)) = n {
Some(hir_id)
} else {
None
}
})
&& let Some(other_parent_let) =
self.infcx.tcx.hir().parent_iter(other_expr.hir_id).find_map(|n| {
if let (hir_id, hir::Node::LetStmt(_) | hir::Node::Stmt(_)) = n {
Some(hir_id)
} else {
None
}
})
&& parent_let == other_parent_let
{
// Explicitly check that we don't have `foo(&*expr, other_expr)`, as cloning the
// result of `foo(...)` won't help.
break 'outer;
}
}
}
let ty = ty.peel_refs();
if self.implements_clone(ty) {
self.suggest_cloning_inner(err, ty, expr);
} else if let ty::Adt(def, args) = ty.kind()
@ -1575,10 +1514,27 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
);
self.suggest_copy_for_type_in_cloned_ref(&mut err, place);
let typeck_results = self.infcx.tcx.typeck(self.mir_def_id());
if let Some(expr) = self.find_expr(borrow_span)
&& let Some(ty) = typeck_results.node_type_opt(expr.hir_id)
{
self.suggest_cloning(&mut err, ty, expr, self.find_expr(span), Some(move_spans));
if let Some(expr) = self.find_expr(borrow_span) {
// This is a borrow span, so we want to suggest cloning the referent.
if let hir::ExprKind::AddrOf(_, _, borrowed_expr) = expr.kind
&& let Some(ty) = typeck_results.expr_ty_opt(borrowed_expr)
{
self.suggest_cloning(&mut err, ty, borrowed_expr, Some(move_spans));
} else if typeck_results.expr_adjustments(expr).first().is_some_and(|adj| {
matches!(
adj.kind,
ty::adjustment::Adjust::Borrow(ty::adjustment::AutoBorrow::Ref(
_,
ty::adjustment::AutoBorrowMutability::Not
| ty::adjustment::AutoBorrowMutability::Mut {
allow_two_phase_borrow: ty::adjustment::AllowTwoPhase::No
}
))
)
}) && let Some(ty) = typeck_results.expr_ty_opt(expr)
{
self.suggest_cloning(&mut err, ty, expr, Some(move_spans));
}
}
self.buffer_error(err);
}

16
compiler/rustc_borrowck/src/diagnostics/move_errors.rs
View file

@ -565,9 +565,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
fn add_move_hints(&self, error: GroupedMoveError<'tcx>, err: &mut Diag<'_>, span: Span) {
match error {
GroupedMoveError::MovesFromPlace {
mut binds_to, move_from, span: other_span, ..
} => {
GroupedMoveError::MovesFromPlace { mut binds_to, move_from, .. } => {
self.add_borrow_suggestions(err, span);
if binds_to.is_empty() {
let place_ty = move_from.ty(self.body, self.infcx.tcx).ty;
@ -577,7 +575,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
};
if let Some(expr) = self.find_expr(span) {
self.suggest_cloning(err, place_ty, expr, self.find_expr(other_span), None);
self.suggest_cloning(err, place_ty, expr, None);
}
err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
@ -609,13 +607,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
};
if let Some(expr) = self.find_expr(use_span) {
self.suggest_cloning(
err,
place_ty,
expr,
self.find_expr(span),
Some(use_spans),
);
self.suggest_cloning(err, place_ty, expr, Some(use_spans));
}
err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
@ -740,7 +732,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
let place_desc = &format!("`{}`", self.local_names[*local].unwrap());
if let Some(expr) = self.find_expr(binding_span) {
self.suggest_cloning(err, bind_to.ty, expr, None, None);
self.suggest_cloning(err, bind_to.ty, expr, None);
}
err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {

2
tests/ui/associated-types/associated-types-outlives.stderr
View file

@ -18,7 +18,7 @@ LL | pub fn free_and_use<T: for<'a> Foo<'a>,
| ^ consider constraining this type parameter with `Clone`
...
LL | 's: loop { y = denormalise(&x); break }
| -- you could clone this value
| - you could clone this value
error: aborting due to 1 previous error

1
tests/ui/augmented-assignments.rs
View file

@ -17,7 +17,6 @@ fn main() {
x;
//~^ ERROR cannot move out of `x` because it is borrowed
//~| move out of `x` occurs here
//~| HELP consider cloning
let y = Int(2);
//~^ HELP consider changing this to be mutable

7
tests/ui/augmented-assignments.stderr
View file

@ -8,14 +8,9 @@ LL | x
...
LL | x;
| ^ move out of `x` occurs here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | x.clone();
| ++++++++
error[E0596]: cannot borrow `y` as mutable, as it is not declared as mutable
--> $DIR/augmented-assignments.rs:25:5
--> $DIR/augmented-assignments.rs:24:5
|
LL | y
| ^ cannot borrow as mutable

4
tests/ui/binop/binop-move-semantics.stderr
View file

@ -65,7 +65,7 @@ help: if `T` implemented `Clone`, you could clone the value
LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let m = &x;
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `y` because it is borrowed
--> $DIR/binop-move-semantics.rs:23:5
@ -88,7 +88,7 @@ LL | fn move_borrowed<T: Add<Output=()>>(x: T, mut y: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let m = &x;
LL | let n = &mut y;
| ------ you could clone this value
| - you could clone this value
error[E0507]: cannot move out of `*m` which is behind a mutable reference
--> $DIR/binop-move-semantics.rs:30:5

10
tests/ui/borrowck/borrow-tuple-fields.stderr
View file

@ -13,9 +13,8 @@ LL | r.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let r = &x.0;
LL + let r = x.0.clone();
|
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
@ -51,9 +50,8 @@ LL | r.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let r = &x.0;
LL + let r = x.0.clone();
|
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

4
tests/ui/borrowck/borrowck-bad-nested-calls-move.stderr
View file

@ -14,7 +14,7 @@ LL | a);
help: consider cloning the value if the performance cost is acceptable
|
LL - &*a,
LL + a.clone(),
LL + &a.clone(),
|
error[E0505]: cannot move out of `a` because it is borrowed
@ -32,7 +32,7 @@ LL | a);
help: consider cloning the value if the performance cost is acceptable
|
LL - &*a,
LL + a.clone(),
LL + &a.clone(),
|
error: aborting due to 2 previous errors

10
tests/ui/borrowck/borrowck-field-sensitivity.stderr
View file

@ -52,9 +52,8 @@ LL | drop(**p);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let p = &x.b;
LL + let p = x.b.clone();
|
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
@ -70,9 +69,8 @@ LL | drop(**p);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let p = &x.b;
LL + let p = x.b.clone();
|
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

5
tests/ui/borrowck/borrowck-issue-48962.stderr
View file

@ -17,11 +17,6 @@ LL | {src};
| --- value moved here
LL | src.0 = 66;
| ^^^^^^^^^^ value used here after move
|
help: consider cloning the value if the performance cost is acceptable
|
LL | {src.clone()};
| ++++++++
error: aborting due to 2 previous errors

10
tests/ui/borrowck/borrowck-loan-blocks-move-cc.stderr
View file

@ -16,9 +16,8 @@ LL | w.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let w = &v;
LL + let w = v.clone();
|
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
@ -38,9 +37,8 @@ LL | w.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let w = &v;
LL + let w = v.clone();
|
LL | let w = &v.clone();
| ++++++++
error: aborting due to 2 previous errors

5
tests/ui/borrowck/borrowck-loan-blocks-move.stderr
View file

@ -12,9 +12,8 @@ LL | w.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let w = &v;
LL + let w = v.clone();
|
LL | let w = &v.clone();
| ++++++++
error: aborting due to 1 previous error

5
tests/ui/borrowck/borrowck-move-from-subpath-of-borrowed-path.stderr
View file

@ -13,9 +13,8 @@ LL | b.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let b = &a;
LL + let b = a.clone();
|
LL | let b = &a.clone();
| ++++++++
error: aborting due to 1 previous error

2
tests/ui/borrowck/borrowck-move-mut-base-ptr.stderr
View file

@ -14,7 +14,7 @@ LL | p.use_ref();
help: consider cloning the value if the performance cost is acceptable
|
LL - let p: &isize = &*t0; // Freezes `*t0`
LL + let p: &isize = t0.clone(); // Freezes `*t0`
LL + let p: &isize = &t0.clone(); // Freezes `*t0`
|
error: aborting due to 1 previous error

2
tests/ui/borrowck/borrowck-move-subcomponent.stderr
View file

@ -17,7 +17,7 @@ LL | struct S {
| ^^^^^^^^ consider implementing `Clone` for this type
...
LL | let pb = &a;
| -- you could clone this value
| - you could clone this value
error: aborting due to 1 previous error

15
tests/ui/borrowck/borrowck-multiple-captures.stderr
View file

@ -17,9 +17,8 @@ LL | borrow(&*p1);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let p1 = &x1;
LL + let p1 = x1.clone();
|
LL | let p1 = &x1.clone();
| ++++++++
error[E0505]: cannot move out of `x2` because it is borrowed
--> $DIR/borrowck-multiple-captures.rs:12:19
@ -39,9 +38,8 @@ LL | borrow(&*p2);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let p2 = &x2;
LL + let p2 = x2.clone();
|
LL | let p2 = &x2.clone();
| ++++++++
error[E0382]: use of moved value: `x1`
--> $DIR/borrowck-multiple-captures.rs:27:19
@ -108,9 +106,8 @@ LL | borrow(&*p);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let p = &x;
LL + let p = x.clone();
|
LL | let p = &x.clone();
| ++++++++
error[E0382]: use of moved value: `x`
--> $DIR/borrowck-multiple-captures.rs:52:14

10
tests/ui/borrowck/borrowck-overloaded-index-move-index.stderr
View file

@ -11,6 +11,11 @@ LL | println!("{}", f[s]);
...
LL | use_mut(rs);
| -- borrow later used here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | let rs = &mut s.clone();
| ++++++++
error[E0505]: cannot move out of `s` because it is borrowed
--> $DIR/borrowck-overloaded-index-move-index.rs:53:7
@ -25,6 +30,11 @@ LL | f[s] = 10;
...
LL | use_mut(rs);
| -- borrow later used here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | let rs = &mut s.clone();
| ++++++++
error[E0382]: use of moved value: `s`
--> $DIR/borrowck-overloaded-index-move-index.rs:53:7

2
tests/ui/borrowck/borrowck-unary-move.stderr
View file

@ -13,7 +13,7 @@ LL | *y
help: consider cloning the value if the performance cost is acceptable
|
LL - let y = &*x;
LL + let y = x.clone();
LL + let y = &x.clone();
|
error: aborting due to 1 previous error

4
tests/ui/borrowck/clone-on-ref.stderr
View file

@ -38,7 +38,7 @@ help: if `T` implemented `Clone`, you could clone the value
LL | fn bar<T: std::fmt::Display>(x: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let a = &x;
| -- you could clone this value
| - you could clone this value
help: consider further restricting this bound
|
LL | fn bar<T: std::fmt::Display + Clone>(x: T) {
@ -66,7 +66,7 @@ LL | struct A;
| ^^^^^^^^ consider implementing `Clone` for this type
LL | fn qux(x: A) {
LL | let a = &x;
| -- you could clone this value
| - you could clone this value
help: consider annotating `A` with `#[derive(Clone)]`
|
LL + #[derive(Clone)]

8
tests/ui/borrowck/issue-101119.stderr
View file

@ -18,14 +18,6 @@ LL | fn fill_segment(_: &mut State) {}
| ------------ ^^^^^^^^^^ this parameter takes ownership of the value
| |
| in this function
note: if `State` implemented `Clone`, you could clone the value
--> $DIR/issue-101119.rs:1:1
|
LL | struct State;
| ^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | fill_segment(state);
| ----- you could clone this value
error: aborting due to 1 previous error

5
tests/ui/btreemap/btreemap_dropck.stderr
View file

@ -12,9 +12,8 @@ LL | }
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let _map = BTreeMap::from_iter([((), PrintOnDrop(&s))]);
LL + let _map = BTreeMap::from_iter([((), PrintOnDrop(s.clone()))]);
|
LL | let _map = BTreeMap::from_iter([((), PrintOnDrop(&s.clone()))]);
| ++++++++
error: aborting due to 1 previous error

5
tests/ui/dropck/drop-with-active-borrows-1.stderr
View file

@ -9,11 +9,6 @@ LL | drop(a);
| ^ move out of `a` occurs here
LL | for s in &b {
| -- borrow later used here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | let b: Vec<&str> = a.clone().lines().collect();
| ++++++++
error: aborting due to 1 previous error

2
tests/ui/error-codes/E0504.stderr
View file

@ -21,7 +21,7 @@ LL | struct FancyNum {
| ^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let fancy_ref = &fancy_num;
| ---------- you could clone this value
| --------- you could clone this value
error: aborting due to 1 previous error

2
tests/ui/error-codes/E0505.stderr
View file

@ -18,7 +18,7 @@ LL | struct Value {}
| ^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let _ref_to_val: &Value = &x;
| -- you could clone this value
| - you could clone this value
error: aborting due to 1 previous error

5
tests/ui/fn/implied-bounds-unnorm-associated-type-4.stderr
View file

@ -13,9 +13,8 @@ LL | println!("{}", y);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let y = f(&x, ());
LL + let y = f(x.clone(), ());
|
LL | let y = f(&x.clone(), ());
| ++++++++
error: aborting due to 1 previous error

5
tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
View file

@ -30,9 +30,8 @@ LL | println!("{}", y);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let y = f(&x, ());
LL + let y = f(x.clone(), ());
|
LL | let y = f(&x.clone(), ());
| ++++++++
error: aborting due to 2 previous errors

5
tests/ui/fn/implied-bounds-unnorm-associated-type.stderr
View file

@ -13,9 +13,8 @@ LL | println!("{}", y);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let y = f(&x, ());
LL + let y = f(x.clone(), ());
|
LL | let y = f(&x.clone(), ());
| ++++++++
error: aborting due to 1 previous error

9
tests/ui/moves/move-fn-self-receiver.stderr
View file

@ -101,15 +101,6 @@ LL | mut_foo;
| ^^^^^^^ move out of `mut_foo` occurs here
LL | ret;
| --- borrow later used here
|
note: if `Foo` implemented `Clone`, you could clone the value
--> $DIR/move-fn-self-receiver.rs:5:1
|
LL | struct Foo;
| ^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let ret = mut_foo.use_mut_self();
| ------- you could clone this value
error[E0382]: use of moved value: `rc_foo`
--> $DIR/move-fn-self-receiver.rs:55:5

15
tests/ui/nll/closure-access-spans.stderr
View file

@ -60,9 +60,8 @@ LL | r.use_ref();
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let r = &x;
LL + let r = x.clone();
|
LL | let r = &x.clone();
| ++++++++
error[E0382]: borrow of moved value: `x`
--> $DIR/closure-access-spans.rs:35:5
@ -109,11 +108,6 @@ LL | || *x = String::new();
| ^^ -- borrow occurs due to use in closure
| |
| value borrowed here after move
|
help: consider cloning the value if the performance cost is acceptable
|
LL | let r = x.clone();
| ++++++++
error[E0382]: use of moved value: `x`
--> $DIR/closure-access-spans.rs:50:5
@ -126,11 +120,6 @@ LL | || x;
| ^^ - use occurs due to use in closure
| |
| value used here after move
|
help: consider cloning the value if the performance cost is acceptable
|
LL | let r = x.clone();
| ++++++++
error: aborting due to 9 previous errors

10
tests/ui/nll/issue-27282-move-match-input-into-guard.stderr
View file

@ -10,11 +10,6 @@ LL | _ if { (|| { let bar = b; *bar = false; })();
| -- - variable moved due to use in closure
| |
| value moved into closure here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | _ if { (|| { let bar = b.clone(); *bar = false; })();
| ++++++++
error[E0382]: use of moved value: `b`
--> $DIR/issue-27282-move-match-input-into-guard.rs:24:5
@ -28,11 +23,6 @@ LL | (|| { let bar = b; *bar = false; })();
| -- - variable moved due to use in closure
| |
| value moved into closure here
|
help: consider cloning the value if the performance cost is acceptable
|
LL | (|| { let bar = b.clone(); *bar = false; })();
| ++++++++
error: aborting due to 2 previous errors

23
tests/ui/nll/issue-27282-move-ref-mut-into-guard.fixed
View file

@ -1,23 +0,0 @@
// Issue 27282: Example 1: This sidesteps the AST checks disallowing
// mutable borrows in match guards by hiding the mutable borrow in a
// guard behind a move (of the ref mut pattern id) within a closure.
//@ run-rustfix
#![feature(if_let_guard)]
fn main() {
match Some(&4) {
None => {},
ref mut foo
if { (|| { let mut bar = foo.clone(); bar.take() })(); false } => {},
//~^ ERROR cannot move out of `foo` in pattern guard [E0507]
Some(s) => std::process::exit(*s),
}
match Some(&4) {
None => {},
ref mut foo
if let Some(()) = { (|| { let mut bar = foo.clone(); bar.take() })(); None } => {},
//~^ ERROR cannot move out of `foo` in pattern guard [E0507]
Some(s) => std::process::exit(*s),
}
}

2
tests/ui/nll/issue-27282-move-ref-mut-into-guard.rs
View file

@ -1,7 +1,7 @@
// Issue 27282: Example 1: This sidesteps the AST checks disallowing
// mutable borrows in match guards by hiding the mutable borrow in a
// guard behind a move (of the ref mut pattern id) within a closure.
//@ run-rustfix
#![feature(if_let_guard)]
fn main() {

8
tests/ui/nll/issue-27282-move-ref-mut-into-guard.stderr
View file

@ -7,10 +7,6 @@ LL | if { (|| { let mut bar = foo; bar.take() })(); false } => {},
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | if { (|| { let mut bar = foo.clone(); bar.take() })(); false } => {},
| ++++++++
error[E0507]: cannot move out of `foo` in pattern guard
--> $DIR/issue-27282-move-ref-mut-into-guard.rs:19:34
@ -21,10 +17,6 @@ LL | if let Some(()) = { (|| { let mut bar = foo; bar.take() })(); N
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | if let Some(()) = { (|| { let mut bar = foo.clone(); bar.take() })(); None } => {},
| ++++++++
error: aborting due to 2 previous errors

8
tests/ui/nll/issue-27282-mutation-in-guard.stderr
View file

@ -7,10 +7,6 @@ LL | (|| { let bar = foo; bar.take() })();
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | (|| { let bar = foo.clone(); bar.take() })();
| ++++++++
error[E0507]: cannot move out of `foo` in pattern guard
--> $DIR/issue-27282-mutation-in-guard.rs:20:18
@ -21,10 +17,6 @@ LL | (|| { let bar = foo; bar.take() })();
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | (|| { let bar = foo.clone(); bar.take() })();
| ++++++++
error: aborting due to 2 previous errors

4
tests/ui/nll/issue-52059-report-when-borrow-and-drop-conflict.stderr
View file

@ -41,10 +41,6 @@ help: consider borrowing here
|
LL | let p = &s.url; p
| +
help: consider cloning the value if the performance cost is acceptable
|
LL | let p = s.url.clone(); p
| ++++++++
error: aborting due to 4 previous errors

66
tests/ui/nll/match-guards-always-borrow.fixed
View file

@ -1,66 +0,0 @@
#![feature(if_let_guard)]
#![allow(unused_mut)]
//@ run-rustfix
// Here is arielb1's basic example from rust-lang/rust#27282
// that AST borrowck is flummoxed by:
fn should_reject_destructive_mutate_in_guard() {
match Some(&4) {
None => {},
ref mut foo if {
(|| { let mut bar = foo.clone(); bar.take() })();
//~^ ERROR cannot move out of `foo` in pattern guard [E0507]
false } => { },
Some(s) => std::process::exit(*s),
}
match Some(&4) {
None => {},
ref mut foo if let Some(()) = {
(|| { let mut bar = foo.clone(); bar.take() })();
//~^ ERROR cannot move out of `foo` in pattern guard [E0507]
None } => { },
Some(s) => std::process::exit(*s),
}
}
// Here below is a case that needs to keep working: we only use the
// binding via immutable-borrow in the guard, and we mutate in the arm
// body.
fn allow_mutate_in_arm_body() {
match Some(&4) {
None => {},
ref mut foo if foo.is_some() => { foo.take(); () }
Some(s) => std::process::exit(*s),
}
match Some(&4) {
None => {},
ref mut foo if let Some(_) = foo => { foo.take(); () }
Some(s) => std::process::exit(*s),
}
}
// Here below is a case that needs to keep working: we only use the
// binding via immutable-borrow in the guard, and we move into the arm
// body.
fn allow_move_into_arm_body() {
match Some(&4) {
None => {},
mut foo if foo.is_some() => { foo.unwrap(); () }
Some(s) => std::process::exit(*s),
}
match Some(&4) {
None => {},
mut foo if let Some(_) = foo => { foo.unwrap(); () }
Some(s) => std::process::exit(*s),
}
}
fn main() {
should_reject_destructive_mutate_in_guard();
allow_mutate_in_arm_body();
allow_move_into_arm_body();
}

1
tests/ui/nll/match-guards-always-borrow.rs
View file

@ -1,6 +1,5 @@
#![feature(if_let_guard)]
#![allow(unused_mut)]
//@ run-rustfix
// Here is arielb1's basic example from rust-lang/rust#27282
// that AST borrowck is flummoxed by:

12
tests/ui/nll/match-guards-always-borrow.stderr
View file

@ -1,5 +1,5 @@
error[E0507]: cannot move out of `foo` in pattern guard
--> $DIR/match-guards-always-borrow.rs:12:14
--> $DIR/match-guards-always-borrow.rs:11:14
|
LL | (|| { let mut bar = foo; bar.take() })();
| ^^ --- move occurs because `foo` has type `&mut Option<&i32>`, which does not implement the `Copy` trait
@ -7,13 +7,9 @@ LL | (|| { let mut bar = foo; bar.take() })();
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | (|| { let mut bar = foo.clone(); bar.take() })();
| ++++++++
error[E0507]: cannot move out of `foo` in pattern guard
--> $DIR/match-guards-always-borrow.rs:21:14
--> $DIR/match-guards-always-borrow.rs:20:14
|
LL | (|| { let mut bar = foo; bar.take() })();
| ^^ --- move occurs because `foo` has type `&mut Option<&i32>`, which does not implement the `Copy` trait
@ -21,10 +17,6 @@ LL | (|| { let mut bar = foo; bar.take() })();
| `foo` is moved here
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
help: consider cloning the value if the performance cost is acceptable
|
LL | (|| { let mut bar = foo.clone(); bar.take() })();
| ++++++++
error: aborting due to 2 previous errors

12
tests/ui/nll/polonius/polonius-smoke-test.stderr
View file

@ -27,6 +27,12 @@ LL | let z = x;
| ^ move out of `x` occurs here
LL | y
| - returning this value requires that `*x` is borrowed for `'1`
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let y = &mut *x;
LL + let y = &mut x.clone();
|
error[E0505]: cannot move out of `s` because it is borrowed
--> $DIR/polonius-smoke-test.rs:42:5
@ -40,6 +46,12 @@ LL | s;
| ^ move out of `s` occurs here
LL | tmp;
| --- borrow later used here
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let r = &mut *s;
LL + let r = &mut s.clone();
|
error: aborting due to 4 previous errors

16
tests/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr
View file

@ -333,14 +333,6 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
note: if `U` implemented `Clone`, you could clone the value
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:17:5
|
LL | struct U;
| ^^^^^^^^ consider implementing `Clone` for this type
...
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| - you could clone this value
error[E0507]: cannot move out of `b` in pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66
@ -349,14 +341,6 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
|
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
note: if `U` implemented `Clone`, you could clone the value
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:17:5
|
LL | struct U;
| ^^^^^^^^ consider implementing `Clone` for this type
...
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| - you could clone this value
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0507]: cannot move out of `a` in pattern guard

6
tests/ui/span/send-is-not-static-std-sync.stderr
View file

@ -15,7 +15,7 @@ LL | *lock.lock().unwrap() = &z;
help: consider cloning the value if the performance cost is acceptable
|
LL - *lock.lock().unwrap() = &*y;
LL + *lock.lock().unwrap() = y.clone();
LL + *lock.lock().unwrap() = &y.clone();
|
error[E0597]: `z` does not live long enough
@ -48,7 +48,7 @@ LL | *lock.write().unwrap() = &z;
help: consider cloning the value if the performance cost is acceptable
|
LL - *lock.write().unwrap() = &*y;
LL + *lock.write().unwrap() = y.clone();
LL + *lock.write().unwrap() = &y.clone();
|
error[E0597]: `z` does not live long enough
@ -81,7 +81,7 @@ LL | tx.send(&z).unwrap();
help: consider cloning the value if the performance cost is acceptable
|
LL - tx.send(&*y);
LL + tx.send(y.clone());
LL + tx.send(&y.clone());
|
error[E0597]: `z` does not live long enough

5
tests/ui/suggestions/borrow-for-loop-head.stderr
View file

@ -10,9 +10,8 @@ LL | for j in a {
|
help: consider cloning the value if the performance cost is acceptable
|
LL - for i in &a {
LL + for i in a.clone() {
|
LL | for i in &a.clone() {
| ++++++++
error[E0382]: use of moved value: `a`
--> $DIR/borrow-for-loop-head.rs:4:18

5
tests/ui/try-block/try-block-bad-lifetime.stderr
View file

@ -34,11 +34,6 @@ LL | Err(k) ?;
...
LL | ::std::mem::drop(k);
| ^ value used here after move
|
help: consider cloning the value if the performance cost is acceptable
|
LL | Err(k.clone()) ?;
| ++++++++
error[E0506]: cannot assign to `i` because it is borrowed
--> $DIR/try-block-bad-lifetime.rs:32:9

4
tests/ui/unop/unop-move-semantics.stderr
View file

@ -40,7 +40,7 @@ help: if `T` implemented `Clone`, you could clone the value
LL | fn move_borrowed<T: Not<Output=T>>(x: T, mut y: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let m = &x;
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `y` because it is borrowed
--> $DIR/unop-move-semantics.rs:17:6
@ -63,7 +63,7 @@ LL | fn move_borrowed<T: Not<Output=T>>(x: T, mut y: T) {
| ^ consider constraining this type parameter with `Clone`
LL | let m = &x;
LL | let n = &mut y;
| ------ you could clone this value
| - you could clone this value
error[E0507]: cannot move out of `*m` which is behind a mutable reference
--> $DIR/unop-move-semantics.rs:24:6

13
tests/ui/variance/variance-issue-20533.stderr
View file

@ -17,7 +17,7 @@ LL | struct AffineU32(u32);
| ^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let x = foo(&a);
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `a` because it is borrowed
--> $DIR/variance-issue-20533.rs:41:14
@ -38,7 +38,7 @@ LL | struct AffineU32(u32);
| ^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let x = bar(&a);
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `a` because it is borrowed
--> $DIR/variance-issue-20533.rs:47:14
@ -59,7 +59,7 @@ LL | struct AffineU32(u32);
| ^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let x = baz(&a);
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `a` because it is borrowed
--> $DIR/variance-issue-20533.rs:53:14
@ -80,7 +80,7 @@ LL | struct AffineU32(u32);
| ^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
...
LL | let x = bat(&a);
| -- you could clone this value
| - you could clone this value
error[E0505]: cannot move out of `a` because it is borrowed
--> $DIR/variance-issue-20533.rs:59:14
@ -96,9 +96,8 @@ LL | drop(x);
|
help: consider cloning the value if the performance cost is acceptable
|
LL - let x = foo(&a);
LL + let x = foo(a.clone());
|
LL | let x = foo(&a.clone());
| ++++++++
error: aborting due to 5 previous errors