+++ /dev/null
-struct X { x: (), }
-
-impl Drop for X {
- fn drop(&mut self) {
- println!("destructor runs");
- }
-}
-
-fn main() {
- let x = Some((X { x: () }, X { x: () }));
- match x {
- Some((ref _y, _z)) => { }, //~ ERROR cannot bind by-move and by-ref in the same pattern
- None => panic!()
- }
-}
+++ /dev/null
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-2.rs:12:23
- |
-LL | Some((ref _y, _z)) => { },
- | ------ ^^ by-move pattern here
- | |
- | by-ref pattern here
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0009`.
+++ /dev/null
-struct X { x: (), }
-
-impl Drop for X {
- fn drop(&mut self) {
- println!("destructor runs");
- }
-}
-
-enum DoubleOption<T,U> { Some2(T,U), None2 }
-
-fn main() {
- let x = DoubleOption::Some2(X { x: () }, X { x: () });
- match x {
- DoubleOption::Some2(ref _y, _z) => { },
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
- DoubleOption::None2 => panic!()
- }
-}
+++ /dev/null
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-3.rs:14:37
- |
-LL | DoubleOption::Some2(ref _y, _z) => { },
- | ------ ^^ by-move pattern here
- | |
- | by-ref pattern here
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0009`.
+++ /dev/null
-struct X { x: (), }
-
-impl Drop for X {
- fn drop(&mut self) {
- println!("destructor runs");
- }
-}
-
-fn main() {
- let x = Some((X { x: () }, X { x: () }));
- match x {
- Some((_y, ref _z)) => { }, //~ ERROR cannot bind by-move and by-ref in the same pattern
- None => panic!()
- }
-}
+++ /dev/null
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-4.rs:12:15
- |
-LL | Some((_y, ref _z)) => { },
- | ^^ ------ by-ref pattern here
- | |
- | by-move pattern here
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0009`.
// edition:2018
// ignore-wasm32-bare compiled with panic=abort by default
+#![feature(move_ref_pattern)]
+
#![allow(unused)]
use std::{
a.alloc().await;
}
+async fn move_ref_pattern(a: Rc<Allocator>) {
+ let mut tup = (a.alloc().await, a.alloc().await, a.alloc().await, a.alloc().await);
+ let (ref _a, ref mut _b, _c, mut _d) = tup;
+ a.alloc().await;
+}
+
fn run_test<F, G>(cx: &mut Context<'_>, ref f: F)
where
F: Fn(Rc<Allocator>) -> G,
run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, true));
run_test(context, |a| subslice_pattern_from_end_with_drop(a, false, false));
run_test(context, |a| subslice_pattern_reassign(a));
+
+ run_test(context, |a| move_ref_pattern(a));
}
// ignore-wasm32-bare compiled with panic=abort by default
#![feature(generators, generator_trait, untagged_unions)]
+#![feature(move_ref_pattern)]
#![allow(unused_assignments)]
#![allow(unused_variables)]
}
}
+fn move_ref_pattern(a: &Allocator) {
+ let mut tup = (a.alloc(), a.alloc(), a.alloc(), a.alloc());
+ let (ref _a, ref mut _b, _c, mut _d) = tup;
+}
+
fn panic_after_return(a: &Allocator) -> Ptr<'_> {
// Panic in the drop of `p` or `q` can leak
let exceptions = vec![8, 9];
run_test(|a| subslice_mixed_min_lengths(a, 6));
run_test(|a| subslice_mixed_min_lengths(a, 7));
+ run_test(|a| move_ref_pattern(a));
+
run_test(|a| {
panic_after_return(a);
});
+++ /dev/null
-fn main() {
- struct X { x: (), }
- let x = Some((X { x: () }, X { x: () }));
- match x {
- Some((y, ref z)) => {},
- //~^ ERROR E0009
- None => panic!()
- }
-}
+++ /dev/null
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/E0009.rs:5:15
- |
-LL | Some((y, ref z)) => {},
- | ^ ----- by-ref pattern here
- | |
- | by-move pattern here
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0009`.
+++ /dev/null
-enum E {
- Foo(String, String, String),
-}
-
-struct Bar {
- a: String,
- b: String,
-}
-
-fn main() {
- let bar = Bar { a: "1".to_string(), b: "2".to_string() };
- match E::Foo("".into(), "".into(), "".into()) {
- E::Foo(a, b, ref c) => {}
-//~^ ERROR cannot bind by-move and by-ref in the same pattern
- }
- match bar {
- Bar {a, ref b} => {}
-//~^ ERROR cannot bind by-move and by-ref in the same pattern
- }
-}
+++ /dev/null
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/issue-53840.rs:13:16
- |
-LL | E::Foo(a, b, ref c) => {}
- | ^ ^ ----- by-ref pattern here
- | | |
- | | by-move pattern here
- | by-move pattern here
-
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/issue-53840.rs:17:14
- |
-LL | Bar {a, ref b} => {}
- | ^ ----- by-ref pattern here
- | |
- | by-move pattern here
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0009`.
-#![feature(slice_patterns, unsized_locals)]
+#![feature(unsized_locals)]
struct A;
#[derive(Clone, Copy)]
// where one side is by-ref and the other is by-move.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
-struct X { x: () }
+struct X {
+ x: (),
+}
fn main() {
let x = Some(X { x: () });
match x {
- Some(ref _y @ _z) => { }, //~ ERROR cannot bind by-move and by-ref in the same pattern
- None => panic!()
+ Some(ref _y @ _z) => {} //~ ERROR cannot move out of `_y` because it is borrowed
+ None => panic!(),
}
let x = Some(X { x: () });
match x {
- Some(_z @ ref _y) => { }, //~ ERROR cannot bind by-move with sub-bindings
+ Some(_z @ ref _y) => {}
//~^ ERROR borrow of moved value
- None => panic!()
+ //~| ERROR borrow of moved value
+ None => panic!(),
}
let mut x = Some(X { x: () });
match x {
- Some(ref mut _y @ _z) => { }, //~ ERROR cannot bind by-move and by-ref in the same pattern
- None => panic!()
+ Some(ref mut _y @ _z) => {} //~ ERROR cannot move out of `_y` because it is borrowed
+ None => panic!(),
}
let mut x = Some(X { x: () });
match x {
- Some(_z @ ref mut _y) => { }, //~ ERROR cannot bind by-move with sub-bindings
+ Some(_z @ ref mut _y) => {}
//~^ ERROR borrow of moved value
- None => panic!()
+ //~| ERROR borrow of moved value
+ None => panic!(),
}
}
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:12:23
+error: cannot move out of `_y` because it is borrowed
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:15:14
|
-LL | Some(ref _y @ _z) => { },
- | ---------^^
+LL | Some(ref _y @ _z) => {}
+ | ------^^^--
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `_y` occurs here
+ | borrow of `_y` occurs here
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:18:14
+error: borrow of moved value: `_z`
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:14
|
-LL | Some(_z @ ref _y) => { },
- | ^^^^^^^^^^^ binds an already bound by-move value by moving it
+LL | Some(_z @ ref _y) => {}
+ | --^^^------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `_z` has type `X` which does implement the `Copy` trait
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:25:27
+error: cannot move out of `_y` because it is borrowed
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:29:14
|
-LL | Some(ref mut _y @ _z) => { },
- | -------------^^
+LL | Some(ref mut _y @ _z) => {}
+ | ----------^^^--
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `_y` occurs here
+ | borrow of `_y` occurs here
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:31:14
+error: borrow of moved value: `_z`
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:14
|
-LL | Some(_z @ ref mut _y) => { },
- | ^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+LL | Some(_z @ ref mut _y) => {}
+ | --^^^----------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `_z` has type `X` which does implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:18:19
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:19
|
-LL | Some(_z @ ref _y) => { },
+LL | Some(_z @ ref _y) => {}
| -----^^^^^^
| | |
| | value borrowed here after move
= note: move occurs because value has type `X`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:31:19
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:19
|
-LL | Some(_z @ ref mut _y) => { },
+LL | Some(_z @ ref mut _y) => {}
| -----^^^^^^^^^^
| | |
| | value borrowed here after move
error: aborting due to 6 previous errors
-Some errors have detailed explanations: E0007, E0009, E0382.
-For more information about an error, try `rustc --explain E0007`.
+For more information about this error, try `rustc --explain E0382`.
// See issue #12534.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
fn main() {}
struct A(Box<u8>);
fn f(a @ A(u): A) -> Box<u8> {
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
drop(a);
u
}
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/bind-by-move-no-subbindings-fun-param.rs:9:6
- |
-LL | fn f(a @ A(u): A) -> Box<u8> {
- | ^^^^^^^^ binds an already bound by-move value by moving it
-
error[E0382]: use of moved value
- --> $DIR/bind-by-move-no-subbindings-fun-param.rs:9:12
+ --> $DIR/bind-by-move-no-subbindings-fun-param.rs:10:12
|
LL | fn f(a @ A(u): A) -> Box<u8> {
| ------^-
| value moved here
| move occurs because value has type `A`, which does not implement the `Copy` trait
-error: aborting due to 2 previous errors
+error: aborting due to previous error
-Some errors have detailed explanations: E0007, E0382.
-For more information about an error, try `rustc --explain E0007`.
+For more information about this error, try `rustc --explain E0382`.
// Test that moving on both sides of an `@` pattern is not allowed.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
fn main() {
struct U; // Not copy!
// Prevent promotion:
- fn u() -> U { U }
+ fn u() -> U {
+ U
+ }
- let a @ b = U;
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ let a @ b = U; //~ ERROR use of moved value
- let a @ (b, c) = (U, U);
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ let a @ (b, c) = (U, U); //~ ERROR use of moved value
- let a @ (b, c) = (u(), u());
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ let a @ (b, c) = (u(), u()); //~ ERROR use of moved value
match Ok(U) {
- a @ Ok(b) | a @ Err(b) => {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
- //~| ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ a @ Ok(b) | a @ Err(b) => {} //~ ERROR use of moved value
+ //~^ ERROR use of moved value
}
- fn fun(a @ b: U) {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ fn fun(a @ b: U) {} //~ ERROR use of moved value
match [u(), u(), u(), u()] {
- xs @ [a, .., b] => {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ xs @ [a, .., b] => {} //~ ERROR use of moved value
}
match [u(), u(), u(), u()] {
- xs @ [_, ys @ .., _] => {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ xs @ [_, ys @ .., _] => {} //~ ERROR use of moved value
}
}
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:11:9
- |
-LL | let a @ b = U;
- | ^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:15:9
- |
-LL | let a @ (b, c) = (U, U);
- | ^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:19:9
- |
-LL | let a @ (b, c) = (u(), u());
- | ^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:24:9
- |
-LL | a @ Ok(b) | a @ Err(b) => {}
- | ^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:24:21
- |
-LL | a @ Ok(b) | a @ Err(b) => {}
- | ^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:36:9
- |
-LL | xs @ [a, .., b] => {}
- | ^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:42:9
- |
-LL | xs @ [_, ys @ .., _] => {}
- | ^^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-move-and-move.rs:31:12
- |
-LL | fn fun(a @ b: U) {}
- | ^^^^^ binds an already bound by-move value by moving it
-
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:11:13
+ --> $DIR/borrowck-move-and-move.rs:14:13
|
LL | let a @ b = U;
| ----^ - move occurs because value has type `main::U`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:15:17
+ --> $DIR/borrowck-move-and-move.rs:16:17
|
LL | let a @ (b, c) = (U, U);
| --------^- ------ move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:19:17
+ --> $DIR/borrowck-move-and-move.rs:18:17
|
LL | let a @ (b, c) = (u(), u());
| --------^- ---------- move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:24:16
+ --> $DIR/borrowck-move-and-move.rs:21:16
|
LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<main::U, main::U>`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:24:29
+ --> $DIR/borrowck-move-and-move.rs:21:29
|
LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<main::U, main::U>`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:36:22
+ --> $DIR/borrowck-move-and-move.rs:28:22
|
LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[main::U; 4]`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:42:18
+ --> $DIR/borrowck-move-and-move.rs:32:18
|
LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[main::U; 4]`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:31:16
+ --> $DIR/borrowck-move-and-move.rs:25:16
|
LL | fn fun(a @ b: U) {}
| ----^
| value moved here
| move occurs because value has type `main::U`, which does not implement the `Copy` trait
-error: aborting due to 16 previous errors
+error: aborting due to 8 previous errors
-Some errors have detailed explanations: E0007, E0382.
-For more information about an error, try `rustc --explain E0007`.
+For more information about this error, try `rustc --explain E0382`.
// Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
#![feature(box_patterns)]
#[derive(Copy, Clone)]
}
_ => {}
}
+
+ match Box::new([Ok(c()), Err(nc()), Ok(c())]) {
+ box [Ok(a), ref xs @ .., Err(b)] => {}
+ _ => {}
+ }
+
+ match [Ok(Box::new(c())), Err(Box::new(nc())), Ok(Box::new(c())), Ok(Box::new(c()))] {
+ [Ok(box ref a), ref xs @ .., Err(box b), Err(box ref mut c)] => {}
+ _ => {}
+ }
}
// Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
#![feature(box_patterns)]
#[derive(Copy, Clone)]
struct C;
-fn c() -> C { C }
+fn c() -> C {
+ C
+}
struct NC;
-fn nc() -> NC { NC }
+fn nc() -> NC {
+ NC
+}
fn main() {
let a @ box &b = Box::new(&C);
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
let a @ box b = Box::new(C);
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
fn f1(a @ box &b: Box<&C>) {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
fn f2(a @ box b: Box<C>) {}
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
- match Box::new(C) { a @ box b => {} }
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ match Box::new(C) {
+ a @ box b => {} //~ ERROR use of moved value
+ }
- let ref a @ box b = Box::new(NC); //~ ERROR cannot bind by-move and by-ref in the same pattern
+ let ref a @ box b = Box::new(NC); //~ ERROR cannot move out of `a` because it is borrowed
let ref a @ box ref mut b = Box::new(nc());
//~^ ERROR cannot borrow `a` as mutable because it is also borrowed as immutable
drop(b);
}
}
-
- match Box::new([Ok(c()), Err(nc()), Ok(c())]) {
- box [Ok(a), ref xs @ .., Err(b)] => {}
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
- _ => {}
- }
-
- match [Ok(Box::new(c())), Err(Box::new(nc())), Ok(Box::new(c())), Ok(Box::new(c()))] {
- [Ok(box ref a), ref xs @ .., Err(box b), Err(box ref mut c)] => {}
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
- _ => {}
- }
}
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-at-and-box.rs:16:9
- |
-LL | let a @ box &b = Box::new(&C);
- | ^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-at-and-box.rs:20:9
- |
-LL | let a @ box b = Box::new(C);
- | ^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-at-and-box.rs:32:25
- |
-LL | match Box::new(C) { a @ box b => {} }
- | ^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/borrowck-pat-at-and-box.rs:36:21
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-at-and-box.rs:37:9
|
LL | let ref a @ box b = Box::new(NC);
- | ------------^
+ | -----^^^^^^^-
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:38:9
+ --> $DIR/borrowck-pat-at-and-box.rs:39:9
|
LL | let ref a @ box ref mut b = Box::new(nc());
| -----^^^^^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:40:9
+ --> $DIR/borrowck-pat-at-and-box.rs:41:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:42:9
+ --> $DIR/borrowck-pat-at-and-box.rs:43:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:45:9
+ --> $DIR/borrowck-pat-at-and-box.rs:46:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:51:9
+ --> $DIR/borrowck-pat-at-and-box.rs:52:9
|
LL | let ref mut a @ box ref b = Box::new(NC);
| ---------^^^^^^^-----
| mutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:65:9
+ --> $DIR/borrowck-pat-at-and-box.rs:66:9
|
LL | ref mut a @ box ref b => {
| ---------^^^^^^^-----
| | immutable borrow occurs here
| mutable borrow occurs here
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/borrowck-pat-at-and-box.rs:74:38
- |
-LL | box [Ok(a), ref xs @ .., Err(b)] => {}
- | ----------- ^ by-move pattern here
- | |
- | by-ref pattern here
-
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/borrowck-pat-at-and-box.rs:80:46
- |
-LL | [Ok(box ref a), ref xs @ .., Err(box b), Err(box ref mut c)] => {}
- | ----- ----------- ^ --------- by-ref pattern here
- | | | |
- | | | by-move pattern here
- | | by-ref pattern here
- | by-ref pattern here
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-at-and-box.rs:24:11
- |
-LL | fn f1(a @ box &b: Box<&C>) {}
- | ^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-at-and-box.rs:28:11
- |
-LL | fn f2(a @ box b: Box<C>) {}
- | ^^^^^^^^^ binds an already bound by-move value by moving it
-
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:57:11
+ --> $DIR/borrowck-pat-at-and-box.rs:58:11
|
LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ---------^^^^^^^-----
| mutable borrow occurs here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:16:18
+ --> $DIR/borrowck-pat-at-and-box.rs:21:18
|
LL | let a @ box &b = Box::new(&C);
| ---------^ ------------ move occurs because value has type `std::boxed::Box<&C>`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:20:17
+ --> $DIR/borrowck-pat-at-and-box.rs:24:17
|
LL | let a @ box b = Box::new(C);
| --------^ ----------- move occurs because value has type `std::boxed::Box<C>`, which does not implement the `Copy` trait
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:32:33
+ --> $DIR/borrowck-pat-at-and-box.rs:34:17
|
-LL | match Box::new(C) { a @ box b => {} }
- | ----------- --------^
- | | | |
- | | | value used here after move
- | | value moved here
- | move occurs because value has type `std::boxed::Box<C>`, which does not implement the `Copy` trait
+LL | match Box::new(C) {
+ | ----------- move occurs because value has type `std::boxed::Box<C>`, which does not implement the `Copy` trait
+LL | a @ box b => {}
+ | --------^
+ | | |
+ | | value used here after move
+ | value moved here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:45:21
+ --> $DIR/borrowck-pat-at-and-box.rs:46:21
|
LL | let ref a @ box ref mut b = Box::new(NC);
| ------------^^^^^^^^^
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:51:25
+ --> $DIR/borrowck-pat-at-and-box.rs:52:25
|
LL | let ref mut a @ box ref b = Box::new(NC);
| ----------------^^^^^
| -- mutable borrow later used here
error[E0502]: cannot borrow `_` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:65:25
+ --> $DIR/borrowck-pat-at-and-box.rs:66:25
|
LL | ref mut a @ box ref b => {
| ----------------^^^^^
| -- mutable borrow later used here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:24:20
+ --> $DIR/borrowck-pat-at-and-box.rs:27:20
|
LL | fn f1(a @ box &b: Box<&C>) {}
| ---------^
| move occurs because value has type `std::boxed::Box<&C>`, which does not implement the `Copy` trait
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:28:19
+ --> $DIR/borrowck-pat-at-and-box.rs:30:19
|
LL | fn f2(a @ box b: Box<C>) {}
| --------^
| move occurs because value has type `std::boxed::Box<C>`, which does not implement the `Copy` trait
error[E0502]: cannot borrow `_` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:57:27
+ --> $DIR/borrowck-pat-at-and-box.rs:58:27
|
LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ----------------^^^^^
LL | *a = Box::new(NC);
| -- mutable borrow later used here
-error: aborting due to 24 previous errors
+error: aborting due to 17 previous errors
-Some errors have detailed explanations: E0007, E0009, E0382, E0502.
-For more information about an error, try `rustc --explain E0007`.
+Some errors have detailed explanations: E0382, E0502.
+For more information about an error, try `rustc --explain E0382`.
--- /dev/null
+// Test that `by_move_binding @ pat_with_by_ref_bindings` is prevented even with promotion.
+// Currently this logic exists in HAIR match checking as opposed to borrowck.
+
+#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
+
+fn main() {
+ struct U;
+ let a @ ref b = U; //~ ERROR borrow of moved value
+}
--- /dev/null
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse-promotion.rs:9:9
+ |
+LL | let a @ ref b = U;
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `main::U` which does implement the `Copy` trait
+
+error: aborting due to previous error
+
--- /dev/null
+// Test that `by_move_binding @ pat_with_by_ref_bindings` is prevented.
+
+#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
+
+fn main() {
+ struct U;
+
+ // Prevent promotion.
+ fn u() -> U {
+ U
+ }
+
+ fn f1(a @ ref b: U) {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+
+ fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR use of moved value
+ fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+
+ let a @ ref b = U;
+ //~^ ERROR borrow of moved value
+ let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR use of moved value
+ let a @ [ref mut b, ref c] = [U, U];
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ let a @ ref b = u();
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR use of moved value
+ let a @ [ref mut b, ref c] = [u(), u()];
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+
+ match Some(U) {
+ a @ Some(ref b) => {}
+ //~^ ERROR borrow of moved value
+ None => {}
+ }
+ match Some((U, U)) {
+ a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR use of moved value
+ None => {}
+ }
+ match Some([U, U]) {
+ mut a @ Some([ref b, ref mut c]) => {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ None => {}
+ }
+ match Some(u()) {
+ a @ Some(ref b) => {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ None => {}
+ }
+ match Some((u(), u())) {
+ a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ //~| ERROR use of moved value
+ None => {}
+ }
+ match Some([u(), u()]) {
+ mut a @ Some([ref b, ref mut c]) => {}
+ //~^ ERROR borrow of moved value
+ //~| ERROR borrow of moved value
+ None => {}
+ }
+}
--- /dev/null
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:29:9
+ |
+LL | let a @ ref b = U;
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:9
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | -^^^^^^^^^^^^---------^^^^^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `(main::U, main::U)` which does implement the `Copy` trait
+
+error: borrow of moved value: `b`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:14
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | -----^^^---------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `d`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `d` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:9
+ |
+LL | let a @ [ref mut b, ref c] = [U, U];
+ | -^^^^---------^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `[main::U; 2]` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:9
+ |
+LL | let a @ ref b = u();
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:9
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | -^^^^^^^^^^^^---------^^^^^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `(main::U, main::U)` which does implement the `Copy` trait
+
+error: borrow of moved value: `b`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:14
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | -----^^^---------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `d`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `d` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:9
+ |
+LL | let a @ [ref mut b, ref c] = [u(), u()];
+ | -^^^^---------^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `[main::U; 2]` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:56:9
+ |
+LL | a @ Some(ref b) => {}
+ | -^^^^^^^^-----^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<main::U>` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:9
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<(main::U, main::U)>` which does implement the `Copy` trait
+
+error: borrow of moved value: `b`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:19
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -----^^^---------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `d`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `d` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:9
+ |
+LL | mut a @ Some([ref b, ref mut c]) => {}
+ | -----^^^^^^^^^-----^^---------^^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<[main::U; 2]>` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:9
+ |
+LL | a @ Some(ref b) => {}
+ | -^^^^^^^^-----^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<main::U>` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:9
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<(main::U, main::U)>` which does implement the `Copy` trait
+
+error: borrow of moved value: `b`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:19
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -----^^^---------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `d`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `d` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:9
+ |
+LL | mut a @ Some([ref b, ref mut c]) => {}
+ | -----^^^^^^^^^-----^^---------^^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `std::option::Option<[main::U; 2]>` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:11
+ |
+LL | fn f1(a @ ref b: U) {}
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:11
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | -----^^^^^^^^-----^^^^^^^^^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `(main::U, main::U)` which does implement the `Copy` trait
+
+error: borrow of moved value: `b`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:20
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `d`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | -----^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `d` has type `main::U` which does implement the `Copy` trait
+
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:11
+ |
+LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
+ | -^^^^---------^^-----^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `[main::U; 2]` which does implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:22
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | --------^^^^^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | ------------------------^^^^^^^^^- ------ move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
+ | | |
+ | | value used here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:37
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:25
+ |
+LL | let a @ [ref mut b, ref c] = [U, U];
+ | ----------------^^^^^- ------ move occurs because value has type `[main::U; 2]`, which does not implement the `Copy` trait
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:13
+ |
+LL | let a @ ref b = u();
+ | ----^^^^^ --- move occurs because value has type `main::U`, which does not implement the `Copy` trait
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:22
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | --------^^^^^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | ------------------------^^^^^^^^^- ---------- move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
+ | | |
+ | | value used here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:37
+ |
+LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:25
+ |
+LL | let a @ [ref mut b, ref c] = [u(), u()];
+ | ----------------^^^^^- ---------- move occurs because value has type `[main::U; 2]`, which does not implement the `Copy` trait
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:27
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | --------^^^^^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
+ |
+LL | match Some((U, U)) {
+ | ------------ move occurs because value has type `std::option::Option<(main::U, main::U)>`, which does not implement the `Copy` trait
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -----------------------------^^^^^^^^^--
+ | | |
+ | | value used here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:42
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:30
+ |
+LL | match Some([U, U]) {
+ | ------------ move occurs because value has type `std::option::Option<[main::U; 2]>`, which does not implement the `Copy` trait
+LL | mut a @ Some([ref b, ref mut c]) => {}
+ | ---------------------^^^^^^^^^--
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:18
+ |
+LL | match Some(u()) {
+ | --------- move occurs because value has type `std::option::Option<main::U>`, which does not implement the `Copy` trait
+LL | a @ Some(ref b) => {}
+ | ---------^^^^^-
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:27
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | --------^^^^^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
+ |
+LL | match Some((u(), u())) {
+ | ---------------- move occurs because value has type `std::option::Option<(main::U, main::U)>`, which does not implement the `Copy` trait
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | -----------------------------^^^^^^^^^--
+ | | |
+ | | value used here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:42
+ |
+LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:30
+ |
+LL | match Some([u(), u()]) {
+ | ---------------- move occurs because value has type `std::option::Option<[main::U; 2]>`, which does not implement the `Copy` trait
+LL | mut a @ Some([ref b, ref mut c]) => {}
+ | ---------------------^^^^^^^^^--
+ | | |
+ | | value borrowed here after move
+ | value moved here
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:15
+ |
+LL | fn f1(a @ ref b: U) {}
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:24
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | ----^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | --------------------^^^^^^^^^^^^^-
+ | | |
+ | | value used here after move
+ | value moved here
+ | move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:39
+ |
+LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
+ | --------^^^^^
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ |
+ = note: move occurs because value has type `main::U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:27
+ |
+LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
+ | ----------------^^^^^-
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because value has type `[main::U; 2]`, which does not implement the `Copy` trait
+
+error: aborting due to 48 previous errors
+
+For more information about this error, try `rustc --explain E0382`.
+// Test that `ref mut? @ pat_with_by_move_bindings` is prevented.
+
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
fn main() {
- match Some("hi".to_string()) {
- ref op_string_ref @ Some(s) => {},
- //~^ ERROR cannot bind by-move and by-ref in the same pattern [E0009]
- None => {},
+ struct U;
+
+ // Prevent promotion.
+ fn u() -> U {
+ U
+ }
+
+ fn f1(ref a @ b: U) {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR cannot move out of `b` because it is borrowed
+ //~| ERROR cannot move out of `d` because it is borrowed
+ fn f3(ref mut a @ [b, mut c]: [U; 2]) {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+
+ let ref a @ b = U;
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR cannot move out of `b` because it is borrowed
+ //~| ERROR cannot move out of `d` because it is borrowed
+ let ref mut a @ [b, mut c] = [U, U];
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ let ref a @ b = u();
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR cannot move out of `b` because it is borrowed
+ //~| ERROR cannot move out of `d` because it is borrowed
+ let ref mut a @ [b, mut c] = [u(), u()];
+ //~^ ERROR cannot move out of `a` because it is borrowed
+
+ match Some(U) {
+ ref a @ Some(b) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ None => {}
+ }
+ match Some((U, U)) {
+ ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR cannot move out of `b` because it is borrowed
+ //~| ERROR cannot move out of `d` because it is borrowed
+ None => {}
+ }
+ match Some([U, U]) {
+ ref mut a @ Some([b, mut c]) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ None => {}
+ }
+ match Some(u()) {
+ ref a @ Some(b) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ None => {}
+ }
+ match Some((u(), u())) {
+ ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR cannot move out of `b` because it is borrowed
+ //~| ERROR cannot move out of `d` because it is borrowed
+ None => {}
+ }
+ match Some([u(), u()]) {
+ ref mut a @ Some([b, mut c]) => {}
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ None => {}
}
}
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/borrowck-pat-by-move-and-ref.rs:5:34
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:23:9
|
-LL | ref op_string_ref @ Some(s) => {},
- | -------------------------^-
- | | |
- | | by-move pattern here
- | by-ref pattern here
+LL | let ref a @ b = U;
+ | -----^^^-
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
-error: aborting due to previous error
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:25:9
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
+ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:25:18
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
+ | -----^^^-----
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
+error: cannot move out of `d` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:25:33
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
+ | -----^^^-
+ | | |
+ | | move out of `d` occurs here
+ | borrow of `d` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:29:9
+ |
+LL | let ref mut a @ [b, mut c] = [U, U];
+ | ---------^^^^-^^-----^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:31:9
+ |
+LL | let ref a @ b = u();
+ | -----^^^-
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:33:9
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
+ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:33:18
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
+ | -----^^^-----
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
+error: cannot move out of `d` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:33:33
+ |
+LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
+ | -----^^^-
+ | | |
+ | | move out of `d` occurs here
+ | borrow of `d` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:37:9
+ |
+LL | let ref mut a @ [b, mut c] = [u(), u()];
+ | ---------^^^^-^^-----^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:41:9
+ |
+LL | ref a @ Some(b) => {}
+ | -----^^^^^^^^-^
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:46:9
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:46:23
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^-----
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
+error: cannot move out of `d` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:46:38
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^-
+ | | |
+ | | move out of `d` occurs here
+ | borrow of `d` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:53:9
+ |
+LL | ref mut a @ Some([b, mut c]) => {}
+ | ---------^^^^^^^^^-^^-----^^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:58:9
+ |
+LL | ref a @ Some(b) => {}
+ | -----^^^^^^^^-^
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:63:9
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:63:23
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^-----
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
+error: cannot move out of `d` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:63:38
+ |
+LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
+ | -----^^^-
+ | | |
+ | | move out of `d` occurs here
+ | borrow of `d` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:70:9
+ |
+LL | ref mut a @ Some([b, mut c]) => {}
+ | ---------^^^^^^^^^-^^-----^^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:14:11
+ |
+LL | fn f1(ref a @ b: U) {}
+ | -----^^^-
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:16:11
+ |
+LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
+ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:16:20
+ |
+LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
+ | -----^^^-----
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
+error: cannot move out of `d` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:16:35
+ |
+LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
+ | -----^^^-
+ | | |
+ | | move out of `d` occurs here
+ | borrow of `d` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:20:11
+ |
+LL | fn f3(ref mut a @ [b, mut c]: [U; 2]) {}
+ | ---------^^^^-^^-----^
+ | | | |
+ | | | move out of `a` occurs here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: aborting due to 25 previous errors
-For more information about this error, try `rustc --explain E0009`.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
enum Option<T> {
None,
//~^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable
fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
//~^ ERROR cannot borrow `a` as mutable because it is also borrowed as immutable
+ fn f4_also_moved(ref a @ ref mut b @ c: U) {}
+ //~^ ERROR cannot borrow `a` as mutable because it is also borrowed as immutable
+ //~| ERROR cannot move out of `b` because it is borrowed
let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
//~^ ERROR cannot borrow `a` as mutable more than once at a time
error: cannot borrow `z` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:9
|
LL | ref mut z @ &mut Some(ref a) => {
| ---------^^^^^^^^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:9
|
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| ---------^^^^-----------------^
| first mutable borrow occurs here
error: cannot borrow `b` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:22
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:22
|
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| -----^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:39:9
|
LL | let ref a @ ref mut b = U;
| -----^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:37:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:41:9
|
LL | let ref mut a @ ref b = U;
| ---------^^^-----
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:39:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:43:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:41:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:45:9
|
LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:44:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:9
|
LL | let ref mut a @ ref b = u();
| ---------^^^-----
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:49:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:9
|
LL | let ref a @ ref mut b = u();
| -----^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:55:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:59:9
|
LL | let ref mut a @ ref b = U;
| ---------^^^-----
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:59:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:63:9
|
LL | let ref a @ ref mut b = U;
| -----^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:65:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:65:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:74:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:74:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:85:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:85:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:92:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:92:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:99:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:99:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:107:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:107:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:115:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:119:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:120:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:127:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:132:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:136:9
|
LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:24:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:25:11
|
LL | fn f1(ref a @ ref mut b: U) {}
| -----^^^---------
| immutable borrow occurs here
error: cannot borrow `a` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:26:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:27:11
|
LL | fn f2(ref mut a @ ref b: U) {}
| ---------^^^-----
| mutable borrow occurs here
error: cannot borrow `a` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:28:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:29:11
|
LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
| -----^^^^^^^^^^^----------------^^^^^^^^
| | mutable borrow occurs here
| immutable borrow occurs here
+error: cannot borrow `a` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:22
+ |
+LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
+ | -----^^^-------------
+ | | | |
+ | | | also moved here
+ | | mutable borrow occurs here
+ | immutable borrow occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:30
+ |
+LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
+ | ---------^^^-
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
error[E0502]: cannot borrow `_` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:31
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:31
|
LL | ref mut z @ &mut Some(ref a) => {
| ----------------------^^^^^-
| ---------- mutable borrow later used here
error[E0502]: cannot borrow `_` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:44:21
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:21
|
LL | let ref mut a @ ref b = u();
| ------------^^^^^
| -------- mutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:49:17
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:17
|
LL | let ref a @ ref mut b = u();
| --------^^^^^^^^^
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:74:20
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:20
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----------^^^^^^^^^-
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:74:45
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:45
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| ------------^^^^^^^^^-
| - immutable borrow later used here
error[E0594]: cannot assign to `*b`, as it is immutable for the pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:85:61
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:61
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| ^^^^^^ cannot assign
= note: variables bound in patterns are immutable until the end of the pattern guard
error[E0594]: cannot assign to `*a`, as it is immutable for the pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:92:61
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:61
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ^^^^^^^^^^^ cannot assign
= note: variables bound in patterns are immutable until the end of the pattern guard
error[E0507]: cannot move out of `b` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:99:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut main::U`, which does not implement the `Copy` trait
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `b` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:99:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut main::U`, which does not implement the `Copy` trait
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `a` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:107:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ^ move occurs because `a` has type `&mut std::result::Result<main::U, main::U>`, which does not implement the `Copy` trait
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `a` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:107:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ^ move occurs because `a` has type `&mut std::result::Result<main::U, main::U>`, which does not implement the `Copy` trait
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:120:18
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:18
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:120:29
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:29
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^-
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:127:18
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:18
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------
| - immutable borrow later used here
error[E0502]: cannot borrow `_` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:127:29
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:29
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^-
LL | drop(a);
| - immutable borrow later used here
-error: aborting due to 45 previous errors
+error: aborting due to 47 previous errors
Some errors have detailed explanations: E0502, E0507, E0594.
For more information about an error, try `rustc --explain E0502`.
// Test that `ref mut x @ ref mut y` and varieties of that are not allowed.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
fn main() {
struct U;
[..],
] : [[U; 4]; 5]
) {}
+ fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
+ //~^ ERROR cannot borrow `a` as mutable more than once at a time
+ //~| ERROR cannot move out of `b` because it is borrowed
let ref mut a @ ref mut b = U;
//~^ ERROR cannot borrow `a` as mutable more than once at a time
) = (u(), [u(), u(), u()]);
let a @ (ref mut b, ref mut c) = (U, U);
- //~^ ERROR cannot bind by-move with sub-bindings
+ //~^ ERROR borrow of moved value
//~| ERROR borrow of moved value
let mut val = (U, [U, U]);
let a @ (b, [c, d]) = &mut val; // Same as ^--
- //~^ ERROR cannot bind by-move with sub-bindings
+ //~^ ERROR borrow of moved value
//~| ERROR borrow of moved value
let a @ &mut ref mut b = &mut U;
- //~^ ERROR cannot bind by-move with sub-bindings
+ //~^ ERROR borrow of moved value
//~| ERROR borrow of moved value
let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
- //~^ ERROR cannot bind by-move with sub-bindings
+ //~^ ERROR borrow of moved value
//~| ERROR borrow of moved value
match Ok(U) {
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:24:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:28:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:28:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:32:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:31:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:35:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:34:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:38:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:38:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:42:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:42:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:46:9
|
LL | let ref mut a @ (
| ^--------
| |_____^
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:52:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:56:9
|
LL | let ref mut a @ (
| ^--------
LL | | ) = (u(), [u(), u(), u()]);
| |_________^
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-ref-mut-twice.rs:62:9
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:66:9
|
LL | let a @ (ref mut b, ref mut c) = (U, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+ | -^^^^---------^^---------^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `(main::U, main::U)` which does implement the `Copy` trait
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-ref-mut-twice.rs:66:9
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:70:9
|
LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
- | ^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+ | -^^^^-^^^-^^-^^
+ | | | | |
+ | | | | value borrowed here after move
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `&mut (main::U, [main::U; 2])` which does implement the `Copy` trait
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-ref-mut-twice.rs:70:9
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:74:9
|
LL | let a @ &mut ref mut b = &mut U;
- | ^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+ | -^^^^^^^^---------
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `&mut main::U` which does implement the `Copy` trait
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/borrowck-pat-ref-mut-twice.rs:73:9
+error: borrow of moved value: `a`
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:77:9
|
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
+ | -^^^^^^^^^---------^^---------^
+ | | | |
+ | | | value borrowed here after move
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `a` has type `&mut (main::U, main::U)` which does implement the `Copy` trait
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:78:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:82:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:78:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:82:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:84:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:88:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:84:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:88:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:91:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:95:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:91:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:95:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:103:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:107:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:103:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:107:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:10:11
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:11:11
|
LL | fn f1(ref mut a @ ref mut b: U) {}
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:12:11
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:13:11
|
LL | fn f2(ref mut a @ ref mut b: U) {}
| ---------^^^---------
| first mutable borrow occurs here
error: cannot borrow `a` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:15:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:16:9
|
LL | ref mut a @ [
| ^--------
LL | | ] : [[U; 4]; 5]
| |_________^
+error: cannot borrow `a` as mutable more than once at a time
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:24:22
+ |
+LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
+ | ---------^^^-------------
+ | | | |
+ | | | also moved here
+ | | another mutable borrow occurs here
+ | first mutable borrow occurs here
+
+error: cannot move out of `b` because it is borrowed
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:24:34
+ |
+LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
+ | ---------^^^-
+ | | |
+ | | move out of `b` occurs here
+ | borrow of `b` occurs here
+
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:24:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:28:21
|
LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^
| - first borrow later used here
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:34:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:38:21
|
LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^
| ------ first borrow later used here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:62:25
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:66:25
|
LL | let a @ (ref mut b, ref mut c) = (U, U);
| ----------------^^^^^^^^^- ------ move occurs because value has type `(main::U, main::U)`, which does not implement the `Copy` trait
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:66:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:70:21
|
LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| ------------^-- -------- move occurs because value has type `&mut (main::U, [main::U; 2])`, which does not implement the `Copy` trait
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:70:18
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:74:18
|
LL | let a @ &mut ref mut b = &mut U;
| ---------^^^^^^^^^ ------ move occurs because value has type `&mut main::U`, which does not implement the `Copy` trait
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:73:30
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:77:30
|
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| ---------------------^^^^^^^^^- ----------- move occurs because value has type `&mut (main::U, main::U)`, which does not implement the `Copy` trait
| value moved here
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:91:24
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:95:24
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^-
| ----------- first borrow later used here
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:91:53
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:95:53
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^-
| ----------- first borrow later used here
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:103:24
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:107:24
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^-
| - first borrow later used here
error[E0499]: cannot borrow `_` as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:103:53
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:107:53
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^-
LL | drop(a);
| - first borrow later used here
-error: aborting due to 32 previous errors
+error: aborting due to 34 previous errors
-Some errors have detailed explanations: E0007, E0382, E0499.
-For more information about an error, try `rustc --explain E0007`.
+Some errors have detailed explanations: E0382, E0499.
+For more information about an error, try `rustc --explain E0382`.
// Test that mixing `Copy` and non-`Copy` types in `@` patterns is forbidden.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
#[derive(Copy, Clone)]
struct C;
fn main() {
let a @ NC(b, c) = NC(C, C);
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
+ //~^ ERROR use of moved value
let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
- //~^ ERROR cannot bind by-move with sub-bindings
- //~| ERROR use of moved value
- //~| ERROR cannot bind by-move with sub-bindings
+ //~^ ERROR use of moved value
//~| ERROR use of moved value
}
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/copy-and-move-mixed.rs:11:9
- |
-LL | let a @ NC(b, c) = NC(C, C);
- | ^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/copy-and-move-mixed.rs:15:9
- |
-LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
- | ^^^^^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/copy-and-move-mixed.rs:15:19
- |
-LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
- | ^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
error[E0382]: use of moved value
- --> $DIR/copy-and-move-mixed.rs:11:19
+ --> $DIR/copy-and-move-mixed.rs:12:19
|
LL | let a @ NC(b, c) = NC(C, C);
| ----------^- -------- move occurs because value has type `NC<C, C>`, which does not implement the `Copy` trait
|
= note: move occurs because value has type `NC<C, C>`, which does not implement the `Copy` trait
-error: aborting due to 6 previous errors
+error: aborting due to 3 previous errors
-Some errors have detailed explanations: E0007, E0382.
-For more information about an error, try `rustc --explain E0007`.
+For more information about this error, try `rustc --explain E0382`.
// this would create problems for the generalization aforementioned.
#![feature(bindings_after_at)]
+#![feature(move_ref_pattern)]
fn main() {
struct NotCopy;
let ref a @ b = &NotCopy; // OK
let _: &&NotCopy = a;
- let ref a @ b = NotCopy; //~ ERROR cannot bind by-move and by-ref in the same pattern
- let ref mut a @ b = NotCopy; //~ ERROR cannot bind by-move and by-ref in the same pattern
+ let ref a @ b = NotCopy; //~ ERROR cannot move out of `a` because it is borrowed
+ let _a: &NotCopy = a;
+ let _b: NotCopy = b;
+ let ref mut a @ b = NotCopy; //~ ERROR cannot move out of `a` because it is borrowed
+ //~^ ERROR cannot move out of `_` because it is borrowed
+ let _a: &NotCopy = a;
+ let _b: NotCopy = b;
match Ok(NotCopy) {
- Ok(ref a @ b) | Err(ref a @ b) => {}
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
+ Ok(ref a @ b) | Err(b @ ref a) => {
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ //~| ERROR borrow of moved value: `b`
+ let _a: &NotCopy = a;
+ let _b: NotCopy = b;
+ }
}
match NotCopy {
- ref a @ b => {}
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
+ ref a @ b => {
+ //~^ ERROR cannot move out of `a` because it is borrowed
+ let _a: &NotCopy = a;
+ let _b: NotCopy = b;
+ }
}
}
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/default-binding-modes-both-sides-independent.rs:27:17
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/default-binding-modes-both-sides-independent.rs:28:9
|
LL | let ref a @ b = NotCopy;
- | --------^
+ | -----^^^-
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/default-binding-modes-both-sides-independent.rs:28:21
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/default-binding-modes-both-sides-independent.rs:31:9
|
LL | let ref mut a @ b = NotCopy;
- | ------------^
+ | ---------^^^-
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/default-binding-modes-both-sides-independent.rs:36:12
+ |
+LL | Ok(ref a @ b) | Err(b @ ref a) => {
+ | -----^^^-
+ | | |
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/default-binding-modes-both-sides-independent.rs:30:20
+error: borrow of moved value: `b`
+ --> $DIR/default-binding-modes-both-sides-independent.rs:36:29
|
-LL | Ok(ref a @ b) | Err(ref a @ b) => {}
- | --------^ --------^
- | | | | |
- | | | | by-move pattern here
- | | | by-ref pattern here
- | | by-move pattern here
- | by-ref pattern here
+LL | Ok(ref a @ b) | Err(b @ ref a) => {
+ | -^^^-----
+ | | |
+ | | value borrowed here after move
+ | value moved here
+ | move occurs because `b` has type `main::NotCopy` which does implement the `Copy` trait
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/default-binding-modes-both-sides-independent.rs:34:17
+error: cannot move out of `a` because it is borrowed
+ --> $DIR/default-binding-modes-both-sides-independent.rs:44:9
|
-LL | ref a @ b => {}
- | --------^
+LL | ref a @ b => {
+ | -----^^^-
| | |
- | | by-move pattern here
- | by-ref pattern here
+ | | move out of `a` occurs here
+ | borrow of `a` occurs here
+
+error[E0505]: cannot move out of `_` because it is borrowed
+ --> $DIR/default-binding-modes-both-sides-independent.rs:31:21
+ |
+LL | let ref mut a @ b = NotCopy;
+ | ------------^
+ | | |
+ | | move out of value occurs here
+ | borrow of value occurs here
+LL |
+LL | let _a: &NotCopy = a;
+ | - borrow later used here
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
-For more information about this error, try `rustc --explain E0009`.
+For more information about this error, try `rustc --explain E0505`.
--- /dev/null
+// check-pass
+
+#![feature(move_ref_pattern)]
+
+fn main() {}
+
+struct U;
+
+fn slice() {
+ let mut arr = [U, U, U, U, U, U, U, U];
+ let [ref _x0, _x1, _, mut _x3, .., ref _x6, _x7] = arr;
+ _x3 = U;
+ let [ref mut _x0, _, ref _x2, _, _x4, ref mut _x5, _x6, _] = arr;
+ *_x5 = U;
+ let [_, _, _x2, _, _, _x5, _, _] = arr;
+ *_x0 = U;
+ let [ref _x0, ..] = arr;
+ let [_x0, ..] = arr;
+}
+
+fn tuple() {
+ let mut tup = (U, U, U, U, U);
+ let (ref _x0, mut _x1, ref _x2, ..) = tup;
+ _x1 = U;
+ let (ref mut _x0, _, _, ref _x3, _x4) = tup;
+ let (_, _, _, _x3, _) = tup;
+ *_x0 = U;
+ drop(_x2);
+ drop(tup.2);
+ let (_x0, _, _, ..) = tup;
+}
--- /dev/null
+#![feature(move_ref_pattern)]
+
+fn main() {}
+
+struct U;
+
+fn slice() {
+ let mut arr = [U, U, U, U, U];
+ let hold_all = &arr;
+ let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; //~ ERROR cannot move out of `arr[..]`
+ _x1 = U; //~ ERROR cannot assign twice to immutable variable `_x1`
+ drop(hold_all);
+ let [_x0, ..] = arr; //~ ERROR cannot move out of `arr[..]`
+ drop(_x0_hold);
+ let [_, _, ref mut _x2, _x3, mut _x4] = arr;
+ //~^ ERROR cannot borrow `arr[..]` as mutable
+ //~| ERROR cannot move out of `arr[..]` because it is borrowed
+ //~| ERROR cannot move out of `arr[..]` because it is borrowed
+ drop(xs_hold);
+}
+
+fn tuple() {
+ let mut tup = (U, U, U, U);
+ let (ref _x0, _x1, ref _x2, ..) = tup;
+ _x1 = U; //~ ERROR cannot assign twice to immutable variable
+ let _x0_hold = &mut tup.0; //~ ERROR cannot borrow `tup.0` as mutable because it is also
+ let (ref mut _x0_hold, ..) = tup; //~ ERROR cannot borrow `tup.0` as mutable because it is also
+ *_x0 = U; //~ ERROR cannot assign to `*_x0` which is behind a `&` reference
+ *_x2 = U; //~ ERROR cannot assign to `*_x2` which is behind a `&` reference
+ drop(tup.1); //~ ERROR use of moved value: `tup.1`
+ let _x1_hold = &tup.1; //~ ERROR borrow of moved value: `tup.1`
+ let (.., ref mut _x3) = tup;
+ let _x3_hold = &tup.3; //~ ERROR cannot borrow `tup.3` as immutable
+ let _x3_hold = &mut tup.3; //~ ERROR cannot borrow `tup.3` as mutable more
+ let (.., ref mut _x4_hold) = tup; //~ ERROR cannot borrow `tup.3` as mutable more
+ let (.., ref _x4_hold) = tup; //~ ERROR cannot borrow `tup.3` as immutable
+ drop(_x3);
+}
+
+fn closure() {
+ let mut tup = (U, U, U);
+ let c1 = || {
+ let (ref _x0, _x1, _) = tup;
+ };
+ let c2 = || {
+ //~^ ERROR use of moved value
+ let (ref mut _x0, _, _x2) = tup;
+ };
+ drop(c1);
+}
--- /dev/null
+error[E0505]: cannot move out of `arr[..]` because it is borrowed
+ --> $DIR/borrowck-move-ref-pattern.rs:10:24
+ |
+LL | let hold_all = &arr;
+ | ---- borrow of `arr` occurs here
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ^^^ move out of `arr[..]` occurs here
+LL | _x1 = U;
+LL | drop(hold_all);
+ | -------- borrow later used here
+
+error[E0384]: cannot assign twice to immutable variable `_x1`
+ --> $DIR/borrowck-move-ref-pattern.rs:11:5
+ |
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ---
+ | |
+ | first assignment to `_x1`
+ | help: make this binding mutable: `mut _x1`
+LL | _x1 = U;
+ | ^^^^^^^ cannot assign twice to immutable variable
+
+error[E0505]: cannot move out of `arr[..]` because it is borrowed
+ --> $DIR/borrowck-move-ref-pattern.rs:13:10
+ |
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ------------ borrow of `arr[..]` occurs here
+...
+LL | let [_x0, ..] = arr;
+ | ^^^ move out of `arr[..]` occurs here
+LL | drop(_x0_hold);
+ | -------- borrow later used here
+
+error[E0502]: cannot borrow `arr[..]` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-move-ref-pattern.rs:15:16
+ |
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ---------------- immutable borrow occurs here
+...
+LL | let [_, _, ref mut _x2, _x3, mut _x4] = arr;
+ | ^^^^^^^^^^^ mutable borrow occurs here
+...
+LL | drop(xs_hold);
+ | ------- immutable borrow later used here
+
+error[E0505]: cannot move out of `arr[..]` because it is borrowed
+ --> $DIR/borrowck-move-ref-pattern.rs:15:29
+ |
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ---------------- borrow of `arr[..]` occurs here
+...
+LL | let [_, _, ref mut _x2, _x3, mut _x4] = arr;
+ | ^^^ move out of `arr[..]` occurs here
+...
+LL | drop(xs_hold);
+ | ------- borrow later used here
+
+error[E0505]: cannot move out of `arr[..]` because it is borrowed
+ --> $DIR/borrowck-move-ref-pattern.rs:15:34
+ |
+LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
+ | ---------------- borrow of `arr[..]` occurs here
+...
+LL | let [_, _, ref mut _x2, _x3, mut _x4] = arr;
+ | ^^^^^^^ move out of `arr[..]` occurs here
+...
+LL | drop(xs_hold);
+ | ------- borrow later used here
+
+error[E0384]: cannot assign twice to immutable variable `_x1`
+ --> $DIR/borrowck-move-ref-pattern.rs:25:5
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | ---
+ | |
+ | first assignment to `_x1`
+ | help: make this binding mutable: `mut _x1`
+LL | _x1 = U;
+ | ^^^^^^^ cannot assign twice to immutable variable
+
+error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-move-ref-pattern.rs:26:20
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | ------- immutable borrow occurs here
+LL | _x1 = U;
+LL | let _x0_hold = &mut tup.0;
+ | ^^^^^^^^^^ mutable borrow occurs here
+LL | let (ref mut _x0_hold, ..) = tup;
+LL | *_x0 = U;
+ | -------- immutable borrow later used here
+
+error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-move-ref-pattern.rs:27:10
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | ------- immutable borrow occurs here
+...
+LL | let (ref mut _x0_hold, ..) = tup;
+ | ^^^^^^^^^^^^^^^^ mutable borrow occurs here
+LL | *_x0 = U;
+ | -------- immutable borrow later used here
+
+error[E0594]: cannot assign to `*_x0` which is behind a `&` reference
+ --> $DIR/borrowck-move-ref-pattern.rs:28:5
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | ------- help: consider changing this to be a mutable reference: `ref mut _x0`
+...
+LL | *_x0 = U;
+ | ^^^^^^^^ `_x0` is a `&` reference, so the data it refers to cannot be written
+
+error[E0594]: cannot assign to `*_x2` which is behind a `&` reference
+ --> $DIR/borrowck-move-ref-pattern.rs:29:5
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | ------- help: consider changing this to be a mutable reference: `ref mut _x2`
+...
+LL | *_x2 = U;
+ | ^^^^^^^^ `_x2` is a `&` reference, so the data it refers to cannot be written
+
+error[E0382]: use of moved value: `tup.1`
+ --> $DIR/borrowck-move-ref-pattern.rs:30:10
+ |
+LL | let (ref _x0, _x1, ref _x2, ..) = tup;
+ | --- value moved here
+...
+LL | drop(tup.1);
+ | ^^^^^ value used here after move
+ |
+ = note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait
+
+error[E0382]: borrow of moved value: `tup.1`
+ --> $DIR/borrowck-move-ref-pattern.rs:31:20
+ |
+LL | drop(tup.1);
+ | ----- value moved here
+LL | let _x1_hold = &tup.1;
+ | ^^^^^^ value borrowed here after move
+ |
+ = note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait
+
+error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
+ --> $DIR/borrowck-move-ref-pattern.rs:33:20
+ |
+LL | let (.., ref mut _x3) = tup;
+ | ----------- mutable borrow occurs here
+LL | let _x3_hold = &tup.3;
+ | ^^^^^^ immutable borrow occurs here
+...
+LL | drop(_x3);
+ | --- mutable borrow later used here
+
+error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
+ --> $DIR/borrowck-move-ref-pattern.rs:34:20
+ |
+LL | let (.., ref mut _x3) = tup;
+ | ----------- first mutable borrow occurs here
+LL | let _x3_hold = &tup.3;
+LL | let _x3_hold = &mut tup.3;
+ | ^^^^^^^^^^ second mutable borrow occurs here
+...
+LL | drop(_x3);
+ | --- first borrow later used here
+
+error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
+ --> $DIR/borrowck-move-ref-pattern.rs:35:14
+ |
+LL | let (.., ref mut _x3) = tup;
+ | ----------- first mutable borrow occurs here
+...
+LL | let (.., ref mut _x4_hold) = tup;
+ | ^^^^^^^^^^^^^^^^ second mutable borrow occurs here
+LL | let (.., ref _x4_hold) = tup;
+LL | drop(_x3);
+ | --- first borrow later used here
+
+error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
+ --> $DIR/borrowck-move-ref-pattern.rs:36:14
+ |
+LL | let (.., ref mut _x3) = tup;
+ | ----------- mutable borrow occurs here
+...
+LL | let (.., ref _x4_hold) = tup;
+ | ^^^^^^^^^^^^ immutable borrow occurs here
+LL | drop(_x3);
+ | --- mutable borrow later used here
+
+error[E0382]: use of moved value: `tup`
+ --> $DIR/borrowck-move-ref-pattern.rs:45:14
+ |
+LL | let mut tup = (U, U, U);
+ | ------- move occurs because `tup` has type `(U, U, U)`, which does not implement the `Copy` trait
+LL | let c1 = || {
+ | -- value moved into closure here
+LL | let (ref _x0, _x1, _) = tup;
+ | --- variable moved due to use in closure
+LL | };
+LL | let c2 = || {
+ | ^^ value used here after move
+LL |
+LL | let (ref mut _x0, _, _x2) = tup;
+ | --- use occurs due to use in closure
+
+error: aborting due to 18 previous errors
+
+Some errors have detailed explanations: E0382, E0384, E0499, E0502, E0505, E0594.
+For more information about an error, try `rustc --explain E0382`.
--- /dev/null
+fn main() {
+ #[derive(Clone)]
+ struct X {
+ x: (),
+ }
+ let mut tup = (X { x: () }, X { x: () });
+ match Some(tup.clone()) {
+ Some((y, ref z)) => {}
+ //~^ ERROR binding by-move and by-ref in the same pattern is unstable
+ None => panic!(),
+ }
+
+ let (ref a, b) = tup.clone();
+ //~^ ERROR binding by-move and by-ref in the same pattern is unstable
+
+ let (a, mut b) = &tup;
+ //~^ ERROR binding by-move and by-ref in the same pattern is unstable
+ //~| ERROR cannot move out of a shared reference
+
+ let (mut a, b) = &mut tup;
+ //~^ ERROR binding by-move and by-ref in the same pattern is unstable
+ //~| ERROR cannot move out of a mutable reference
+}
--- /dev/null
+error[E0658]: binding by-move and by-ref in the same pattern is unstable
+ --> $DIR/feature-gate-move_ref_pattern.rs:8:15
+ |
+LL | Some((y, ref z)) => {}
+ | ^ ----- by-ref pattern here
+ | |
+ | by-move pattern here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/68354
+ = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
+
+error[E0658]: binding by-move and by-ref in the same pattern is unstable
+ --> $DIR/feature-gate-move_ref_pattern.rs:13:17
+ |
+LL | let (ref a, b) = tup.clone();
+ | ----- ^ by-move pattern here
+ | |
+ | by-ref pattern here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/68354
+ = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
+
+error[E0658]: binding by-move and by-ref in the same pattern is unstable
+ --> $DIR/feature-gate-move_ref_pattern.rs:16:13
+ |
+LL | let (a, mut b) = &tup;
+ | - ^^^^^ by-move pattern here
+ | |
+ | by-ref pattern here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/68354
+ = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
+
+error[E0658]: binding by-move and by-ref in the same pattern is unstable
+ --> $DIR/feature-gate-move_ref_pattern.rs:20:10
+ |
+LL | let (mut a, b) = &mut tup;
+ | ^^^^^ - by-ref pattern here
+ | |
+ | by-move pattern here
+ |
+ = note: for more information, see https://github.com/rust-lang/rust/issues/68354
+ = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
+
+error[E0507]: cannot move out of a shared reference
+ --> $DIR/feature-gate-move_ref_pattern.rs:16:22
+ |
+LL | let (a, mut b) = &tup;
+ | ----- ^^^^
+ | |
+ | data moved here
+ | move occurs because `b` has type `main::X`, which does not implement the `Copy` trait
+
+error[E0507]: cannot move out of a mutable reference
+ --> $DIR/feature-gate-move_ref_pattern.rs:20:22
+ |
+LL | let (mut a, b) = &mut tup;
+ | ----- ^^^^^^^^
+ | |
+ | data moved here
+ | move occurs because `a` has type `main::X`, which does not implement the `Copy` trait
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0507, E0658.
+For more information about an error, try `rustc --explain E0507`.
--- /dev/null
+// check-pass
+
+#![feature(move_ref_pattern)]
+
+enum E {
+ Foo(String, String, String),
+}
+
+struct Bar {
+ a: String,
+ b: String,
+}
+
+fn main() {
+ let bar = Bar { a: "1".to_string(), b: "2".to_string() };
+ match E::Foo("".into(), "".into(), "".into()) {
+ E::Foo(a, b, ref c) => {}
+ }
+ match bar {
+ Bar { a, ref b } => {}
+ }
+}
--- /dev/null
+// check-pass
+
+#![feature(move_ref_pattern)]
+
+fn main() {
+ struct U;
+ fn accept_fn_once(_: impl FnOnce()) {}
+ fn accept_fn_mut(_: impl FnMut()) {}
+ fn accept_fn(_: impl Fn()) {}
+
+ let mut tup = (U, U, U);
+ let (ref _x0, _x1, ref mut _x2) = tup;
+ let c1 = || {
+ drop::<&U>(_x0);
+ drop::<U>(_x1);
+ drop::<&mut U>(_x2);
+ };
+ accept_fn_once(c1);
+
+ let c2 = || {
+ drop::<&U>(_x0);
+ drop::<&mut U>(_x2);
+ };
+ accept_fn_mut(c2);
+
+ let c3 = || {
+ drop::<&U>(_x0);
+ };
+ accept_fn(c3);
+}
--- /dev/null
+#![feature(move_ref_pattern)]
+
+fn main() {
+ struct U;
+ fn accept_fn_once(_: &impl FnOnce()) {}
+ fn accept_fn_mut(_: &impl FnMut()) {}
+ fn accept_fn(_: &impl Fn()) {}
+
+ let mut tup = (U, U, U);
+ let (ref _x0, _x1, ref mut _x2) = tup;
+ let c1 = || {
+ //~^ ERROR expected a closure that implements the `FnMut`
+ //~| ERROR expected a closure that implements the `Fn`
+ drop::<&U>(_x0);
+ drop::<U>(_x1);
+ drop::<&mut U>(_x2);
+ };
+ accept_fn_once(&c1);
+ accept_fn_mut(&c1);
+ accept_fn(&c1);
+
+ let c2 = || {
+ //~^ ERROR expected a closure that implements the `Fn`
+ drop::<&U>(_x0);
+ drop::<&mut U>(_x2);
+ };
+ accept_fn_mut(&c2);
+ accept_fn(&c2);
+
+ let c3 = || {
+ drop::<&U>(_x0);
+ };
+ accept_fn(&c3);
+}
--- /dev/null
+error[E0525]: expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
+ --> $DIR/move-ref-patterns-closure-captures.rs:11:14
+ |
+LL | let c1 = || {
+ | ^^ this closure implements `FnOnce`, not `FnMut`
+...
+LL | drop::<U>(_x1);
+ | --- closure is `FnOnce` because it moves the variable `_x1` out of its environment
+...
+LL | accept_fn_mut(&c1);
+ | ------------- the requirement to implement `FnMut` derives from here
+
+error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
+ --> $DIR/move-ref-patterns-closure-captures.rs:11:14
+ |
+LL | let c1 = || {
+ | ^^ this closure implements `FnOnce`, not `Fn`
+...
+LL | drop::<U>(_x1);
+ | --- closure is `FnOnce` because it moves the variable `_x1` out of its environment
+...
+LL | accept_fn(&c1);
+ | --------- the requirement to implement `Fn` derives from here
+
+error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
+ --> $DIR/move-ref-patterns-closure-captures.rs:22:14
+ |
+LL | let c2 = || {
+ | ^^ this closure implements `FnMut`, not `Fn`
+...
+LL | drop::<&mut U>(_x2);
+ | --- closure is `FnMut` because it mutates the variable `_x2` here
+...
+LL | accept_fn(&c2);
+ | --------- the requirement to implement `Fn` derives from here
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0525`.
--- /dev/null
+#![feature(move_ref_pattern)]
+
+fn main() {
+ struct U;
+
+ // A tuple is a "non-reference pattern".
+ // A `mut` binding pattern resets the binding mode to by-value.
+
+ let p = (U, U);
+ let (a, mut b) = &p;
+ //~^ ERROR cannot move out of a shared reference
+
+ let mut p = (U, U);
+ let (a, mut b) = &mut p;
+ //~^ ERROR cannot move out of a mutable reference
+}
--- /dev/null
+error[E0507]: cannot move out of a shared reference
+ --> $DIR/move-ref-patterns-default-binding-modes.rs:10:22
+ |
+LL | let (a, mut b) = &p;
+ | ----- ^^
+ | |
+ | data moved here
+ | move occurs because `b` has type `main::U`, which does not implement the `Copy` trait
+
+error[E0507]: cannot move out of a mutable reference
+ --> $DIR/move-ref-patterns-default-binding-modes.rs:14:22
+ |
+LL | let (a, mut b) = &mut p;
+ | ----- ^^^^^^
+ | |
+ | data moved here
+ | move occurs because `b` has type `main::U`, which does not implement the `Copy` trait
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0507`.
--- /dev/null
+// run-pass
+
+// This test checks the dynamic semantics and drop order of pattern matching
+// where a product pattern has both a by-move and by-ref binding.
+
+#![feature(move_ref_pattern)]
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+struct X {
+ x: Box<usize>,
+ d: DropOrderListPtr,
+}
+
+type DropOrderListPtr = Rc<RefCell<Vec<usize>>>;
+
+impl Drop for X {
+ fn drop(&mut self) {
+ self.d.borrow_mut().push(*self.x);
+ }
+}
+
+enum DoubleOption<T, U> {
+ Some2(T, U),
+ _None2,
+}
+
+fn main() {
+ let d: DropOrderListPtr = <_>::default();
+ {
+ let mk = |v| X { x: Box::new(v), d: d.clone() };
+ let check = |a1: &X, a2, b1: &X, b2| {
+ assert_eq!(*a1.x, a2);
+ assert_eq!(*b1.x, b2);
+ };
+
+ let x = DoubleOption::Some2(mk(1), mk(2));
+ match x {
+ DoubleOption::Some2(ref a, b) => check(a, 1, &b, 2),
+ DoubleOption::_None2 => panic!(),
+ }
+ let x = DoubleOption::Some2(mk(3), mk(4));
+ match x {
+ DoubleOption::Some2(a, ref b) => check(&a, 3, b, 4),
+ DoubleOption::_None2 => panic!(),
+ }
+ match DoubleOption::Some2(mk(5), mk(6)) {
+ DoubleOption::Some2(ref a, b) => check(a, 5, &b, 6),
+ DoubleOption::_None2 => panic!(),
+ }
+ match DoubleOption::Some2(mk(7), mk(8)) {
+ DoubleOption::Some2(a, ref b) => check(&a, 7, b, 8),
+ DoubleOption::_None2 => panic!(),
+ }
+ {
+ let (a, ref b) = (mk(9), mk(10));
+ let (ref c, d) = (mk(11), mk(12));
+ check(&a, 9, b, 10);
+ check(c, 11, &d, 12);
+ }
+ fn fun([a, ref mut b, ref xs @ .., ref c, d]: [X; 6]) {
+ assert_eq!(*a.x, 13);
+ assert_eq!(*b.x, 14);
+ assert_eq!(&[*xs[0].x, *xs[1].x], &[15, 16]);
+ assert_eq!(*c.x, 17);
+ assert_eq!(*d.x, 18);
+ }
+ fun([mk(13), mk(14), mk(15), mk(16), mk(17), mk(18)]);
+
+ let lam = |(a, ref b, c, ref mut d): (X, X, X, X)| {
+ assert_eq!(*a.x, 19);
+ assert_eq!(*b.x, 20);
+ assert_eq!(*c.x, 21);
+ assert_eq!(*d.x, 22);
+ };
+ lam((mk(19), mk(20), mk(21), mk(22)));
+ }
+ let expected = [2, 3, 6, 5, 7, 8, 12, 11, 9, 10, 18, 13, 14, 15, 16, 17, 21, 19, 20, 22, 4, 1];
+ assert_eq!(&*d.borrow(), &expected);
+}
// outside of slice (+ ident patterns witin those), tuple,
// and tuple struct patterns and that duplicates are caught in these contexts.
-#![feature(slice_patterns, box_patterns)]
+#![feature(box_patterns)]
fn main() {}
+#![feature(move_ref_pattern)]
+
struct Foo {}
pub fn main() {
- let mut tups = vec![(Foo{}, Foo{})];
+ let mut tups = vec![(Foo {}, Foo {})];
// The below desugars to &(ref n, mut m).
for (n, mut m) in &tups {
- //~^ ERROR cannot bind by-move and by-ref in the same pattern
- //~| ERROR cannot move out of a shared reference
+ //~^ ERROR cannot move out of a shared reference
}
}
-error[E0009]: cannot bind by-move and by-ref in the same pattern
- --> $DIR/for.rs:6:13
- |
-LL | for (n, mut m) in &tups {
- | - ^^^^^ by-move pattern here
- | |
- | by-ref pattern here
-
error[E0507]: cannot move out of a shared reference
- --> $DIR/for.rs:6:23
+ --> $DIR/for.rs:8:23
|
LL | for (n, mut m) in &tups {
| ----- ^^^^^
| data moved here
| move occurs because `m` has type `Foo`, which does not implement the `Copy` trait
-error: aborting due to 2 previous errors
+error: aborting due to previous error
-Some errors have detailed explanations: E0009, E0507.
-For more information about an error, try `rustc --explain E0009`.
+For more information about this error, try `rustc --explain E0507`.
projects / rust.git / commitdiff