summaryrefslogtreecommitdiffstats
path: root/tests/ui/moves
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:19:03 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:19:03 +0000
commit64d98f8ee037282c35007b64c2649055c56af1db (patch)
tree5492bcf97fce41ee1c0b1cc2add283f3e66cdab0 /tests/ui/moves
parentAdding debian version 1.67.1+dfsg1-1. (diff)
downloadrustc-64d98f8ee037282c35007b64c2649055c56af1db.tar.xz
rustc-64d98f8ee037282c35007b64c2649055c56af1db.zip
Merging upstream version 1.68.2+dfsg1.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'tests/ui/moves')
-rw-r--r--tests/ui/moves/borrow-closures-instead-of-move.rs36
-rw-r--r--tests/ui/moves/borrow-closures-instead-of-move.stderr68
-rw-r--r--tests/ui/moves/issue-46099-move-in-macro.rs15
-rw-r--r--tests/ui/moves/issue-46099-move-in-macro.stderr16
-rw-r--r--tests/ui/moves/issue-72649-uninit-in-loop.rs74
-rw-r--r--tests/ui/moves/issue-72649-uninit-in-loop.stderr79
-rw-r--r--tests/ui/moves/issue-75904-move-closure-loop.rs15
-rw-r--r--tests/ui/moves/issue-75904-move-closure-loop.stderr15
-rw-r--r--tests/ui/moves/issue-99470-move-out-of-some.rs9
-rw-r--r--tests/ui/moves/issue-99470-move-out-of-some.stderr21
-rw-r--r--tests/ui/moves/move-1-unique.rs25
-rw-r--r--tests/ui/moves/move-2-unique.rs10
-rw-r--r--tests/ui/moves/move-2.rs6
-rw-r--r--tests/ui/moves/move-3-unique.rs25
-rw-r--r--tests/ui/moves/move-4-unique.rs18
-rw-r--r--tests/ui/moves/move-4.rs18
-rw-r--r--tests/ui/moves/move-arg-2-unique.rs12
-rw-r--r--tests/ui/moves/move-arg-2.rs12
-rw-r--r--tests/ui/moves/move-arg.rs5
-rw-r--r--tests/ui/moves/move-deref-coercion.rs33
-rw-r--r--tests/ui/moves/move-deref-coercion.stderr35
-rw-r--r--tests/ui/moves/move-fn-self-receiver.rs79
-rw-r--r--tests/ui/moves/move-fn-self-receiver.stderr177
-rw-r--r--tests/ui/moves/move-guard-same-consts.rs25
-rw-r--r--tests/ui/moves/move-guard-same-consts.stderr26
-rw-r--r--tests/ui/moves/move-in-guard-1.rs15
-rw-r--r--tests/ui/moves/move-in-guard-1.stderr26
-rw-r--r--tests/ui/moves/move-in-guard-2.rs13
-rw-r--r--tests/ui/moves/move-in-guard-2.stderr24
-rw-r--r--tests/ui/moves/move-into-dead-array-1.rs15
-rw-r--r--tests/ui/moves/move-into-dead-array-1.stderr16
-rw-r--r--tests/ui/moves/move-into-dead-array-2.rs15
-rw-r--r--tests/ui/moves/move-into-dead-array-2.stderr13
-rw-r--r--tests/ui/moves/move-nullary-fn.rs13
-rw-r--r--tests/ui/moves/move-of-addr-of-mut.rs12
-rw-r--r--tests/ui/moves/move-of-addr-of-mut.stderr17
-rw-r--r--tests/ui/moves/move-out-of-array-1.rs18
-rw-r--r--tests/ui/moves/move-out-of-array-1.stderr12
-rw-r--r--tests/ui/moves/move-out-of-array-ref.rs34
-rw-r--r--tests/ui/moves/move-out-of-array-ref.stderr63
-rw-r--r--tests/ui/moves/move-out-of-field.rs27
-rw-r--r--tests/ui/moves/move-out-of-slice-1.rs11
-rw-r--r--tests/ui/moves/move-out-of-slice-1.stderr19
-rw-r--r--tests/ui/moves/move-out-of-slice-2.rs36
-rw-r--r--tests/ui/moves/move-out-of-slice-2.stderr80
-rw-r--r--tests/ui/moves/move-out-of-tuple-field.rs13
-rw-r--r--tests/ui/moves/move-out-of-tuple-field.stderr23
-rw-r--r--tests/ui/moves/move-scalar.rs10
-rw-r--r--tests/ui/moves/moves-based-on-type-access-to-field.rs14
-rw-r--r--tests/ui/moves/moves-based-on-type-access-to-field.stderr20
-rw-r--r--tests/ui/moves/moves-based-on-type-block-bad.rs29
-rw-r--r--tests/ui/moves/moves-based-on-type-block-bad.stderr20
-rw-r--r--tests/ui/moves/moves-based-on-type-capture-clause-bad.rs9
-rw-r--r--tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr18
-rw-r--r--tests/ui/moves/moves-based-on-type-capture-clause.rs12
-rw-r--r--tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.rs20
-rw-r--r--tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr18
-rw-r--r--tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.rs49
-rw-r--r--tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.stderr37
-rw-r--r--tests/ui/moves/moves-based-on-type-exprs.rs93
-rw-r--r--tests/ui/moves/moves-based-on-type-exprs.stderr189
-rw-r--r--tests/ui/moves/moves-based-on-type-match-bindings.rs21
-rw-r--r--tests/ui/moves/moves-based-on-type-match-bindings.stderr18
-rw-r--r--tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.rs10
-rw-r--r--tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr13
-rw-r--r--tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.rs35
-rw-r--r--tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.stderr28
-rw-r--r--tests/ui/moves/moves-based-on-type-tuple.rs10
-rw-r--r--tests/ui/moves/moves-based-on-type-tuple.stderr19
-rw-r--r--tests/ui/moves/moves-sru-moved-field.rs23
-rw-r--r--tests/ui/moves/moves-sru-moved-field.stderr13
-rw-r--r--tests/ui/moves/pin-mut-reborrow.fixed15
-rw-r--r--tests/ui/moves/pin-mut-reborrow.rs15
-rw-r--r--tests/ui/moves/pin-mut-reborrow.stderr23
-rw-r--r--tests/ui/moves/suggest-clone.fixed11
-rw-r--r--tests/ui/moves/suggest-clone.rs11
-rw-r--r--tests/ui/moves/suggest-clone.stderr22
-rw-r--r--tests/ui/moves/use_of_moved_value_clone_suggestions.rs6
-rw-r--r--tests/ui/moves/use_of_moved_value_clone_suggestions.stderr18
-rw-r--r--tests/ui/moves/use_of_moved_value_copy_suggestions.fixed86
-rw-r--r--tests/ui/moves/use_of_moved_value_copy_suggestions.rs86
-rw-r--r--tests/ui/moves/use_of_moved_value_copy_suggestions.stderr179
82 files changed, 2569 insertions, 0 deletions
diff --git a/tests/ui/moves/borrow-closures-instead-of-move.rs b/tests/ui/moves/borrow-closures-instead-of-move.rs
new file mode 100644
index 000000000..51771ced7
--- /dev/null
+++ b/tests/ui/moves/borrow-closures-instead-of-move.rs
@@ -0,0 +1,36 @@
+fn takes_fn(f: impl Fn()) {
+ loop {
+ takes_fnonce(f);
+ //~^ ERROR use of moved value
+ //~| HELP consider borrowing
+ }
+}
+
+fn takes_fn_mut(m: impl FnMut()) {
+ if maybe() {
+ takes_fnonce(m);
+ //~^ HELP consider mutably borrowing
+ }
+ takes_fnonce(m);
+ //~^ ERROR use of moved value
+}
+
+fn has_closure() {
+ let mut x = 0;
+ let mut closure = || {
+ x += 1;
+ };
+ takes_fnonce(closure);
+ //~^ HELP consider mutably borrowing
+ closure();
+ //~^ ERROR borrow of moved value
+}
+
+fn maybe() -> bool {
+ false
+}
+
+// Could also be Fn[Mut], here it doesn't matter
+fn takes_fnonce(_: impl FnOnce()) {}
+
+fn main() {}
diff --git a/tests/ui/moves/borrow-closures-instead-of-move.stderr b/tests/ui/moves/borrow-closures-instead-of-move.stderr
new file mode 100644
index 000000000..9a84ddef7
--- /dev/null
+++ b/tests/ui/moves/borrow-closures-instead-of-move.stderr
@@ -0,0 +1,68 @@
+error[E0382]: use of moved value: `f`
+ --> $DIR/borrow-closures-instead-of-move.rs:3:22
+ |
+LL | fn takes_fn(f: impl Fn()) {
+ | - move occurs because `f` has type `impl Fn()`, which does not implement the `Copy` trait
+LL | loop {
+ | ---- inside of this loop
+LL | takes_fnonce(f);
+ | ^ value moved here, in previous iteration of loop
+ |
+note: consider changing this parameter type in function `takes_fnonce` to borrow instead if owning the value isn't necessary
+ --> $DIR/borrow-closures-instead-of-move.rs:34:20
+ |
+LL | fn takes_fnonce(_: impl FnOnce()) {}
+ | ------------ ^^^^^^^^^^^^^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider borrowing `f`
+ |
+LL | takes_fnonce(&f);
+ | +
+
+error[E0382]: use of moved value: `m`
+ --> $DIR/borrow-closures-instead-of-move.rs:14:18
+ |
+LL | fn takes_fn_mut(m: impl FnMut()) {
+ | - move occurs because `m` has type `impl FnMut()`, which does not implement the `Copy` trait
+LL | if maybe() {
+LL | takes_fnonce(m);
+ | - value moved here
+...
+LL | takes_fnonce(m);
+ | ^ value used here after move
+ |
+note: consider changing this parameter type in function `takes_fnonce` to borrow instead if owning the value isn't necessary
+ --> $DIR/borrow-closures-instead-of-move.rs:34:20
+ |
+LL | fn takes_fnonce(_: impl FnOnce()) {}
+ | ------------ ^^^^^^^^^^^^^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider mutably borrowing `m`
+ |
+LL | takes_fnonce(&mut m);
+ | ++++
+
+error[E0382]: borrow of moved value: `closure`
+ --> $DIR/borrow-closures-instead-of-move.rs:25:5
+ |
+LL | takes_fnonce(closure);
+ | ------- value moved here
+LL |
+LL | closure();
+ | ^^^^^^^ value borrowed here after move
+ |
+note: closure cannot be moved more than once as it is not `Copy` due to moving the variable `x` out of its environment
+ --> $DIR/borrow-closures-instead-of-move.rs:21:9
+ |
+LL | x += 1;
+ | ^
+help: consider mutably borrowing `closure`
+ |
+LL | takes_fnonce(&mut closure);
+ | ++++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-46099-move-in-macro.rs b/tests/ui/moves/issue-46099-move-in-macro.rs
new file mode 100644
index 000000000..576fe1f4c
--- /dev/null
+++ b/tests/ui/moves/issue-46099-move-in-macro.rs
@@ -0,0 +1,15 @@
+// Regression test for issue #46099
+// Tests that we don't emit spurious
+// 'value moved in previous iteration of loop' message
+
+macro_rules! test {
+ ($v:expr) => {{
+ drop(&$v);
+ $v
+ }}
+}
+
+fn main() {
+ let b = Box::new(true);
+ test!({b}); //~ ERROR use of moved value
+}
diff --git a/tests/ui/moves/issue-46099-move-in-macro.stderr b/tests/ui/moves/issue-46099-move-in-macro.stderr
new file mode 100644
index 000000000..94bc9e6f4
--- /dev/null
+++ b/tests/ui/moves/issue-46099-move-in-macro.stderr
@@ -0,0 +1,16 @@
+error[E0382]: use of moved value: `b`
+ --> $DIR/issue-46099-move-in-macro.rs:14:12
+ |
+LL | let b = Box::new(true);
+ | - move occurs because `b` has type `Box<bool>`, which does not implement the `Copy` trait
+LL | test!({b});
+ | ^ value used here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | test!({b.clone()});
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-72649-uninit-in-loop.rs b/tests/ui/moves/issue-72649-uninit-in-loop.rs
new file mode 100644
index 000000000..56c225bab
--- /dev/null
+++ b/tests/ui/moves/issue-72649-uninit-in-loop.rs
@@ -0,0 +1,74 @@
+// Regression test for issue #72649
+// Tests that we don't emit spurious
+// 'value moved in previous iteration of loop' message
+
+struct NonCopy;
+
+fn good() {
+ loop {
+ let value = NonCopy{};
+ let _used = value;
+ }
+}
+
+fn moved_here_1() {
+ loop {
+ let value = NonCopy{};
+ //~^ NOTE move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+ let _used = value;
+ //~^ NOTE value moved here
+ let _used2 = value; //~ ERROR use of moved value: `value`
+ //~^ NOTE value used here after move
+ }
+}
+
+fn moved_here_2() {
+ let value = NonCopy{};
+ //~^ NOTE move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+ loop { //~ NOTE inside of this loop
+ let _used = value;
+ //~^ NOTE value moved here
+ loop {
+ let _used2 = value; //~ ERROR use of moved value: `value`
+ //~^ NOTE value used here after move
+ }
+ }
+}
+
+fn moved_loop_1() {
+ let value = NonCopy{};
+ //~^ NOTE move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+ loop { //~ NOTE inside of this loop
+ let _used = value; //~ ERROR use of moved value: `value`
+ //~^ NOTE value moved here, in previous iteration of loop
+ }
+}
+
+fn moved_loop_2() {
+ let mut value = NonCopy{};
+ //~^ NOTE move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+ let _used = value;
+ value = NonCopy{};
+ loop { //~ NOTE inside of this loop
+ let _used2 = value; //~ ERROR use of moved value: `value`
+ //~^ NOTE value moved here, in previous iteration of loop
+ }
+}
+
+fn uninit_1() {
+ loop {
+ let value: NonCopy; //~ NOTE declared here
+ let _used = value; //~ ERROR binding `value` isn't initialized
+ //~^ NOTE `value` used here but it isn't initialized
+ }
+}
+
+fn uninit_2() {
+ let mut value: NonCopy; //~ NOTE declared here
+ loop {
+ let _used = value; //~ ERROR binding `value` isn't initialized
+ //~^ NOTE `value` used here but it isn't initialized
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/moves/issue-72649-uninit-in-loop.stderr b/tests/ui/moves/issue-72649-uninit-in-loop.stderr
new file mode 100644
index 000000000..7e119fe8c
--- /dev/null
+++ b/tests/ui/moves/issue-72649-uninit-in-loop.stderr
@@ -0,0 +1,79 @@
+error[E0382]: use of moved value: `value`
+ --> $DIR/issue-72649-uninit-in-loop.rs:20:22
+ |
+LL | let value = NonCopy{};
+ | ----- move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+LL |
+LL | let _used = value;
+ | ----- value moved here
+LL |
+LL | let _used2 = value;
+ | ^^^^^ value used here after move
+
+error[E0382]: use of moved value: `value`
+ --> $DIR/issue-72649-uninit-in-loop.rs:32:26
+ |
+LL | let value = NonCopy{};
+ | ----- move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+LL |
+LL | loop {
+ | ---- inside of this loop
+LL | let _used = value;
+ | ----- value moved here
+...
+LL | let _used2 = value;
+ | ^^^^^ value used here after move
+
+error[E0382]: use of moved value: `value`
+ --> $DIR/issue-72649-uninit-in-loop.rs:42:21
+ |
+LL | let value = NonCopy{};
+ | ----- move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+LL |
+LL | loop {
+ | ---- inside of this loop
+LL | let _used = value;
+ | ^^^^^ value moved here, in previous iteration of loop
+
+error[E0382]: use of moved value: `value`
+ --> $DIR/issue-72649-uninit-in-loop.rs:53:22
+ |
+LL | let mut value = NonCopy{};
+ | --------- move occurs because `value` has type `NonCopy`, which does not implement the `Copy` trait
+...
+LL | loop {
+ | ---- inside of this loop
+LL | let _used2 = value;
+ | ^^^^^ value moved here, in previous iteration of loop
+
+error[E0381]: used binding `value` isn't initialized
+ --> $DIR/issue-72649-uninit-in-loop.rs:61:21
+ |
+LL | let value: NonCopy;
+ | ----- binding declared here but left uninitialized
+LL | let _used = value;
+ | ^^^^^ `value` used here but it isn't initialized
+ |
+help: consider assigning a value
+ |
+LL | let value: NonCopy = todo!();
+ | +++++++++
+
+error[E0381]: used binding `value` isn't initialized
+ --> $DIR/issue-72649-uninit-in-loop.rs:69:21
+ |
+LL | let mut value: NonCopy;
+ | --------- binding declared here but left uninitialized
+LL | loop {
+LL | let _used = value;
+ | ^^^^^ `value` used here but it isn't initialized
+ |
+help: consider assigning a value
+ |
+LL | let mut value: NonCopy = todo!();
+ | +++++++++
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0381, E0382.
+For more information about an error, try `rustc --explain E0381`.
diff --git a/tests/ui/moves/issue-75904-move-closure-loop.rs b/tests/ui/moves/issue-75904-move-closure-loop.rs
new file mode 100644
index 000000000..6641a0376
--- /dev/null
+++ b/tests/ui/moves/issue-75904-move-closure-loop.rs
@@ -0,0 +1,15 @@
+// Regression test for issue #75904
+// Tests that we point at an expression
+// that required the upvar to be moved, rather than just borrowed.
+
+struct NotCopy;
+
+fn main() {
+ let mut a = NotCopy;
+ loop {
+ || { //~ ERROR use of moved value
+ &mut a;
+ a;
+ };
+ }
+}
diff --git a/tests/ui/moves/issue-75904-move-closure-loop.stderr b/tests/ui/moves/issue-75904-move-closure-loop.stderr
new file mode 100644
index 000000000..5e427a1fc
--- /dev/null
+++ b/tests/ui/moves/issue-75904-move-closure-loop.stderr
@@ -0,0 +1,15 @@
+error[E0382]: use of moved value: `a`
+ --> $DIR/issue-75904-move-closure-loop.rs:10:9
+ |
+LL | let mut a = NotCopy;
+ | ----- move occurs because `a` has type `NotCopy`, which does not implement the `Copy` trait
+LL | loop {
+LL | || {
+ | ^^ value moved into closure here, in previous iteration of loop
+LL | &mut a;
+LL | a;
+ | - use occurs due to use in closure
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/issue-99470-move-out-of-some.rs b/tests/ui/moves/issue-99470-move-out-of-some.rs
new file mode 100644
index 000000000..f404cd3cd
--- /dev/null
+++ b/tests/ui/moves/issue-99470-move-out-of-some.rs
@@ -0,0 +1,9 @@
+fn main() {
+ let x: &Option<Box<i32>> = &Some(Box::new(0));
+
+ match x {
+ //~^ ERROR cannot move out of `x` as enum variant `Some` which is behind a shared reference
+ &Some(_y) => (),
+ &None => (),
+ }
+}
diff --git a/tests/ui/moves/issue-99470-move-out-of-some.stderr b/tests/ui/moves/issue-99470-move-out-of-some.stderr
new file mode 100644
index 000000000..c5159471f
--- /dev/null
+++ b/tests/ui/moves/issue-99470-move-out-of-some.stderr
@@ -0,0 +1,21 @@
+error[E0507]: cannot move out of `x` as enum variant `Some` which is behind a shared reference
+ --> $DIR/issue-99470-move-out-of-some.rs:4:11
+ |
+LL | match x {
+ | ^
+LL |
+LL | &Some(_y) => (),
+ | --
+ | |
+ | data moved here
+ | move occurs because `_y` has type `Box<i32>`, which does not implement the `Copy` trait
+ |
+help: consider removing the borrow
+ |
+LL - &Some(_y) => (),
+LL + Some(_y) => (),
+ |
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/move-1-unique.rs b/tests/ui/moves/move-1-unique.rs
new file mode 100644
index 000000000..f98d075d1
--- /dev/null
+++ b/tests/ui/moves/move-1-unique.rs
@@ -0,0 +1,25 @@
+// run-pass
+#![allow(unused_mut)]
+#![allow(dead_code)]
+
+#[derive(Clone)]
+struct Triple {
+ x: isize,
+ y: isize,
+ z: isize,
+}
+
+fn test(x: bool, foo: Box<Triple>) -> isize {
+ let bar = foo;
+ let mut y: Box<Triple>;
+ if x { y = bar; } else { y = Box::new(Triple{x: 4, y: 5, z: 6}); }
+ return y.y;
+}
+
+pub fn main() {
+ let x: Box<_> = Box::new(Triple{x: 1, y: 2, z: 3});
+ assert_eq!(test(true, x.clone()), 2);
+ assert_eq!(test(true, x.clone()), 2);
+ assert_eq!(test(true, x.clone()), 2);
+ assert_eq!(test(false, x), 5);
+}
diff --git a/tests/ui/moves/move-2-unique.rs b/tests/ui/moves/move-2-unique.rs
new file mode 100644
index 000000000..8fda3c1c8
--- /dev/null
+++ b/tests/ui/moves/move-2-unique.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![allow(dead_code)]
+
+struct X { x: isize, y: isize, z: isize }
+
+pub fn main() {
+ let x: Box<_> = Box::new(X {x: 1, y: 2, z: 3});
+ let y = x;
+ assert_eq!(y.y, 2);
+}
diff --git a/tests/ui/moves/move-2.rs b/tests/ui/moves/move-2.rs
new file mode 100644
index 000000000..5e0100874
--- /dev/null
+++ b/tests/ui/moves/move-2.rs
@@ -0,0 +1,6 @@
+// run-pass
+#![allow(dead_code)]
+
+struct X { x: isize, y: isize, z: isize }
+
+pub fn main() { let x: Box<_> = Box::new(X {x: 1, y: 2, z: 3}); let y = x; assert_eq!(y.y, 2); }
diff --git a/tests/ui/moves/move-3-unique.rs b/tests/ui/moves/move-3-unique.rs
new file mode 100644
index 000000000..8e5df2c3f
--- /dev/null
+++ b/tests/ui/moves/move-3-unique.rs
@@ -0,0 +1,25 @@
+// run-pass
+#![allow(unused_mut)]
+#![allow(dead_code)]
+
+#[derive(Clone)]
+struct Triple {
+ x: isize,
+ y: isize,
+ z: isize,
+}
+
+fn test(x: bool, foo: Box<Triple>) -> isize {
+ let bar = foo;
+ let mut y: Box<Triple>;
+ if x { y = bar; } else { y = Box::new(Triple {x: 4, y: 5, z: 6}); }
+ return y.y;
+}
+
+pub fn main() {
+ let x: Box<_> = Box::new(Triple{x: 1, y: 2, z: 3});
+ for _ in 0_usize..10000_usize {
+ assert_eq!(test(true, x.clone()), 2);
+ }
+ assert_eq!(test(false, x), 5);
+}
diff --git a/tests/ui/moves/move-4-unique.rs b/tests/ui/moves/move-4-unique.rs
new file mode 100644
index 000000000..24aec7ea6
--- /dev/null
+++ b/tests/ui/moves/move-4-unique.rs
@@ -0,0 +1,18 @@
+// run-pass
+#![allow(dead_code)]
+
+struct Triple {a: isize, b: isize, c: isize}
+
+fn test(foo: Box<Triple>) -> Box<Triple> {
+ let foo = foo;
+ let bar = foo;
+ let baz = bar;
+ let quux = baz;
+ return quux;
+}
+
+pub fn main() {
+ let x = Box::new(Triple{a: 1, b: 2, c: 3});
+ let y = test(x);
+ assert_eq!(y.c, 3);
+}
diff --git a/tests/ui/moves/move-4.rs b/tests/ui/moves/move-4.rs
new file mode 100644
index 000000000..63aa031a6
--- /dev/null
+++ b/tests/ui/moves/move-4.rs
@@ -0,0 +1,18 @@
+// run-pass
+#![allow(dead_code)]
+
+struct Triple { a: isize, b: isize, c: isize }
+
+fn test(foo: Box<Triple>) -> Box<Triple> {
+ let foo = foo;
+ let bar = foo;
+ let baz = bar;
+ let quux = baz;
+ return quux;
+}
+
+pub fn main() {
+ let x = Box::new(Triple{ a: 1, b: 2, c: 3 });
+ let y = test(x);
+ assert_eq!(y.c, 3);
+}
diff --git a/tests/ui/moves/move-arg-2-unique.rs b/tests/ui/moves/move-arg-2-unique.rs
new file mode 100644
index 000000000..9622c8375
--- /dev/null
+++ b/tests/ui/moves/move-arg-2-unique.rs
@@ -0,0 +1,12 @@
+// run-pass
+
+fn test(foo: Box<Vec<isize>> ) { assert_eq!((*foo)[0], 10); }
+
+pub fn main() {
+ let x = Box::new(vec![10]);
+ // Test forgetting a local by move-in
+ test(x);
+
+ // Test forgetting a temporary by move-in.
+ test(Box::new(vec![10]));
+}
diff --git a/tests/ui/moves/move-arg-2.rs b/tests/ui/moves/move-arg-2.rs
new file mode 100644
index 000000000..77ee06e19
--- /dev/null
+++ b/tests/ui/moves/move-arg-2.rs
@@ -0,0 +1,12 @@
+// run-pass
+
+fn test(foo: Box<Vec<isize>>) { assert_eq!((*foo)[0], 10); }
+
+pub fn main() {
+ let x = Box::new(vec![10]);
+ // Test forgetting a local by move-in
+ test(x);
+
+ // Test forgetting a temporary by move-in.
+ test(Box::new(vec![10]));
+}
diff --git a/tests/ui/moves/move-arg.rs b/tests/ui/moves/move-arg.rs
new file mode 100644
index 000000000..5942cd89f
--- /dev/null
+++ b/tests/ui/moves/move-arg.rs
@@ -0,0 +1,5 @@
+// run-pass
+
+fn test(foo: isize) { assert_eq!(foo, 10); }
+
+pub fn main() { let x = 10; test(x); }
diff --git a/tests/ui/moves/move-deref-coercion.rs b/tests/ui/moves/move-deref-coercion.rs
new file mode 100644
index 000000000..41154388f
--- /dev/null
+++ b/tests/ui/moves/move-deref-coercion.rs
@@ -0,0 +1,33 @@
+use std::ops::Deref;
+
+struct NotCopy {
+ inner: bool
+}
+
+impl NotCopy {
+ fn inner_method(&self) {}
+}
+
+struct Foo {
+ first: NotCopy,
+ second: NotCopy
+}
+
+impl Deref for Foo {
+ type Target = NotCopy;
+ fn deref(&self) -> &NotCopy {
+ &self.second
+ }
+}
+
+fn use_field(val: Foo) {
+ let _val = val.first;
+ val.inner; //~ ERROR borrow of
+}
+
+fn use_method(val: Foo) {
+ let _val = val.first;
+ val.inner_method(); //~ ERROR borrow of
+}
+
+fn main() {}
diff --git a/tests/ui/moves/move-deref-coercion.stderr b/tests/ui/moves/move-deref-coercion.stderr
new file mode 100644
index 000000000..5760f4a7f
--- /dev/null
+++ b/tests/ui/moves/move-deref-coercion.stderr
@@ -0,0 +1,35 @@
+error[E0382]: borrow of partially moved value: `val`
+ --> $DIR/move-deref-coercion.rs:25:5
+ |
+LL | let _val = val.first;
+ | --------- value partially moved here
+LL | val.inner;
+ | ^^^^^^^^^ value borrowed here after partial move
+ |
+ = note: partial move occurs because `val.first` has type `NotCopy`, which does not implement the `Copy` trait
+ = note: borrow occurs due to deref coercion to `NotCopy`
+note: deref defined here
+ --> $DIR/move-deref-coercion.rs:17:5
+ |
+LL | type Target = NotCopy;
+ | ^^^^^^^^^^^
+
+error[E0382]: borrow of partially moved value: `val`
+ --> $DIR/move-deref-coercion.rs:30:5
+ |
+LL | let _val = val.first;
+ | --------- value partially moved here
+LL | val.inner_method();
+ | ^^^^^^^^^^^^^^^^^^ value borrowed here after partial move
+ |
+ = note: partial move occurs because `val.first` has type `NotCopy`, which does not implement the `Copy` trait
+ = note: borrow occurs due to deref coercion to `NotCopy`
+note: deref defined here
+ --> $DIR/move-deref-coercion.rs:17:5
+ |
+LL | type Target = NotCopy;
+ | ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-fn-self-receiver.rs b/tests/ui/moves/move-fn-self-receiver.rs
new file mode 100644
index 000000000..946642ef6
--- /dev/null
+++ b/tests/ui/moves/move-fn-self-receiver.rs
@@ -0,0 +1,79 @@
+use std::pin::Pin;
+use std::rc::Rc;
+use std::ops::Add;
+
+struct Foo;
+
+impl Add for Foo {
+ type Output = ();
+ fn add(self, _rhs: Self) -> () {}
+}
+
+impl Foo {
+ fn use_self(self) {}
+ fn use_box_self(self: Box<Self>) {}
+ fn use_pin_box_self(self: Pin<Box<Self>>) {}
+ fn use_rc_self(self: Rc<Self>) {}
+ fn use_mut_self(&mut self) -> &mut Self { self }
+}
+
+struct Container(Vec<bool>);
+
+impl Container {
+ fn custom_into_iter(self) -> impl Iterator<Item = bool> {
+ self.0.into_iter()
+ }
+}
+
+fn move_out(val: Container) {
+ val.0.into_iter().next();
+ val.0; //~ ERROR use of moved
+
+ let foo = Foo;
+ foo.use_self();
+ foo; //~ ERROR use of moved
+
+ let second_foo = Foo;
+ second_foo.use_self();
+ second_foo; //~ ERROR use of moved
+
+ let boxed_foo = Box::new(Foo);
+ boxed_foo.use_box_self();
+ boxed_foo; //~ ERROR use of moved
+
+ let pin_box_foo = Box::pin(Foo);
+ pin_box_foo.use_pin_box_self();
+ pin_box_foo; //~ ERROR use of moved
+
+ let mut mut_foo = Foo;
+ let ret = mut_foo.use_mut_self();
+ mut_foo; //~ ERROR cannot move out
+ ret;
+
+ let rc_foo = Rc::new(Foo);
+ rc_foo.use_rc_self();
+ rc_foo; //~ ERROR use of moved
+
+ let foo_add = Foo;
+ foo_add + Foo;
+ foo_add; //~ ERROR use of moved
+
+ let implicit_into_iter = vec![true];
+ for _val in implicit_into_iter {}
+ implicit_into_iter; //~ ERROR use of moved
+
+ let explicit_into_iter = vec![true];
+ for _val in explicit_into_iter.into_iter() {}
+ explicit_into_iter; //~ ERROR use of moved
+
+ let container = Container(vec![]);
+ for _val in container.custom_into_iter() {}
+ container; //~ ERROR use of moved
+
+ let foo2 = Foo;
+ loop {
+ foo2.use_self(); //~ ERROR use of moved
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/moves/move-fn-self-receiver.stderr b/tests/ui/moves/move-fn-self-receiver.stderr
new file mode 100644
index 000000000..7f69e5dcf
--- /dev/null
+++ b/tests/ui/moves/move-fn-self-receiver.stderr
@@ -0,0 +1,177 @@
+error[E0382]: use of moved value: `val.0`
+ --> $DIR/move-fn-self-receiver.rs:30:5
+ |
+LL | val.0.into_iter().next();
+ | ----------- `val.0` moved due to this method call
+LL | val.0;
+ | ^^^^^ value used here after move
+ |
+note: `into_iter` takes ownership of the receiver `self`, which moves `val.0`
+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
+ = note: move occurs because `val.0` has type `Vec<bool>`, which does not implement the `Copy` trait
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | val.0.clone().into_iter().next();
+ | ++++++++
+
+error[E0382]: use of moved value: `foo`
+ --> $DIR/move-fn-self-receiver.rs:34:5
+ |
+LL | let foo = Foo;
+ | --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
+LL | foo.use_self();
+ | ---------- `foo` moved due to this method call
+LL | foo;
+ | ^^^ value used here after move
+ |
+note: `Foo::use_self` takes ownership of the receiver `self`, which moves `foo`
+ --> $DIR/move-fn-self-receiver.rs:13:17
+ |
+LL | fn use_self(self) {}
+ | ^^^^
+
+error[E0382]: use of moved value: `second_foo`
+ --> $DIR/move-fn-self-receiver.rs:38:5
+ |
+LL | let second_foo = Foo;
+ | ---------- move occurs because `second_foo` has type `Foo`, which does not implement the `Copy` trait
+LL | second_foo.use_self();
+ | ---------- `second_foo` moved due to this method call
+LL | second_foo;
+ | ^^^^^^^^^^ value used here after move
+
+error[E0382]: use of moved value: `boxed_foo`
+ --> $DIR/move-fn-self-receiver.rs:42:5
+ |
+LL | let boxed_foo = Box::new(Foo);
+ | --------- move occurs because `boxed_foo` has type `Box<Foo>`, which does not implement the `Copy` trait
+LL | boxed_foo.use_box_self();
+ | -------------- `boxed_foo` moved due to this method call
+LL | boxed_foo;
+ | ^^^^^^^^^ value used here after move
+ |
+note: `Foo::use_box_self` takes ownership of the receiver `self`, which moves `boxed_foo`
+ --> $DIR/move-fn-self-receiver.rs:14:21
+ |
+LL | fn use_box_self(self: Box<Self>) {}
+ | ^^^^
+
+error[E0382]: use of moved value: `pin_box_foo`
+ --> $DIR/move-fn-self-receiver.rs:46:5
+ |
+LL | let pin_box_foo = Box::pin(Foo);
+ | ----------- move occurs because `pin_box_foo` has type `Pin<Box<Foo>>`, which does not implement the `Copy` trait
+LL | pin_box_foo.use_pin_box_self();
+ | ------------------ `pin_box_foo` moved due to this method call
+LL | pin_box_foo;
+ | ^^^^^^^^^^^ value used here after move
+ |
+note: `Foo::use_pin_box_self` takes ownership of the receiver `self`, which moves `pin_box_foo`
+ --> $DIR/move-fn-self-receiver.rs:15:25
+ |
+LL | fn use_pin_box_self(self: Pin<Box<Self>>) {}
+ | ^^^^
+
+error[E0505]: cannot move out of `mut_foo` because it is borrowed
+ --> $DIR/move-fn-self-receiver.rs:50:5
+ |
+LL | let ret = mut_foo.use_mut_self();
+ | ---------------------- borrow of `mut_foo` occurs here
+LL | mut_foo;
+ | ^^^^^^^ move out of `mut_foo` occurs here
+LL | ret;
+ | --- borrow later used here
+
+error[E0382]: use of moved value: `rc_foo`
+ --> $DIR/move-fn-self-receiver.rs:55:5
+ |
+LL | let rc_foo = Rc::new(Foo);
+ | ------ move occurs because `rc_foo` has type `Rc<Foo>`, which does not implement the `Copy` trait
+LL | rc_foo.use_rc_self();
+ | ------------- `rc_foo` moved due to this method call
+LL | rc_foo;
+ | ^^^^^^ value used here after move
+ |
+note: `Foo::use_rc_self` takes ownership of the receiver `self`, which moves `rc_foo`
+ --> $DIR/move-fn-self-receiver.rs:16:20
+ |
+LL | fn use_rc_self(self: Rc<Self>) {}
+ | ^^^^
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | rc_foo.clone().use_rc_self();
+ | ++++++++
+
+error[E0382]: use of moved value: `foo_add`
+ --> $DIR/move-fn-self-receiver.rs:59:5
+ |
+LL | let foo_add = Foo;
+ | ------- move occurs because `foo_add` has type `Foo`, which does not implement the `Copy` trait
+LL | foo_add + Foo;
+ | ------------- `foo_add` moved due to usage in operator
+LL | foo_add;
+ | ^^^^^^^ value used here after move
+ |
+note: calling this operator moves the left-hand side
+ --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
+
+error[E0382]: use of moved value: `implicit_into_iter`
+ --> $DIR/move-fn-self-receiver.rs:63:5
+ |
+LL | let implicit_into_iter = vec![true];
+ | ------------------ move occurs because `implicit_into_iter` has type `Vec<bool>`, which does not implement the `Copy` trait
+LL | for _val in implicit_into_iter {}
+ | ------------------ `implicit_into_iter` moved due to this implicit call to `.into_iter()`
+LL | implicit_into_iter;
+ | ^^^^^^^^^^^^^^^^^^ value used here after move
+ |
+help: consider iterating over a slice of the `Vec<bool>`'s content to avoid moving into the `for` loop
+ |
+LL | for _val in &implicit_into_iter {}
+ | +
+
+error[E0382]: use of moved value: `explicit_into_iter`
+ --> $DIR/move-fn-self-receiver.rs:67:5
+ |
+LL | let explicit_into_iter = vec![true];
+ | ------------------ move occurs because `explicit_into_iter` has type `Vec<bool>`, which does not implement the `Copy` trait
+LL | for _val in explicit_into_iter.into_iter() {}
+ | ----------- `explicit_into_iter` moved due to this method call
+LL | explicit_into_iter;
+ | ^^^^^^^^^^^^^^^^^^ value used here after move
+ |
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | for _val in explicit_into_iter.clone().into_iter() {}
+ | ++++++++
+
+error[E0382]: use of moved value: `container`
+ --> $DIR/move-fn-self-receiver.rs:71:5
+ |
+LL | let container = Container(vec![]);
+ | --------- move occurs because `container` has type `Container`, which does not implement the `Copy` trait
+LL | for _val in container.custom_into_iter() {}
+ | ------------------ `container` moved due to this method call
+LL | container;
+ | ^^^^^^^^^ value used here after move
+ |
+note: `Container::custom_into_iter` takes ownership of the receiver `self`, which moves `container`
+ --> $DIR/move-fn-self-receiver.rs:23:25
+ |
+LL | fn custom_into_iter(self) -> impl Iterator<Item = bool> {
+ | ^^^^
+
+error[E0382]: use of moved value: `foo2`
+ --> $DIR/move-fn-self-receiver.rs:75:9
+ |
+LL | let foo2 = Foo;
+ | ---- move occurs because `foo2` has type `Foo`, which does not implement the `Copy` trait
+LL | loop {
+ | ---- inside of this loop
+LL | foo2.use_self();
+ | ^^^^ ---------- `foo2` moved due to this method call, in previous iteration of loop
+
+error: aborting due to 12 previous errors
+
+Some errors have detailed explanations: E0382, E0505.
+For more information about an error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-guard-same-consts.rs b/tests/ui/moves/move-guard-same-consts.rs
new file mode 100644
index 000000000..b96ef8e19
--- /dev/null
+++ b/tests/ui/moves/move-guard-same-consts.rs
@@ -0,0 +1,25 @@
+// #47295: We used to have a hack of special-casing adjacent amtch
+// arms whose patterns were composed solely of constants to not have
+// them linked in the cfg.
+//
+// This was broken for various reasons. In particular, that hack was
+// originally authored under the assunption that other checks
+// elsewhere would ensure that the two patterns did not overlap. But
+// that assumption did not hold, at least not in the long run (namely,
+// overlapping patterns were turned into warnings rather than errors).
+
+
+
+fn main() {
+ let x: Box<_> = Box::new(1);
+
+ let v = (1, 2);
+
+ match v {
+ (1, 2) if take(x) => (),
+ (1, 2) if take(x) => (), //~ ERROR use of moved value: `x`
+ _ => (),
+ }
+}
+
+fn take<T>(_: T) -> bool { false }
diff --git a/tests/ui/moves/move-guard-same-consts.stderr b/tests/ui/moves/move-guard-same-consts.stderr
new file mode 100644
index 000000000..86e5f6524
--- /dev/null
+++ b/tests/ui/moves/move-guard-same-consts.stderr
@@ -0,0 +1,26 @@
+error[E0382]: use of moved value: `x`
+ --> $DIR/move-guard-same-consts.rs:20:24
+ |
+LL | let x: Box<_> = Box::new(1);
+ | - move occurs because `x` has type `Box<i32>`, which does not implement the `Copy` trait
+...
+LL | (1, 2) if take(x) => (),
+ | - value moved here
+LL | (1, 2) if take(x) => (),
+ | ^ value used here after move
+ |
+note: consider changing this parameter type in function `take` to borrow instead if owning the value isn't necessary
+ --> $DIR/move-guard-same-consts.rs:25:15
+ |
+LL | fn take<T>(_: T) -> bool { false }
+ | ---- ^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | (1, 2) if take(x.clone()) => (),
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-in-guard-1.rs b/tests/ui/moves/move-in-guard-1.rs
new file mode 100644
index 000000000..36e39fea6
--- /dev/null
+++ b/tests/ui/moves/move-in-guard-1.rs
@@ -0,0 +1,15 @@
+pub fn main() {
+
+
+ let x: Box<_> = Box::new(1);
+
+ let v = (1, 2);
+
+ match v {
+ (1, _) if take(x) => (),
+ (_, 2) if take(x) => (), //~ ERROR use of moved value: `x`
+ _ => (),
+ }
+}
+
+fn take<T>(_: T) -> bool { false }
diff --git a/tests/ui/moves/move-in-guard-1.stderr b/tests/ui/moves/move-in-guard-1.stderr
new file mode 100644
index 000000000..f04cb34d7
--- /dev/null
+++ b/tests/ui/moves/move-in-guard-1.stderr
@@ -0,0 +1,26 @@
+error[E0382]: use of moved value: `x`
+ --> $DIR/move-in-guard-1.rs:10:24
+ |
+LL | let x: Box<_> = Box::new(1);
+ | - move occurs because `x` has type `Box<i32>`, which does not implement the `Copy` trait
+...
+LL | (1, _) if take(x) => (),
+ | - value moved here
+LL | (_, 2) if take(x) => (),
+ | ^ value used here after move
+ |
+note: consider changing this parameter type in function `take` to borrow instead if owning the value isn't necessary
+ --> $DIR/move-in-guard-1.rs:15:15
+ |
+LL | fn take<T>(_: T) -> bool { false }
+ | ---- ^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | (1, _) if take(x.clone()) => (),
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-in-guard-2.rs b/tests/ui/moves/move-in-guard-2.rs
new file mode 100644
index 000000000..085b7ec6e
--- /dev/null
+++ b/tests/ui/moves/move-in-guard-2.rs
@@ -0,0 +1,13 @@
+pub fn main() {
+ let x: Box<_> = Box::new(1);
+
+ let v = (1, 2);
+
+ match v {
+ (1, _) |
+ (_, 2) if take(x) => (), //~ ERROR use of moved value: `x`
+ _ => (),
+ }
+}
+
+fn take<T>(_: T) -> bool { false }
diff --git a/tests/ui/moves/move-in-guard-2.stderr b/tests/ui/moves/move-in-guard-2.stderr
new file mode 100644
index 000000000..26047861f
--- /dev/null
+++ b/tests/ui/moves/move-in-guard-2.stderr
@@ -0,0 +1,24 @@
+error[E0382]: use of moved value: `x`
+ --> $DIR/move-in-guard-2.rs:8:24
+ |
+LL | let x: Box<_> = Box::new(1);
+ | - move occurs because `x` has type `Box<i32>`, which does not implement the `Copy` trait
+...
+LL | (_, 2) if take(x) => (),
+ | ^ value used here after move
+ |
+note: consider changing this parameter type in function `take` to borrow instead if owning the value isn't necessary
+ --> $DIR/move-in-guard-2.rs:13:15
+ |
+LL | fn take<T>(_: T) -> bool { false }
+ | ---- ^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | (_, 2) if take(x.clone()) => (),
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-into-dead-array-1.rs b/tests/ui/moves/move-into-dead-array-1.rs
new file mode 100644
index 000000000..0b8d76def
--- /dev/null
+++ b/tests/ui/moves/move-into-dead-array-1.rs
@@ -0,0 +1,15 @@
+// Ensure that we cannot move into an uninitialized fixed-size array.
+
+struct D { _x: u8 }
+
+fn d() -> D { D { _x: 0 } }
+
+fn main() {
+ foo(1);
+ foo(3);
+}
+
+fn foo(i: usize) {
+ let mut a: [D; 4];
+ a[i] = d(); //~ ERROR E0381
+}
diff --git a/tests/ui/moves/move-into-dead-array-1.stderr b/tests/ui/moves/move-into-dead-array-1.stderr
new file mode 100644
index 000000000..6db0f0bcb
--- /dev/null
+++ b/tests/ui/moves/move-into-dead-array-1.stderr
@@ -0,0 +1,16 @@
+error[E0381]: used binding `a` isn't initialized
+ --> $DIR/move-into-dead-array-1.rs:14:5
+ |
+LL | let mut a: [D; 4];
+ | ----- binding declared here but left uninitialized
+LL | a[i] = d();
+ | ^^^^ `a` used here but it isn't initialized
+ |
+help: consider assigning a value
+ |
+LL | let mut a: [D; 4] = todo!();
+ | +++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/moves/move-into-dead-array-2.rs b/tests/ui/moves/move-into-dead-array-2.rs
new file mode 100644
index 000000000..9b66ea35f
--- /dev/null
+++ b/tests/ui/moves/move-into-dead-array-2.rs
@@ -0,0 +1,15 @@
+// Ensure that we cannot move into an uninitialized fixed-size array.
+
+struct D { _x: u8 }
+
+fn d() -> D { D { _x: 0 } }
+
+fn main() {
+ foo([d(), d(), d(), d()], 1);
+ foo([d(), d(), d(), d()], 3);
+}
+
+fn foo(mut a: [D; 4], i: usize) {
+ drop(a);
+ a[i] = d(); //~ ERROR use of moved value: `a`
+}
diff --git a/tests/ui/moves/move-into-dead-array-2.stderr b/tests/ui/moves/move-into-dead-array-2.stderr
new file mode 100644
index 000000000..19e476c04
--- /dev/null
+++ b/tests/ui/moves/move-into-dead-array-2.stderr
@@ -0,0 +1,13 @@
+error[E0382]: use of moved value: `a`
+ --> $DIR/move-into-dead-array-2.rs:14:5
+ |
+LL | fn foo(mut a: [D; 4], i: usize) {
+ | ----- move occurs because `a` has type `[D; 4]`, which does not implement the `Copy` trait
+LL | drop(a);
+ | - value moved here
+LL | a[i] = d();
+ | ^^^^ value used here after move
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-nullary-fn.rs b/tests/ui/moves/move-nullary-fn.rs
new file mode 100644
index 000000000..14c9262c7
--- /dev/null
+++ b/tests/ui/moves/move-nullary-fn.rs
@@ -0,0 +1,13 @@
+// run-pass
+// Issue #922
+// pretty-expanded FIXME #23616
+
+fn f2<F>(_thing: F) where F: FnOnce() { }
+
+fn f<F>(thing: F) where F: FnOnce() {
+ f2(thing);
+}
+
+pub fn main() {
+ f(|| {});
+}
diff --git a/tests/ui/moves/move-of-addr-of-mut.rs b/tests/ui/moves/move-of-addr-of-mut.rs
new file mode 100644
index 000000000..19fd70286
--- /dev/null
+++ b/tests/ui/moves/move-of-addr-of-mut.rs
@@ -0,0 +1,12 @@
+// Ensure that taking a mutable raw ptr to an uninitialized variable does not change its
+// initializedness.
+
+struct S;
+
+fn main() {
+ let mut x: S;
+ std::ptr::addr_of_mut!(x); //~ ERROR E0381
+
+ let y = x; // Should error here if `addr_of_mut` is ever allowed on uninitialized variables
+ drop(y);
+}
diff --git a/tests/ui/moves/move-of-addr-of-mut.stderr b/tests/ui/moves/move-of-addr-of-mut.stderr
new file mode 100644
index 000000000..ddebaa012
--- /dev/null
+++ b/tests/ui/moves/move-of-addr-of-mut.stderr
@@ -0,0 +1,17 @@
+error[E0381]: used binding `x` isn't initialized
+ --> $DIR/move-of-addr-of-mut.rs:8:5
+ |
+LL | let mut x: S;
+ | ----- binding declared here but left uninitialized
+LL | std::ptr::addr_of_mut!(x);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ `x` used here but it isn't initialized
+ |
+ = note: this error originates in the macro `std::ptr::addr_of_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider assigning a value
+ |
+LL | let mut x: S = todo!();
+ | +++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0381`.
diff --git a/tests/ui/moves/move-out-of-array-1.rs b/tests/ui/moves/move-out-of-array-1.rs
new file mode 100644
index 000000000..77cb73e47
--- /dev/null
+++ b/tests/ui/moves/move-out-of-array-1.rs
@@ -0,0 +1,18 @@
+// Ensure that we cannot move out of a fixed-size array (especially
+// when the element type has a destructor).
+
+
+struct D { _x: u8 }
+
+impl Drop for D { fn drop(&mut self) { } }
+
+fn main() {
+ fn d() -> D { D { _x: 0 } }
+
+ let _d1 = foo([d(), d(), d(), d()], 1);
+ let _d3 = foo([d(), d(), d(), d()], 3);
+}
+
+fn foo(a: [D; 4], i: usize) -> D {
+ a[i] //~ ERROR cannot move out of type `[D; 4]`, a non-copy array
+}
diff --git a/tests/ui/moves/move-out-of-array-1.stderr b/tests/ui/moves/move-out-of-array-1.stderr
new file mode 100644
index 000000000..0af083e5b
--- /dev/null
+++ b/tests/ui/moves/move-out-of-array-1.stderr
@@ -0,0 +1,12 @@
+error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
+ --> $DIR/move-out-of-array-1.rs:17:5
+ |
+LL | a[i]
+ | ^^^^
+ | |
+ | cannot move out of here
+ | move occurs because `a[_]` has type `D`, which does not implement the `Copy` trait
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/move-out-of-array-ref.rs b/tests/ui/moves/move-out-of-array-ref.rs
new file mode 100644
index 000000000..343f00ff2
--- /dev/null
+++ b/tests/ui/moves/move-out-of-array-ref.rs
@@ -0,0 +1,34 @@
+// Ensure that we cannot move out of a reference to a fixed-size array
+
+struct D { _x: u8 }
+
+impl Drop for D { fn drop(&mut self) { } }
+
+fn move_elem(a: &[D; 4]) -> D {
+ let [_, e, _, _] = *a; //~ ERROR cannot move
+ e
+}
+
+fn move_subarr(a: &[D; 4]) -> [D; 2] {
+ let [_, s @ .. , _] = *a; //~ ERROR cannot move
+ s
+}
+
+fn move_elem_mut(a: &mut [D; 4]) -> D {
+ let [_, e, _, _] = *a; //~ ERROR cannot move
+ e
+}
+
+fn move_subarr_mut(a: &mut [D; 4]) -> [D; 2] {
+ let [_, s @ .. , _] = *a; //~ ERROR cannot move
+ s
+}
+
+fn main() {
+ fn d() -> D { D { _x: 0 } }
+
+ move_elem(&[d(), d(), d(), d()]);
+ move_subarr(&[d(), d(), d(), d()]);
+ move_elem_mut(&mut [d(), d(), d(), d()]);
+ move_subarr_mut(&mut [d(), d(), d(), d()]);
+}
diff --git a/tests/ui/moves/move-out-of-array-ref.stderr b/tests/ui/moves/move-out-of-array-ref.stderr
new file mode 100644
index 000000000..26d4996d6
--- /dev/null
+++ b/tests/ui/moves/move-out-of-array-ref.stderr
@@ -0,0 +1,63 @@
+error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
+ --> $DIR/move-out-of-array-ref.rs:8:24
+ |
+LL | let [_, e, _, _] = *a;
+ | - ^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `e` has type `D`, which does not implement the `Copy` trait
+ |
+help: consider removing the dereference here
+ |
+LL - let [_, e, _, _] = *a;
+LL + let [_, e, _, _] = a;
+ |
+
+error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
+ --> $DIR/move-out-of-array-ref.rs:13:27
+ |
+LL | let [_, s @ .. , _] = *a;
+ | - ^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `s` has type `[D; 2]`, which does not implement the `Copy` trait
+ |
+help: consider removing the dereference here
+ |
+LL - let [_, s @ .. , _] = *a;
+LL + let [_, s @ .. , _] = a;
+ |
+
+error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
+ --> $DIR/move-out-of-array-ref.rs:18:24
+ |
+LL | let [_, e, _, _] = *a;
+ | - ^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `e` has type `D`, which does not implement the `Copy` trait
+ |
+help: consider removing the dereference here
+ |
+LL - let [_, e, _, _] = *a;
+LL + let [_, e, _, _] = a;
+ |
+
+error[E0508]: cannot move out of type `[D; 4]`, a non-copy array
+ --> $DIR/move-out-of-array-ref.rs:23:27
+ |
+LL | let [_, s @ .. , _] = *a;
+ | - ^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `s` has type `[D; 2]`, which does not implement the `Copy` trait
+ |
+help: consider removing the dereference here
+ |
+LL - let [_, s @ .. , _] = *a;
+LL + let [_, s @ .. , _] = a;
+ |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/move-out-of-field.rs b/tests/ui/moves/move-out-of-field.rs
new file mode 100644
index 000000000..9f697db4f
--- /dev/null
+++ b/tests/ui/moves/move-out-of-field.rs
@@ -0,0 +1,27 @@
+// run-pass
+
+use std::string::String;
+
+struct StringBuffer {
+ s: String,
+}
+
+impl StringBuffer {
+ pub fn append(&mut self, v: &str) {
+ self.s.push_str(v);
+ }
+}
+
+fn to_string(sb: StringBuffer) -> String {
+ sb.s
+}
+
+pub fn main() {
+ let mut sb = StringBuffer {
+ s: String::new(),
+ };
+ sb.append("Hello, ");
+ sb.append("World!");
+ let str = to_string(sb);
+ assert_eq!(str, "Hello, World!");
+}
diff --git a/tests/ui/moves/move-out-of-slice-1.rs b/tests/ui/moves/move-out-of-slice-1.rs
new file mode 100644
index 000000000..982648f5b
--- /dev/null
+++ b/tests/ui/moves/move-out-of-slice-1.rs
@@ -0,0 +1,11 @@
+#![feature(box_patterns)]
+
+struct A;
+
+fn main() {
+ let a: Box<[A]> = Box::new([A]);
+ match a { //~ ERROR cannot move out of type `[A]`, a non-copy slice
+ box [a] => {},
+ _ => {}
+ }
+}
diff --git a/tests/ui/moves/move-out-of-slice-1.stderr b/tests/ui/moves/move-out-of-slice-1.stderr
new file mode 100644
index 000000000..5a0357cf5
--- /dev/null
+++ b/tests/ui/moves/move-out-of-slice-1.stderr
@@ -0,0 +1,19 @@
+error[E0508]: cannot move out of type `[A]`, a non-copy slice
+ --> $DIR/move-out-of-slice-1.rs:7:11
+ |
+LL | match a {
+ | ^ cannot move out of here
+LL | box [a] => {},
+ | -
+ | |
+ | data moved here
+ | move occurs because `a` has type `A`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | box [ref a] => {},
+ | +++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/move-out-of-slice-2.rs b/tests/ui/moves/move-out-of-slice-2.rs
new file mode 100644
index 000000000..2f7394fbf
--- /dev/null
+++ b/tests/ui/moves/move-out-of-slice-2.rs
@@ -0,0 +1,36 @@
+#![feature(unsized_locals)]
+//~^ WARN the feature `unsized_locals` is incomplete
+#![allow(unused)]
+
+struct A;
+#[derive(Clone, Copy)]
+struct C;
+
+fn main() {
+ let a: Box<[A]> = Box::new([A]);
+ match *a {
+ //~^ ERROR cannot move out of type `[A]`, a non-copy slice
+ [a @ ..] => {}
+ _ => {}
+ }
+ let b: Box<[A]> = Box::new([A, A, A]);
+ match *b {
+ //~^ ERROR cannot move out of type `[A]`, a non-copy slice
+ [_, _, b @ .., _] => {}
+ _ => {}
+ }
+
+ // `[C]` isn't `Copy`, even if `C` is.
+ let c: Box<[C]> = Box::new([C]);
+ match *c {
+ //~^ ERROR cannot move out of type `[C]`, a non-copy slice
+ [c @ ..] => {}
+ _ => {}
+ }
+ let d: Box<[C]> = Box::new([C, C, C]);
+ match *d {
+ //~^ ERROR cannot move out of type `[C]`, a non-copy slice
+ [_, _, d @ .., _] => {}
+ _ => {}
+ }
+}
diff --git a/tests/ui/moves/move-out-of-slice-2.stderr b/tests/ui/moves/move-out-of-slice-2.stderr
new file mode 100644
index 000000000..b46854cd6
--- /dev/null
+++ b/tests/ui/moves/move-out-of-slice-2.stderr
@@ -0,0 +1,80 @@
+warning: the feature `unsized_locals` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/move-out-of-slice-2.rs:1:12
+ |
+LL | #![feature(unsized_locals)]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: see issue #48055 <https://github.com/rust-lang/rust/issues/48055> for more information
+ = note: `#[warn(incomplete_features)]` on by default
+
+error[E0508]: cannot move out of type `[A]`, a non-copy slice
+ --> $DIR/move-out-of-slice-2.rs:11:11
+ |
+LL | match *a {
+ | ^^ cannot move out of here
+LL |
+LL | [a @ ..] => {}
+ | -
+ | |
+ | data moved here
+ | move occurs because `a` has type `[A]`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | [ref a @ ..] => {}
+ | +++
+
+error[E0508]: cannot move out of type `[A]`, a non-copy slice
+ --> $DIR/move-out-of-slice-2.rs:17:11
+ |
+LL | match *b {
+ | ^^ cannot move out of here
+LL |
+LL | [_, _, b @ .., _] => {}
+ | -
+ | |
+ | data moved here
+ | move occurs because `b` has type `[A]`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | [_, _, ref b @ .., _] => {}
+ | +++
+
+error[E0508]: cannot move out of type `[C]`, a non-copy slice
+ --> $DIR/move-out-of-slice-2.rs:25:11
+ |
+LL | match *c {
+ | ^^ cannot move out of here
+LL |
+LL | [c @ ..] => {}
+ | -
+ | |
+ | data moved here
+ | move occurs because `c` has type `[C]`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | [ref c @ ..] => {}
+ | +++
+
+error[E0508]: cannot move out of type `[C]`, a non-copy slice
+ --> $DIR/move-out-of-slice-2.rs:31:11
+ |
+LL | match *d {
+ | ^^ cannot move out of here
+LL |
+LL | [_, _, d @ .., _] => {}
+ | -
+ | |
+ | data moved here
+ | move occurs because `d` has type `[C]`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | [_, _, ref d @ .., _] => {}
+ | +++
+
+error: aborting due to 4 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0508`.
diff --git a/tests/ui/moves/move-out-of-tuple-field.rs b/tests/ui/moves/move-out-of-tuple-field.rs
new file mode 100644
index 000000000..66912fa4d
--- /dev/null
+++ b/tests/ui/moves/move-out-of-tuple-field.rs
@@ -0,0 +1,13 @@
+struct Foo(Box<isize>);
+
+
+
+fn main() {
+ let x: (Box<_>,) = (Box::new(1),);
+ let y = x.0;
+ let z = x.0; //~ ERROR use of moved value: `x.0`
+
+ let x = Foo(Box::new(1));
+ let y = x.0;
+ let z = x.0; //~ ERROR use of moved value: `x.0`
+}
diff --git a/tests/ui/moves/move-out-of-tuple-field.stderr b/tests/ui/moves/move-out-of-tuple-field.stderr
new file mode 100644
index 000000000..bb4eb7677
--- /dev/null
+++ b/tests/ui/moves/move-out-of-tuple-field.stderr
@@ -0,0 +1,23 @@
+error[E0382]: use of moved value: `x.0`
+ --> $DIR/move-out-of-tuple-field.rs:8:13
+ |
+LL | let y = x.0;
+ | --- value moved here
+LL | let z = x.0;
+ | ^^^ value used here after move
+ |
+ = note: move occurs because `x.0` has type `Box<i32>`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value: `x.0`
+ --> $DIR/move-out-of-tuple-field.rs:12:13
+ |
+LL | let y = x.0;
+ | --- value moved here
+LL | let z = x.0;
+ | ^^^ value used here after move
+ |
+ = note: move occurs because `x.0` has type `Box<isize>`, which does not implement the `Copy` trait
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/move-scalar.rs b/tests/ui/moves/move-scalar.rs
new file mode 100644
index 000000000..98bfeb1bc
--- /dev/null
+++ b/tests/ui/moves/move-scalar.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![allow(unused_mut)]
+
+pub fn main() {
+
+ let y: isize = 42;
+ let mut x: isize;
+ x = y;
+ assert_eq!(x, 42);
+}
diff --git a/tests/ui/moves/moves-based-on-type-access-to-field.rs b/tests/ui/moves/moves-based-on-type-access-to-field.rs
new file mode 100644
index 000000000..e2003ed6e
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-access-to-field.rs
@@ -0,0 +1,14 @@
+// Tests that if you move from `x.f` or `x[0]`, `x` is inaccessible.
+// Also tests that we give a more specific error message.
+
+struct Foo { f: String, y: isize }
+fn consume(_s: String) {}
+fn touch<A>(_a: &A) {}
+
+fn f20() {
+ let x = vec!["hi".to_string()];
+ consume(x.into_iter().next().unwrap());
+ touch(&x[0]); //~ ERROR borrow of moved value: `x`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-based-on-type-access-to-field.stderr b/tests/ui/moves/moves-based-on-type-access-to-field.stderr
new file mode 100644
index 000000000..a28f324aa
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-access-to-field.stderr
@@ -0,0 +1,20 @@
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-access-to-field.rs:11:12
+ |
+LL | let x = vec!["hi".to_string()];
+ | - move occurs because `x` has type `Vec<String>`, which does not implement the `Copy` trait
+LL | consume(x.into_iter().next().unwrap());
+ | ----------- `x` moved due to this method call
+LL | touch(&x[0]);
+ | ^ value borrowed here after move
+ |
+note: `into_iter` takes ownership of the receiver `self`, which moves `x`
+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | consume(x.clone().into_iter().next().unwrap());
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-block-bad.rs b/tests/ui/moves/moves-based-on-type-block-bad.rs
new file mode 100644
index 000000000..eca33167f
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-block-bad.rs
@@ -0,0 +1,29 @@
+#![feature(box_patterns)]
+
+
+struct S {
+ x: Box<E>
+}
+
+enum E {
+ Foo(Box<S>),
+ Bar(Box<isize>),
+ Baz
+}
+
+fn f<G>(s: &S, g: G) where G: FnOnce(&S) {
+ g(s)
+}
+
+fn main() {
+ let s = S { x: Box::new(E::Bar(Box::new(42))) };
+ loop {
+ f(&s, |hellothere| {
+ match hellothere.x { //~ ERROR cannot move out
+ box E::Foo(_) => {}
+ box E::Bar(x) => println!("{}", x.to_string()),
+ box E::Baz => {}
+ }
+ })
+ }
+}
diff --git a/tests/ui/moves/moves-based-on-type-block-bad.stderr b/tests/ui/moves/moves-based-on-type-block-bad.stderr
new file mode 100644
index 000000000..df09ababa
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-block-bad.stderr
@@ -0,0 +1,20 @@
+error[E0507]: cannot move out of `hellothere.x` as enum variant `Bar` which is behind a shared reference
+ --> $DIR/moves-based-on-type-block-bad.rs:22:19
+ |
+LL | match hellothere.x {
+ | ^^^^^^^^^^^^
+LL | box E::Foo(_) => {}
+LL | box E::Bar(x) => println!("{}", x.to_string()),
+ | -
+ | |
+ | data moved here
+ | move occurs because `x` has type `Box<isize>`, which does not implement the `Copy` trait
+ |
+help: consider borrowing here
+ |
+LL | match &hellothere.x {
+ | +
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/moves-based-on-type-capture-clause-bad.rs b/tests/ui/moves/moves-based-on-type-capture-clause-bad.rs
new file mode 100644
index 000000000..b2f68352f
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-capture-clause-bad.rs
@@ -0,0 +1,9 @@
+use std::thread;
+
+fn main() {
+ let x = "Hello world!".to_string();
+ thread::spawn(move|| {
+ println!("{}", x);
+ });
+ println!("{}", x); //~ ERROR borrow of moved value
+}
diff --git a/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr b/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr
new file mode 100644
index 000000000..34b7ea658
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-capture-clause-bad.stderr
@@ -0,0 +1,18 @@
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-capture-clause-bad.rs:8:20
+ |
+LL | let x = "Hello world!".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL | thread::spawn(move|| {
+ | ------ value moved into closure here
+LL | println!("{}", x);
+ | - variable moved due to use in closure
+LL | });
+LL | println!("{}", x);
+ | ^ value borrowed here after move
+ |
+ = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-capture-clause.rs b/tests/ui/moves/moves-based-on-type-capture-clause.rs
new file mode 100644
index 000000000..4a6a4ed28
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-capture-clause.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![allow(unused_must_use)]
+// ignore-emscripten no threads support
+
+use std::thread;
+
+pub fn main() {
+ let x = "Hello world!".to_string();
+ thread::spawn(move|| {
+ println!("{}", x);
+ }).join();
+}
diff --git a/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.rs b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.rs
new file mode 100644
index 000000000..4417fb926
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.rs
@@ -0,0 +1,20 @@
+// Test for a subtle failure computing kinds of cyclic types, in which
+// temporary kinds wound up being stored in a cache and used later.
+// See rustc::ty::type_contents() for more information.
+
+
+struct List { key: isize, next: Option<Box<List>> }
+
+fn foo(node: Box<List>) -> isize {
+ let r = match node.next {
+ Some(right) => consume(right),
+ None => 0
+ };
+ consume(node) + r //~ ERROR use of partially moved value: `node`
+}
+
+fn consume(v: Box<List>) -> isize {
+ v.key
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr
new file mode 100644
index 000000000..db4382b58
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-cyclic-types-issue-4821.stderr
@@ -0,0 +1,18 @@
+error[E0382]: use of partially moved value: `node`
+ --> $DIR/moves-based-on-type-cyclic-types-issue-4821.rs:13:13
+ |
+LL | Some(right) => consume(right),
+ | ----- value partially moved here
+...
+LL | consume(node) + r
+ | ^^^^ value used here after partial move
+ |
+ = note: partial move occurs because value has type `Box<List>`, which does not implement the `Copy` trait
+help: borrow this binding in the pattern to avoid moving the value
+ |
+LL | Some(ref right) => consume(right),
+ | +++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.rs b/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.rs
new file mode 100644
index 000000000..d256e18b6
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.rs
@@ -0,0 +1,49 @@
+// Tests that references to move-by-default values trigger moves when
+// they occur as part of various kinds of expressions.
+
+struct Foo<A> { f: A }
+fn touch<A>(_a: &A) {}
+
+fn f00() {
+ let x = "hi".to_string();
+ //~^ NOTE move occurs because `x` has type `String`
+ let _y = Foo { f:x };
+ //~^ NOTE value moved here
+ touch(&x); //~ ERROR borrow of moved value: `x`
+ //~^ NOTE value borrowed here after move
+}
+
+fn f05() {
+ let x = "hi".to_string();
+ //~^ NOTE move occurs because `x` has type `String`
+ let _y = Foo { f:(((x))) };
+ //~^ NOTE value moved here
+ touch(&x); //~ ERROR borrow of moved value: `x`
+ //~^ NOTE value borrowed here after move
+}
+
+fn f10() {
+ let x = "hi".to_string();
+ let _y = Foo { f:x.clone() };
+ touch(&x);
+}
+
+fn f20() {
+ let x = "hi".to_string();
+ let _y = Foo { f:(x).clone() };
+ touch(&x);
+}
+
+fn f30() {
+ let x = "hi".to_string();
+ let _y = Foo { f:((x)).clone() };
+ touch(&x);
+}
+
+fn f40() {
+ let x = "hi".to_string();
+ let _y = Foo { f:(((((((x)).clone()))))) };
+ touch(&x);
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.stderr b/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.stderr
new file mode 100644
index 000000000..0930df148
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-distribute-copy-over-paren.stderr
@@ -0,0 +1,37 @@
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-distribute-copy-over-paren.rs:12:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL |
+LL | let _y = Foo { f:x };
+ | - value moved here
+LL |
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = Foo { f:x.clone() };
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-distribute-copy-over-paren.rs:21:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL |
+LL | let _y = Foo { f:(((x))) };
+ | ------- value moved here
+LL |
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = Foo { f:(((x))).clone() };
+ | ++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-exprs.rs b/tests/ui/moves/moves-based-on-type-exprs.rs
new file mode 100644
index 000000000..4a52d8d32
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-exprs.rs
@@ -0,0 +1,93 @@
+// Tests that references to move-by-default values trigger moves when
+// they occur as part of various kinds of expressions.
+
+
+struct Foo<A> { f: A }
+fn guard(_s: String) -> bool {panic!()}
+fn touch<A>(_a: &A) {}
+
+fn f10() {
+ let x = "hi".to_string();
+ let _y = Foo { f:x };
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f20() {
+ let x = "hi".to_string();
+ let _y = (x, 3);
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f21() {
+ let x = vec![1, 2, 3];
+ let _y = (x[0], 3);
+ touch(&x);
+}
+
+fn f30(cond: bool) {
+ let x = "hi".to_string();
+ let y = "ho".to_string();
+ let _y = if cond {
+ x
+ } else {
+ y
+ };
+ touch(&x); //~ ERROR borrow of moved value: `x`
+ touch(&y); //~ ERROR borrow of moved value: `y`
+}
+
+fn f40(cond: bool) {
+ let x = "hi".to_string();
+ let y = "ho".to_string();
+ let _y = match cond {
+ true => x,
+ false => y
+ };
+ touch(&x); //~ ERROR borrow of moved value: `x`
+ touch(&y); //~ ERROR borrow of moved value: `y`
+}
+
+fn f50(cond: bool) {
+ let x = "hi".to_string();
+ let y = "ho".to_string();
+ let _y = match cond {
+ _ if guard(x) => 10,
+ true => 10,
+ false => 20,
+ };
+ touch(&x); //~ ERROR borrow of moved value: `x`
+ touch(&y);
+}
+
+fn f70() {
+ let x = "hi".to_string();
+ let _y = [x];
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f80() {
+ let x = "hi".to_string();
+ let _y = vec![x];
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f100() {
+ let x = vec!["hi".to_string()];
+ let _y = x.into_iter().next().unwrap();
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f110() {
+ let x = vec!["hi".to_string()];
+ let _y = [x.into_iter().next().unwrap(); 1];
+ touch(&x); //~ ERROR borrow of moved value: `x`
+}
+
+fn f120() {
+ let mut x = vec!["hi".to_string(), "ho".to_string()];
+ x.swap(0, 1);
+ touch(&x[0]);
+ touch(&x[1]);
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-based-on-type-exprs.stderr b/tests/ui/moves/moves-based-on-type-exprs.stderr
new file mode 100644
index 000000000..ab7c27456
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-exprs.stderr
@@ -0,0 +1,189 @@
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:12:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL | let _y = Foo { f:x };
+ | - value moved here
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = Foo { f:x.clone() };
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:18:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL | let _y = (x, 3);
+ | - value moved here
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = (x.clone(), 3);
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:35:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+...
+LL | x
+ | - value moved here
+...
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | x.clone()
+ | ++++++++
+
+error[E0382]: borrow of moved value: `y`
+ --> $DIR/moves-based-on-type-exprs.rs:36:11
+ |
+LL | let y = "ho".to_string();
+ | - move occurs because `y` has type `String`, which does not implement the `Copy` trait
+...
+LL | y
+ | - value moved here
+...
+LL | touch(&y);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | y.clone()
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:46:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+...
+LL | true => x,
+ | - value moved here
+...
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | true => x.clone(),
+ | ++++++++
+
+error[E0382]: borrow of moved value: `y`
+ --> $DIR/moves-based-on-type-exprs.rs:47:11
+ |
+LL | let y = "ho".to_string();
+ | - move occurs because `y` has type `String`, which does not implement the `Copy` trait
+...
+LL | false => y
+ | - value moved here
+...
+LL | touch(&y);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | false => y.clone()
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:58:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+...
+LL | _ if guard(x) => 10,
+ | - value moved here
+...
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+note: consider changing this parameter type in function `guard` to borrow instead if owning the value isn't necessary
+ --> $DIR/moves-based-on-type-exprs.rs:6:14
+ |
+LL | fn guard(_s: String) -> bool {panic!()}
+ | ----- ^^^^^^ this parameter takes ownership of the value
+ | |
+ | in this function
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | _ if guard(x.clone()) => 10,
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:65:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL | let _y = [x];
+ | - value moved here
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = [x.clone()];
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:71:11
+ |
+LL | let x = "hi".to_string();
+ | - move occurs because `x` has type `String`, which does not implement the `Copy` trait
+LL | let _y = vec![x];
+ | - value moved here
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | let _y = vec![x.clone()];
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:77:11
+ |
+LL | let x = vec!["hi".to_string()];
+ | - move occurs because `x` has type `Vec<String>`, which does not implement the `Copy` trait
+LL | let _y = x.into_iter().next().unwrap();
+ | ----------- `x` moved due to this method call
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+note: `into_iter` takes ownership of the receiver `self`, which moves `x`
+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | let _y = x.clone().into_iter().next().unwrap();
+ | ++++++++
+
+error[E0382]: borrow of moved value: `x`
+ --> $DIR/moves-based-on-type-exprs.rs:83:11
+ |
+LL | let x = vec!["hi".to_string()];
+ | - move occurs because `x` has type `Vec<String>`, which does not implement the `Copy` trait
+LL | let _y = [x.into_iter().next().unwrap(); 1];
+ | ----------- `x` moved due to this method call
+LL | touch(&x);
+ | ^^ value borrowed here after move
+ |
+note: `into_iter` takes ownership of the receiver `self`, which moves `x`
+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | let _y = [x.clone().into_iter().next().unwrap(); 1];
+ | ++++++++
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-match-bindings.rs b/tests/ui/moves/moves-based-on-type-match-bindings.rs
new file mode 100644
index 000000000..4fb9b40e8
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-match-bindings.rs
@@ -0,0 +1,21 @@
+// Tests that bindings to move-by-default values trigger moves of the
+// discriminant. Also tests that the compiler explains the move in
+// terms of the binding, not the discriminant.
+
+struct Foo<A> { f: A }
+fn guard(_s: String) -> bool {panic!()}
+fn touch<A>(_a: &A) {}
+
+fn f10() {
+ let x = Foo {f: "hi".to_string()};
+
+ let y = match x {
+ Foo {f} => {}
+ };
+
+ touch(&x); //~ ERROR borrow of partially moved value: `x`
+ //~^ value borrowed here after partial move
+ //~| partial move occurs because `x.f` has type `String`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-based-on-type-match-bindings.stderr b/tests/ui/moves/moves-based-on-type-match-bindings.stderr
new file mode 100644
index 000000000..225935532
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-match-bindings.stderr
@@ -0,0 +1,18 @@
+error[E0382]: borrow of partially moved value: `x`
+ --> $DIR/moves-based-on-type-match-bindings.rs:16:11
+ |
+LL | Foo {f} => {}
+ | - value partially moved here
+...
+LL | touch(&x);
+ | ^^ value borrowed here after partial move
+ |
+ = note: partial move occurs because `x.f` has type `String`, which does not implement the `Copy` trait
+help: borrow this binding in the pattern to avoid moving the value
+ |
+LL | Foo {ref f} => {}
+ | +++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.rs b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
new file mode 100644
index 000000000..490d91ac1
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
@@ -0,0 +1,10 @@
+#![feature(unboxed_closures, tuple_trait)]
+
+fn to_fn<A:std::marker::Tuple,F:Fn<A>>(f: F) -> F { f }
+
+fn test(_x: Box<usize>) {}
+
+fn main() {
+ let i = Box::new(3);
+ let _f = to_fn(|| test(i)); //~ ERROR cannot move out
+}
diff --git a/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
new file mode 100644
index 000000000..125e446c3
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-move-out-of-closure-env-issue-1965.stderr
@@ -0,0 +1,13 @@
+error[E0507]: cannot move out of `i`, a captured variable in an `Fn` closure
+ --> $DIR/moves-based-on-type-move-out-of-closure-env-issue-1965.rs:9:28
+ |
+LL | let i = Box::new(3);
+ | - captured outer variable
+LL | let _f = to_fn(|| test(i));
+ | -- ^ move occurs because `i` has type `Box<usize>`, which does not implement the `Copy` trait
+ | |
+ | captured by this `Fn` closure
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.rs b/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.rs
new file mode 100644
index 000000000..86fd37e78
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.rs
@@ -0,0 +1,35 @@
+// Tests correct kind-checking of the reason stack closures without the :Copy
+// bound must be noncopyable. For details see
+// https://smallcultfollowing.com/babysteps/blog/2013/04/30/the-case-of-the-recurring-closure/
+
+struct R<'a> {
+ // This struct is needed to create the
+ // otherwise infinite type of a fn that
+ // accepts itself as argument:
+ c: Box<dyn FnMut(&mut R, bool) + 'a>
+}
+
+fn innocent_looking_victim() {
+ let mut x = Some("hello".to_string());
+ conspirator(|f, writer| {
+ if writer {
+ x = None;
+ } else {
+ match x {
+ Some(ref msg) => {
+ (f.c)(f, true);
+ //~^ ERROR: cannot borrow `*f` as mutable more than once at a time
+ println!("{}", msg);
+ },
+ None => panic!("oops"),
+ }
+ }
+ })
+}
+
+fn conspirator<F>(mut f: F) where F: FnMut(&mut R, bool) {
+ let mut r = R {c: Box::new(f)};
+ f(&mut r, false) //~ ERROR borrow of moved value
+}
+
+fn main() { innocent_looking_victim() }
diff --git a/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.stderr b/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.stderr
new file mode 100644
index 000000000..4759b4589
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-no-recursive-stack-closure.stderr
@@ -0,0 +1,28 @@
+error[E0499]: cannot borrow `*f` as mutable more than once at a time
+ --> $DIR/moves-based-on-type-no-recursive-stack-closure.rs:20:27
+ |
+LL | (f.c)(f, true);
+ | ----- ^ second mutable borrow occurs here
+ | |
+ | first mutable borrow occurs here
+ | first borrow later used by call
+
+error[E0382]: borrow of moved value: `f`
+ --> $DIR/moves-based-on-type-no-recursive-stack-closure.rs:32:5
+ |
+LL | fn conspirator<F>(mut f: F) where F: FnMut(&mut R, bool) {
+ | ----- move occurs because `f` has type `F`, which does not implement the `Copy` trait
+LL | let mut r = R {c: Box::new(f)};
+ | - value moved here
+LL | f(&mut r, false)
+ | ^ value borrowed here after move
+ |
+help: consider mutably borrowing `f`
+ |
+LL | let mut r = R {c: Box::new(&mut f)};
+ | ++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0382, E0499.
+For more information about an error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-based-on-type-tuple.rs b/tests/ui/moves/moves-based-on-type-tuple.rs
new file mode 100644
index 000000000..2e67d8f8a
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-tuple.rs
@@ -0,0 +1,10 @@
+fn dup(x: Box<isize>) -> Box<(Box<isize>,Box<isize>)> {
+
+
+ Box::new((x, x))
+ //~^ use of moved value: `x` [E0382]
+}
+
+fn main() {
+ dup(Box::new(3));
+}
diff --git a/tests/ui/moves/moves-based-on-type-tuple.stderr b/tests/ui/moves/moves-based-on-type-tuple.stderr
new file mode 100644
index 000000000..0bcce3012
--- /dev/null
+++ b/tests/ui/moves/moves-based-on-type-tuple.stderr
@@ -0,0 +1,19 @@
+error[E0382]: use of moved value: `x`
+ --> $DIR/moves-based-on-type-tuple.rs:4:18
+ |
+LL | fn dup(x: Box<isize>) -> Box<(Box<isize>,Box<isize>)> {
+ | - move occurs because `x` has type `Box<isize>`, which does not implement the `Copy` trait
+...
+LL | Box::new((x, x))
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | Box::new((x.clone(), x))
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/moves-sru-moved-field.rs b/tests/ui/moves/moves-sru-moved-field.rs
new file mode 100644
index 000000000..72957c49f
--- /dev/null
+++ b/tests/ui/moves/moves-sru-moved-field.rs
@@ -0,0 +1,23 @@
+type Noncopyable = Box<isize>;
+
+
+
+struct Foo {
+ copied: isize,
+ moved: Box<isize>,
+ noncopyable: Noncopyable
+}
+
+fn test0(f: Foo, g: Noncopyable, h: Noncopyable) {
+ // just copy implicitly copyable fields from `f`, no moves:
+ let _b = Foo {moved: Box::new(1), noncopyable: g, ..f};
+ let _c = Foo {moved: Box::new(2), noncopyable: h, ..f};
+}
+
+fn test1(f: Foo, g: Noncopyable, h: Noncopyable) {
+ // copying move-by-default fields from `f`, so move:
+ let _b = Foo {noncopyable: g, ..f};
+ let _c = Foo {noncopyable: h, ..f}; //~ ERROR use of moved value: `f.moved`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/moves-sru-moved-field.stderr b/tests/ui/moves/moves-sru-moved-field.stderr
new file mode 100644
index 000000000..cf7213637
--- /dev/null
+++ b/tests/ui/moves/moves-sru-moved-field.stderr
@@ -0,0 +1,13 @@
+error[E0382]: use of moved value: `f.moved`
+ --> $DIR/moves-sru-moved-field.rs:20:14
+ |
+LL | let _b = Foo {noncopyable: g, ..f};
+ | ------------------------- value moved here
+LL | let _c = Foo {noncopyable: h, ..f};
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ value used here after move
+ |
+ = note: move occurs because `f.moved` has type `Box<isize>`, which does not implement the `Copy` trait
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/pin-mut-reborrow.fixed b/tests/ui/moves/pin-mut-reborrow.fixed
new file mode 100644
index 000000000..e808186d7
--- /dev/null
+++ b/tests/ui/moves/pin-mut-reborrow.fixed
@@ -0,0 +1,15 @@
+// run-rustfix
+use std::pin::Pin;
+
+struct Foo;
+
+impl Foo {
+ fn foo(self: Pin<&mut Self>) {}
+}
+
+fn main() {
+ let mut foo = Foo;
+ let mut foo = Pin::new(&mut foo);
+ foo.as_mut().foo();
+ foo.foo(); //~ ERROR use of moved value
+}
diff --git a/tests/ui/moves/pin-mut-reborrow.rs b/tests/ui/moves/pin-mut-reborrow.rs
new file mode 100644
index 000000000..fee6236eb
--- /dev/null
+++ b/tests/ui/moves/pin-mut-reborrow.rs
@@ -0,0 +1,15 @@
+// run-rustfix
+use std::pin::Pin;
+
+struct Foo;
+
+impl Foo {
+ fn foo(self: Pin<&mut Self>) {}
+}
+
+fn main() {
+ let mut foo = Foo;
+ let mut foo = Pin::new(&mut foo);
+ foo.foo();
+ foo.foo(); //~ ERROR use of moved value
+}
diff --git a/tests/ui/moves/pin-mut-reborrow.stderr b/tests/ui/moves/pin-mut-reborrow.stderr
new file mode 100644
index 000000000..16fa4bacc
--- /dev/null
+++ b/tests/ui/moves/pin-mut-reborrow.stderr
@@ -0,0 +1,23 @@
+error[E0382]: use of moved value: `foo`
+ --> $DIR/pin-mut-reborrow.rs:14:5
+ |
+LL | let mut foo = Pin::new(&mut foo);
+ | ------- move occurs because `foo` has type `Pin<&mut Foo>`, which does not implement the `Copy` trait
+LL | foo.foo();
+ | ----- `foo` moved due to this method call
+LL | foo.foo();
+ | ^^^ value used here after move
+ |
+note: `Foo::foo` takes ownership of the receiver `self`, which moves `foo`
+ --> $DIR/pin-mut-reborrow.rs:7:12
+ |
+LL | fn foo(self: Pin<&mut Self>) {}
+ | ^^^^
+help: consider reborrowing the `Pin` instead of moving it
+ |
+LL | foo.as_mut().foo();
+ | +++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/suggest-clone.fixed b/tests/ui/moves/suggest-clone.fixed
new file mode 100644
index 000000000..204bfdb10
--- /dev/null
+++ b/tests/ui/moves/suggest-clone.fixed
@@ -0,0 +1,11 @@
+// run-rustfix
+
+#[derive(Clone)]
+struct Foo;
+impl Foo {
+ fn foo(self) {}
+}
+fn main() {
+ let foo = &Foo;
+ foo.clone().foo(); //~ ERROR cannot move out
+}
diff --git a/tests/ui/moves/suggest-clone.rs b/tests/ui/moves/suggest-clone.rs
new file mode 100644
index 000000000..25dd9f006
--- /dev/null
+++ b/tests/ui/moves/suggest-clone.rs
@@ -0,0 +1,11 @@
+// run-rustfix
+
+#[derive(Clone)]
+struct Foo;
+impl Foo {
+ fn foo(self) {}
+}
+fn main() {
+ let foo = &Foo;
+ foo.foo(); //~ ERROR cannot move out
+}
diff --git a/tests/ui/moves/suggest-clone.stderr b/tests/ui/moves/suggest-clone.stderr
new file mode 100644
index 000000000..cbb3dfea3
--- /dev/null
+++ b/tests/ui/moves/suggest-clone.stderr
@@ -0,0 +1,22 @@
+error[E0507]: cannot move out of `*foo` which is behind a shared reference
+ --> $DIR/suggest-clone.rs:10:5
+ |
+LL | foo.foo();
+ | ^^^^-----
+ | | |
+ | | `*foo` moved due to this method call
+ | move occurs because `*foo` has type `Foo`, which does not implement the `Copy` trait
+ |
+note: `Foo::foo` takes ownership of the receiver `self`, which moves `*foo`
+ --> $DIR/suggest-clone.rs:6:12
+ |
+LL | fn foo(self) {}
+ | ^^^^
+help: you can `clone` the value and consume it, but this might not be your desired behavior
+ |
+LL | foo.clone().foo();
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0507`.
diff --git a/tests/ui/moves/use_of_moved_value_clone_suggestions.rs b/tests/ui/moves/use_of_moved_value_clone_suggestions.rs
new file mode 100644
index 000000000..d5c8d4e6b
--- /dev/null
+++ b/tests/ui/moves/use_of_moved_value_clone_suggestions.rs
@@ -0,0 +1,6 @@
+// `Rc` is not ever `Copy`, we should not suggest adding `T: Copy` constraint
+fn duplicate_rc<T>(t: std::rc::Rc<T>) -> (std::rc::Rc<T>, std::rc::Rc<T>) {
+ (t, t) //~ use of moved value: `t`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr b/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr
new file mode 100644
index 000000000..22e7951db
--- /dev/null
+++ b/tests/ui/moves/use_of_moved_value_clone_suggestions.stderr
@@ -0,0 +1,18 @@
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_clone_suggestions.rs:3:9
+ |
+LL | fn duplicate_rc<T>(t: std::rc::Rc<T>) -> (std::rc::Rc<T>, std::rc::Rc<T>) {
+ | - move occurs because `t` has type `Rc<T>`, which does not implement the `Copy` trait
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider cloning the value if the performance cost is acceptable
+ |
+LL | (t.clone(), t)
+ | ++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed b/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed
new file mode 100644
index 000000000..45acf5beb
--- /dev/null
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.fixed
@@ -0,0 +1,86 @@
+// run-rustfix
+#![allow(dead_code)]
+
+fn duplicate_t<T: Copy>(t: T) -> (T, T) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_opt<T: Copy>(t: Option<T>) -> (Option<T>, Option<T>) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_tup1<T: Copy>(t: (T,)) -> ((T,), (T,)) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_tup2<A: Copy, B: Copy>(t: (A, B)) -> ((A, B), (A, B)) {
+ //~^ HELP consider restricting type parameters
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+struct S<T>(T);
+trait Trait {}
+impl<T: Trait + Clone> Clone for S<T> {
+ fn clone(&self) -> Self {
+ Self(self.0.clone())
+ }
+}
+impl<T: Trait + Copy> Copy for S<T> {}
+
+trait A {}
+trait B {}
+
+// Test where bounds are added with different bound placements
+fn duplicate_custom_1<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) where {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_2<T>(t: S<T>) -> (S<T>, S<T>)
+where
+ T: A + Copy + Trait,
+ //~^ HELP consider further restricting this bound
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_3<T>(t: S<T>) -> (S<T>, S<T>)
+where
+ T: A + Copy + Trait,
+ //~^ HELP consider further restricting this bound
+ T: B,
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
+//~^ HELP consider further restricting this bound
+where
+ T: B,
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+#[rustfmt::skip]
+fn existing_colon<T: Copy>(t: T) {
+ //~^ HELP consider restricting type parameter `T`
+ [t, t]; //~ use of moved value: `t`
+}
+
+fn existing_colon_in_where<T>(t: T)
+where
+ T:, T: Copy
+ //~^ HELP consider further restricting type parameter `T`
+{
+ [t, t]; //~ use of moved value: `t`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.rs b/tests/ui/moves/use_of_moved_value_copy_suggestions.rs
new file mode 100644
index 000000000..0a43dd1a9
--- /dev/null
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.rs
@@ -0,0 +1,86 @@
+// run-rustfix
+#![allow(dead_code)]
+
+fn duplicate_t<T>(t: T) -> (T, T) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_opt<T>(t: Option<T>) -> (Option<T>, Option<T>) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_tup1<T>(t: (T,)) -> ((T,), (T,)) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_tup2<A, B>(t: (A, B)) -> ((A, B), (A, B)) {
+ //~^ HELP consider restricting type parameters
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom<T>(t: S<T>) -> (S<T>, S<T>) {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+struct S<T>(T);
+trait Trait {}
+impl<T: Trait + Clone> Clone for S<T> {
+ fn clone(&self) -> Self {
+ Self(self.0.clone())
+ }
+}
+impl<T: Trait + Copy> Copy for S<T> {}
+
+trait A {}
+trait B {}
+
+// Test where bounds are added with different bound placements
+fn duplicate_custom_1<T>(t: S<T>) -> (S<T>, S<T>) where {
+ //~^ HELP consider restricting type parameter `T`
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_2<T>(t: S<T>) -> (S<T>, S<T>)
+where
+ T: A,
+ //~^ HELP consider further restricting this bound
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_3<T>(t: S<T>) -> (S<T>, S<T>)
+where
+ T: A,
+ //~^ HELP consider further restricting this bound
+ T: B,
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+fn duplicate_custom_4<T: A>(t: S<T>) -> (S<T>, S<T>)
+//~^ HELP consider further restricting this bound
+where
+ T: B,
+{
+ (t, t) //~ use of moved value: `t`
+}
+
+#[rustfmt::skip]
+fn existing_colon<T:>(t: T) {
+ //~^ HELP consider restricting type parameter `T`
+ [t, t]; //~ use of moved value: `t`
+}
+
+fn existing_colon_in_where<T>(t: T)
+where
+ T:,
+ //~^ HELP consider further restricting type parameter `T`
+{
+ [t, t]; //~ use of moved value: `t`
+}
+
+fn main() {}
diff --git a/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
new file mode 100644
index 000000000..3e37fcb21
--- /dev/null
+++ b/tests/ui/moves/use_of_moved_value_copy_suggestions.stderr
@@ -0,0 +1,179 @@
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:6:9
+ |
+LL | fn duplicate_t<T>(t: T) -> (T, T) {
+ | - move occurs because `t` has type `T`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn duplicate_t<T: Copy>(t: T) -> (T, T) {
+ | ++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:11:9
+ |
+LL | fn duplicate_opt<T>(t: Option<T>) -> (Option<T>, Option<T>) {
+ | - move occurs because `t` has type `Option<T>`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn duplicate_opt<T: Copy>(t: Option<T>) -> (Option<T>, Option<T>) {
+ | ++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:16:9
+ |
+LL | fn duplicate_tup1<T>(t: (T,)) -> ((T,), (T,)) {
+ | - move occurs because `t` has type `(T,)`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn duplicate_tup1<T: Copy>(t: (T,)) -> ((T,), (T,)) {
+ | ++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:21:9
+ |
+LL | fn duplicate_tup2<A, B>(t: (A, B)) -> ((A, B), (A, B)) {
+ | - move occurs because `t` has type `(A, B)`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameters
+ |
+LL | fn duplicate_tup2<A: Copy, B: Copy>(t: (A, B)) -> ((A, B), (A, B)) {
+ | ++++++ ++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:26:9
+ |
+LL | fn duplicate_custom<T>(t: S<T>) -> (S<T>, S<T>) {
+ | - move occurs because `t` has type `S<T>`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn duplicate_custom<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) {
+ | ++++++++++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:44:9
+ |
+LL | fn duplicate_custom_1<T>(t: S<T>) -> (S<T>, S<T>) where {
+ | - move occurs because `t` has type `S<T>`, which does not implement the `Copy` trait
+LL |
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn duplicate_custom_1<T: Copy + Trait>(t: S<T>) -> (S<T>, S<T>) where {
+ | ++++++++++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:52:9
+ |
+LL | fn duplicate_custom_2<T>(t: S<T>) -> (S<T>, S<T>)
+ | - move occurs because `t` has type `S<T>`, which does not implement the `Copy` trait
+...
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider further restricting this bound
+ |
+LL | T: A + Copy + Trait,
+ | ++++++++++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:61:9
+ |
+LL | fn duplicate_custom_3<T>(t: S<T>) -> (S<T>, S<T>)
+ | - move occurs because `t` has type `S<T>`, which does not implement the `Copy` trait
+...
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider further restricting this bound
+ |
+LL | T: A + Copy + Trait,
+ | ++++++++++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:69:9
+ |
+LL | fn duplicate_custom_4<T: A>(t: S<T>) -> (S<T>, S<T>)
+ | - move occurs because `t` has type `S<T>`, which does not implement the `Copy` trait
+...
+LL | (t, t)
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider further restricting this bound
+ |
+LL | fn duplicate_custom_4<T: A + Copy + Trait>(t: S<T>) -> (S<T>, S<T>)
+ | ++++++++++++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:75:9
+ |
+LL | fn existing_colon<T:>(t: T) {
+ | - move occurs because `t` has type `T`, which does not implement the `Copy` trait
+LL |
+LL | [t, t];
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider restricting type parameter `T`
+ |
+LL | fn existing_colon<T: Copy>(t: T) {
+ | ++++
+
+error[E0382]: use of moved value: `t`
+ --> $DIR/use_of_moved_value_copy_suggestions.rs:83:9
+ |
+LL | fn existing_colon_in_where<T>(t: T)
+ | - move occurs because `t` has type `T`, which does not implement the `Copy` trait
+...
+LL | [t, t];
+ | - ^ value used here after move
+ | |
+ | value moved here
+ |
+help: consider further restricting type parameter `T`
+ |
+LL | T:, T: Copy
+ | ~~~~~~~~~
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0382`.