bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #76119 - Amjad50:stabilizing-move_ref_pattern, r=nikomatsakis

Browse source 
Stabilize move_ref_pattern

# Implementation
- Initially the rule was added in the run-up to 1.0. The AST-based borrow checker was having difficulty correctly enforcing match expressions that combined ref and move bindings, and so it was decided to simplify forbid the combination out right.
- The move to MIR-based borrow checking made it possible to enforce the rules in a finer-grained level, but we kept the rule in place in an effort to be conservative in our changes.
- In #68376, @Centril lifted the restriction but required a feature-gate.
- This PR removes the feature-gate.

Tracking issue: #68354.

# Description
This PR is to stabilize the feature `move_ref_pattern`, which allows patterns
containing both `by-ref` and `by-move` bindings at the same time.

For example: `Foo(ref x, y)`, where `x` is `by-ref`,
and `y` is `by-move`.

The rules of moving a variable also apply here when moving *part* of a variable,
such as it can't be referenced or moved before.

If this pattern is used, it would result in *partial move*, which means that
part of the variable is moved. The variable that was partially moved from
cannot be used as a whole in this case, only the parts that are still
not moved can be used.

## Documentation
- The reference (rust-lang/reference#881)
- Rust by example (rust-lang/rust-by-example#1377)

## Tests
There are many tests, but I think one of the comperhensive ones:
- [borrowck-move-ref-pattern-pass.rs](85fbf49ce0/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs)
- [borrowck-move-ref-pattern.rs](85fbf49ce0/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs)

# Examples

```rust
#[derive(PartialEq, Eq)]
struct Finished {}

#[derive(PartialEq, Eq)]
struct Processing {
    status: ProcessStatus,
}

#[derive(PartialEq, Eq)]
enum ProcessStatus {
    One,
    Two,
    Three,
}

#[derive(PartialEq, Eq)]
enum Status {
    Finished(Finished),
    Processing(Processing),
}

fn check_result(_url: &str) -> Status {
    // fetch status from some server
    Status::Processing(Processing {
        status: ProcessStatus::One,
    })
}

fn wait_for_result(url: &str) -> Finished {
    let mut previous_status = None;
    loop {
        match check_result(url) {
            Status::Finished(f) => return f,
            Status::Processing(p) => {
                match (&mut previous_status, p.status) {
                    (None, status) => previous_status = Some(status), // first status
                    (Some(previous), status) if *previous == status => {} // no change, ignore
                    (Some(previous), status) => { // Now it can be used
                        // new status
                        *previous = status;
                    }
                }
            }
        }
    }
}
```

Before, we would have used:
```rust
                match (&previous_status, p.status) {
                    (Some(previous), status) if *previous == status => {} // no change, ignore
                    (_, status) => {
                        // new status
                        previous_status = Some(status);
                    }
                }
```

Demonstrating *partial move*
```rust
fn main() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: u8,
    }

    let person = Person {
        name: String::from("Alice"),
        age: 20,
    };

    // `name` is moved out of person, but `age` is referenced
    let Person { name, ref age } = person;

    println!("The person's age is {}", age);

    println!("The person's name is {}", name);

    // Error! borrow of partially moved value: `person` partial move occurs
    //println!("The person struct is {:?}", person);

    // `person` cannot be used but `person.age` can be used as it is not moved
    println!("The person's age from person struct is {}", person.age);
}
```
This commit is contained in:
Dylan DPC 2020-10-16 02:10:07 +02:00 • committed by GitHub
commit 85dbb03490
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
50 changed files with 277 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

8
compiler/rustc_error_codes/src/error_codes/E0007.md
View file

@ -1,3 +1,5 @@
#### Note: this error code is no longer emitted by the compiler.
This error indicates that the bindings in a match arm would require a value to This error indicates that the bindings in a match arm would require a value to
be moved into more than one location, thus violating unique ownership. Code be moved into more than one location, thus violating unique ownership. Code
like the following is invalid as it requires the entire `Option<String>` to be like the following is invalid as it requires the entire `Option<String>` to be
@ -6,11 +8,13 @@ inner `String` to be moved into a variable called `s`.
Erroneous code example: Erroneous code example:
```compile_fail,E0007 ```compile_fail,E0382
#![feature(bindings_after_at)]
let x = Some("s".to_string()); let x = Some("s".to_string());
match x { match x {
op_string @ Some(s) => {}, // error: cannot bind by-move with sub-bindings op_string @ Some(s) => {}, // error: use of moved value
None => {}, None => {},
} }
``` ```

3
compiler/rustc_feature/src/accepted.rs
View file

@ -270,6 +270,9 @@ declare_features! (
(accepted, track_caller, "1.46.0", Some(47809), None), (accepted, track_caller, "1.46.0", Some(47809), None),
/// Allows `#[doc(alias = "...")]`. /// Allows `#[doc(alias = "...")]`.
(accepted, doc_alias, "1.48.0", Some(50146), None), (accepted, doc_alias, "1.48.0", Some(50146), None),
/// Allows patterns with concurrent by-move and by-ref bindings.
/// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
(accepted, move_ref_pattern, "1.48.0", Some(68354), None),
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// feature-group-end: accepted features // feature-group-end: accepted features

4
compiler/rustc_feature/src/active.rs
View file

@ -526,10 +526,6 @@ declare_features! (
/// For example, you can write `x @ Some(y)`. /// For example, you can write `x @ Some(y)`.
(active, bindings_after_at, "1.41.0", Some(65490), None), (active, bindings_after_at, "1.41.0", Some(65490), None),
/// Allows patterns with concurrent by-move and by-ref bindings.
/// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
(active, move_ref_pattern, "1.42.0", Some(68354), None),
/// Allows `impl const Trait for T` syntax. /// Allows `impl const Trait for T` syntax.
(active, const_trait_impl, "1.42.0", Some(67792), None), (active, const_trait_impl, "1.42.0", Some(67792), None),

70
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

@ -71,13 +71,13 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
hir::LocalSource::AwaitDesugar => ("`await` future binding", None), hir::LocalSource::AwaitDesugar => ("`await` future binding", None),
}; };
self.check_irrefutable(&loc.pat, msg, sp); self.check_irrefutable(&loc.pat, msg, sp);
self.check_patterns(false, &loc.pat); self.check_patterns(&loc.pat);
} }
fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) { fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
intravisit::walk_param(self, param); intravisit::walk_param(self, param);
self.check_irrefutable(&param.pat, "function argument", None); self.check_irrefutable(&param.pat, "function argument", None);
self.check_patterns(false, &param.pat); self.check_patterns(&param.pat);
} }
} }
@ -119,10 +119,7 @@ impl PatCtxt<'_, '_> {
} }
impl<'tcx> MatchVisitor<'_, 'tcx> { impl<'tcx> MatchVisitor<'_, 'tcx> {
fn check_patterns(&mut self, has_guard: bool, pat: &Pat<'_>) { fn check_patterns(&mut self, pat: &Pat<'_>) {
if !self.tcx.features().move_ref_pattern {
check_legality_of_move_bindings(self, has_guard, pat);
}
pat.walk_always(|pat| check_borrow_conflicts_in_at_patterns(self, pat)); pat.walk_always(|pat| check_borrow_conflicts_in_at_patterns(self, pat));
if !self.tcx.features().bindings_after_at { if !self.tcx.features().bindings_after_at {
check_legality_of_bindings_in_at_patterns(self, pat); check_legality_of_bindings_in_at_patterns(self, pat);
@ -165,7 +162,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
) { ) {
for arm in arms { for arm in arms {
// Check the arm for some things unrelated to exhaustiveness. // Check the arm for some things unrelated to exhaustiveness.
self.check_patterns(arm.guard.is_some(), &arm.pat); self.check_patterns(&arm.pat);
} }
let mut cx = self.new_cx(scrut.hir_id); let mut cx = self.new_cx(scrut.hir_id);
@ -601,65 +598,6 @@ fn is_binding_by_move(cx: &MatchVisitor<'_, '_>, hir_id: HirId, span: Span) -> b
!cx.typeck_results.node_type(hir_id).is_copy_modulo_regions(cx.tcx.at(span), cx.param_env) !cx.typeck_results.node_type(hir_id).is_copy_modulo_regions(cx.tcx.at(span), cx.param_env)
} }
/// Check the legality of legality of by-move bindings.
fn check_legality_of_move_bindings(cx: &mut MatchVisitor<'_, '_>, has_guard: bool, pat: &Pat<'_>) {
let sess = cx.tcx.sess;
let typeck_results = cx.typeck_results;
// Find all by-ref spans.
let mut by_ref_spans = Vec::new();
pat.each_binding(|_, hir_id, span, _| {
if let Some(ty::BindByReference(_)) =
typeck_results.extract_binding_mode(sess, hir_id, span)
{
by_ref_spans.push(span);
}
});
// Find bad by-move spans:
let by_move_spans = &mut Vec::new();
let mut check_move = |p: &Pat<'_>, sub: Option<&Pat<'_>>| {
// Check legality of moving out of the enum.
//
// `x @ Foo(..)` is legal, but `x @ Foo(y)` isn't.
if sub.map_or(false, |p| p.contains_bindings()) {
struct_span_err!(sess, p.span, E0007, "cannot bind by-move with sub-bindings")
.span_label(p.span, "binds an already bound by-move value by moving it")
.emit();
} else if !has_guard && !by_ref_spans.is_empty() {
by_move_spans.push(p.span);
}
};
pat.walk_always(|p| {
if let hir::PatKind::Binding(.., sub) = &p.kind {
if let Some(ty::BindByValue(_)) =
typeck_results.extract_binding_mode(sess, p.hir_id, p.span)
{
if is_binding_by_move(cx, p.hir_id, p.span) {
check_move(p, sub.as_deref());
}
}
}
});
// Found some bad by-move spans, error!
if !by_move_spans.is_empty() {
let mut err = feature_err(
&sess.parse_sess,
sym::move_ref_pattern,
by_move_spans.clone(),
"binding by-move and by-ref in the same pattern is unstable",
);
for span in by_ref_spans.iter() {
err.span_label(*span, "by-ref pattern here");
}
for span in by_move_spans.iter() {
err.span_label(*span, "by-move pattern here");
}
err.emit();
}
}
/// Check that there are no borrow or move conflicts in `binding @ subpat` patterns. /// Check that there are no borrow or move conflicts in `binding @ subpat` patterns.
/// ///
/// For example, this would reject: /// For example, this would reject:

2
src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs
View file

@ -3,8 +3,6 @@
#![feature(or_patterns)] #![feature(or_patterns)]
#![feature(box_patterns)] #![feature(box_patterns)]
#![feature(move_ref_pattern)]
enum Test { enum Test {
Foo, Foo,
Bar, Bar,

34
src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.stderr
View file

@ -1,5 +1,5 @@
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:40:9 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:38:9
| |
LL | ref foo @ [.., ref mut bar] => (), LL | ref foo @ [.., ref mut bar] => (),
| -------^^^^^^^^-----------^ | -------^^^^^^^^-----------^
@ -8,7 +8,7 @@ LL | ref foo @ [.., ref mut bar] => (),
| immutable borrow, by `foo`, occurs here | immutable borrow, by `foo`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:124:9 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:122:9
| |
LL | ref foo @ Some(box ref mut s) => (), LL | ref foo @ Some(box ref mut s) => (),
| -------^^^^^^^^^^^^---------^ | -------^^^^^^^^^^^^---------^
@ -17,7 +17,7 @@ LL | ref foo @ Some(box ref mut s) => (),
| immutable borrow, by `foo`, occurs here | immutable borrow, by `foo`, occurs here
error[E0382]: borrow of moved value: `x` error[E0382]: borrow of moved value: `x`
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:22:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:20:5
| |
LL | fn bindings_after_at_slice_patterns_move_binding(x: [String; 4]) { LL | fn bindings_after_at_slice_patterns_move_binding(x: [String; 4]) {
| - move occurs because `x` has type `[String; 4]`, which does not implement the `Copy` trait | - move occurs because `x` has type `[String; 4]`, which does not implement the `Copy` trait
@ -29,7 +29,7 @@ LL | &x;
| ^^ value borrowed here after move | ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:32:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:30:5
| |
LL | ref mut foo @ [.., _] => Some(foo), LL | ref mut foo @ [.., _] => Some(foo),
| --------------------- mutable borrow occurs here | --------------------- mutable borrow occurs here
@ -41,7 +41,7 @@ LL | drop(r);
| - mutable borrow later used here | - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:54:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:52:5
| |
LL | [ref foo @ .., ref bar] => Some(foo), LL | [ref foo @ .., ref bar] => Some(foo),
| ------------ immutable borrow occurs here | ------------ immutable borrow occurs here
@ -53,7 +53,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:66:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:64:5
| |
LL | ref foo @ [.., ref bar] => Some(foo), LL | ref foo @ [.., ref bar] => Some(foo),
| ----------------------- immutable borrow occurs here | ----------------------- immutable borrow occurs here
@ -65,7 +65,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0382]: borrow of moved value: `x` error[E0382]: borrow of moved value: `x`
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:80:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:78:5
| |
LL | fn bindings_after_at_or_patterns_move(x: Option<Test>) { LL | fn bindings_after_at_or_patterns_move(x: Option<Test>) {
| - move occurs because `x` has type `Option<Test>`, which does not implement the `Copy` trait | - move occurs because `x` has type `Option<Test>`, which does not implement the `Copy` trait
@ -80,7 +80,7 @@ LL | &x;
| ^^ value borrowed here after move | ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:90:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:88:5
| |
LL | ref foo @ Some(Test::Foo | Test::Bar) => Some(foo), LL | ref foo @ Some(Test::Foo | Test::Bar) => Some(foo),
| ------------------------------------- immutable borrow occurs here | ------------------------------------- immutable borrow occurs here
@ -92,7 +92,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:102:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:100:5
| |
LL | ref mut foo @ Some(Test::Foo | Test::Bar) => Some(foo), LL | ref mut foo @ Some(Test::Foo | Test::Bar) => Some(foo),
| ----------------------------------------- mutable borrow occurs here | ----------------------------------------- mutable borrow occurs here
@ -104,7 +104,7 @@ LL | drop(r);
| - mutable borrow later used here | - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:116:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:114:5
| |
LL | ref foo @ Some(box ref s) => Some(foo), LL | ref foo @ Some(box ref s) => Some(foo),
| ------------------------- immutable borrow occurs here | ------------------------- immutable borrow occurs here
@ -116,7 +116,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0382]: borrow of moved value: `x` error[E0382]: borrow of moved value: `x`
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:138:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:136:5
| |
LL | fn bindings_after_at_slice_patterns_or_patterns_moves(x: [Option<Test>; 4]) { LL | fn bindings_after_at_slice_patterns_or_patterns_moves(x: [Option<Test>; 4]) {
| - move occurs because `x` has type `[Option<Test>; 4]`, which does not implement the `Copy` trait | - move occurs because `x` has type `[Option<Test>; 4]`, which does not implement the `Copy` trait
@ -131,7 +131,7 @@ LL | &x;
| ^^ value borrowed here after move | ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:148:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:146:5
| |
LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(a), LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(a),
| ------------------------------------------------- immutable borrow occurs here | ------------------------------------------------- immutable borrow occurs here
@ -143,7 +143,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:160:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:158:5
| |
LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(b), LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(b),
| ---------- immutable borrow occurs here | ---------- immutable borrow occurs here
@ -155,7 +155,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:174:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:172:5
| |
LL | [_, ref a @ Some(box ref b), ..] => Some(a), LL | [_, ref a @ Some(box ref b), ..] => Some(a),
| ----------------------- immutable borrow occurs here | ----------------------- immutable borrow occurs here
@ -167,7 +167,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:190:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:188:5
| |
LL | [_, ref a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a), LL | [_, ref a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ------------------------------------------- immutable borrow occurs here | ------------------------------------------- immutable borrow occurs here
@ -179,7 +179,7 @@ LL | drop(r);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:204:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:202:5
| |
LL | [_, ref mut a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a), LL | [_, ref mut a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ----------------------------------------------- mutable borrow occurs here | ----------------------------------------------- mutable borrow occurs here
@ -191,7 +191,7 @@ LL | drop(r);
| - mutable borrow later used here | - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
--> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:218:5 --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:216:5
| |
LL | ref a @ [_, ref b @ Some(box Test::Foo | box Test::Bar), ..] => Some(a), LL | ref a @ [_, ref b @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ------------------------------------------------------------ immutable borrow occurs here | ------------------------------------------------------------ immutable borrow occurs here

2
src/test/ui/drop/dynamic-drop-async.rs
View file

@ -7,8 +7,6 @@
// edition:2018 // edition:2018
// ignore-wasm32-bare compiled with panic=abort by default // ignore-wasm32-bare compiled with panic=abort by default
#![feature(move_ref_pattern)]
#![allow(unused)] #![allow(unused)]
use std::{ use std::{

1
src/test/ui/drop/dynamic-drop.rs
View file

@ -2,7 +2,6 @@
// ignore-wasm32-bare compiled with panic=abort by default // ignore-wasm32-bare compiled with panic=abort by default
#![feature(generators, generator_trait, untagged_unions)] #![feature(generators, generator_trait, untagged_unions)]
#![feature(move_ref_pattern)]
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![allow(unused_assignments)] #![allow(unused_assignments)]

11
src/test/ui/error-codes/E0007.rs
View file

@ -1,11 +0,0 @@
#![feature(bindings_after_at)]
fn main() {
let x = Some("s".to_string());
match x {
op_string @ Some(s) => {},
//~^ ERROR E0007
//~| ERROR E0382
None => {},
}
}

22
src/test/ui/error-codes/E0007.stderr
View file

@ -1,22 +0,0 @@
error[E0007]: cannot bind by-move with sub-bindings
--> $DIR/E0007.rs:6:9
|
LL | op_string @ Some(s) => {},
| ^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
error[E0382]: use of moved value
--> $DIR/E0007.rs:6:26
|
LL | let x = Some("s".to_string());
| - move occurs because `x` has type `Option<String>`, which does not implement the `Copy` trait
LL | match x {
LL | op_string @ Some(s) => {},
| -----------------^-
| | |
| | value used here after move
| value moved here
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0007, E0382.
For more information about an error, try `rustc --explain E0007`.

1
src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.rs
View file

@ -3,7 +3,6 @@
// where one side is by-ref and the other is by-move. // where one side is by-ref and the other is by-move.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
struct X { struct X {
x: (), x: (),

12
src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.stderr
View file

@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:15:14 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:14:14
| |
LL | Some(ref _y @ _z) => {} LL | Some(ref _y @ _z) => {}
| ------^^^-- | ------^^^--
@ -8,7 +8,7 @@ LL | Some(ref _y @ _z) => {}
| value borrowed, by `_y`, here | value borrowed, by `_y`, here
error: borrow of moved value error: borrow of moved value
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:14 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:20:14
| |
LL | Some(_z @ ref _y) => {} LL | Some(_z @ ref _y) => {}
| --^^^------ | --^^^------
@ -18,7 +18,7 @@ LL | Some(_z @ ref _y) => {}
| move occurs because `_z` has type `X` which does not implement the `Copy` trait | move occurs because `_z` has type `X` which does not implement the `Copy` trait
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:29:14 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:28:14
| |
LL | Some(ref mut _y @ _z) => {} LL | Some(ref mut _y @ _z) => {}
| ----------^^^-- | ----------^^^--
@ -27,7 +27,7 @@ LL | Some(ref mut _y @ _z) => {}
| value borrowed, by `_y`, here | value borrowed, by `_y`, here
error: borrow of moved value error: borrow of moved value
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:14 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:34:14
| |
LL | Some(_z @ ref mut _y) => {} LL | Some(_z @ ref mut _y) => {}
| --^^^---------- | --^^^----------
@ -37,7 +37,7 @@ LL | Some(_z @ ref mut _y) => {}
| move occurs because `_z` has type `X` which does not implement the `Copy` trait | move occurs because `_z` has type `X` which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:19 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:20:19
| |
LL | Some(_z @ ref _y) => {} LL | Some(_z @ ref _y) => {}
| -----^^^^^^ | -----^^^^^^
@ -52,7 +52,7 @@ LL | Some(ref _z @ ref _y) => {}
| ^^^ | ^^^
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:19 --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:34:19
| |
LL | Some(_z @ ref mut _y) => {} LL | Some(_z @ ref mut _y) => {}
| -----^^^^^^^^^^ | -----^^^^^^^^^^

1
src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.rs
View file

@ -1,7 +1,6 @@
// See issue #12534. // See issue #12534.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() {} fn main() {}

2
src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
View file

@ -1,5 +1,5 @@
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/bind-by-move-no-subbindings-fun-param.rs:10:12 --> $DIR/bind-by-move-no-subbindings-fun-param.rs:9:12
| |
LL | fn f(a @ A(u): A) -> Box<u8> { LL | fn f(a @ A(u): A) -> Box<u8> {
| ------^- | ------^-

1
src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.rs
View file

@ -1,7 +1,6 @@
// Test that moving on both sides of an `@` pattern is not allowed. // Test that moving on both sides of an `@` pattern is not allowed.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; // Not copy! struct U; // Not copy!

16
src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr
View file

@ -1,5 +1,5 @@
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:14:13 --> $DIR/borrowck-move-and-move.rs:13:13
| |
LL | let a @ b = U; LL | let a @ b = U;
| ----^ - move occurs because value has type `U`, which does not implement the `Copy` trait | ----^ - move occurs because value has type `U`, which does not implement the `Copy` trait
@ -8,7 +8,7 @@ LL | let a @ b = U;
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:16:17 --> $DIR/borrowck-move-and-move.rs:15:17
| |
LL | let a @ (b, c) = (U, U); LL | let a @ (b, c) = (U, U);
| --------^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | --------^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@ -17,7 +17,7 @@ LL | let a @ (b, c) = (U, U);
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:18:17 --> $DIR/borrowck-move-and-move.rs:17:17
| |
LL | let a @ (b, c) = (u(), u()); LL | let a @ (b, c) = (u(), u());
| --------^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | --------^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@ -26,7 +26,7 @@ LL | let a @ (b, c) = (u(), u());
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:21:16 --> $DIR/borrowck-move-and-move.rs:20:16
| |
LL | match Ok(U) { LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait | ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait
@ -37,7 +37,7 @@ LL | a @ Ok(b) | a @ Err(b) => {}
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:21:29 --> $DIR/borrowck-move-and-move.rs:20:29
| |
LL | match Ok(U) { LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait | ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait
@ -48,7 +48,7 @@ LL | a @ Ok(b) | a @ Err(b) => {}
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:28:22 --> $DIR/borrowck-move-and-move.rs:27:22
| |
LL | match [u(), u(), u(), u()] { LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait | -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait
@ -59,7 +59,7 @@ LL | xs @ [a, .., b] => {}
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:32:18 --> $DIR/borrowck-move-and-move.rs:31:18
| |
LL | match [u(), u(), u(), u()] { LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait | -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait
@ -70,7 +70,7 @@ LL | xs @ [_, ys @ .., _] => {}
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-move-and-move.rs:25:16 --> $DIR/borrowck-move-and-move.rs:24:16
| |
LL | fn fun(a @ b: U) {} LL | fn fun(a @ b: U) {}
| ----^ | ----^

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box-pass.rs
View file

@ -3,7 +3,6 @@
// Test `@` patterns combined with `box` patterns. // Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
#![feature(box_patterns)] #![feature(box_patterns)]
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.rs
View file

@ -1,7 +1,6 @@
// Test `@` patterns combined with `box` patterns. // Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
#![feature(box_patterns)] #![feature(box_patterns)]
#[derive(Copy, Clone)] #[derive(Copy, Clone)]

34
src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.stderr
View file

@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-at-and-box.rs:37:9 --> $DIR/borrowck-pat-at-and-box.rs:36:9
| |
LL | let ref a @ box b = Box::new(NC); LL | let ref a @ box b = Box::new(NC);
| -----^^^^^^^- | -----^^^^^^^-
@ -8,7 +8,7 @@ LL | let ref a @ box b = Box::new(NC);
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-at-and-box.rs:39:9 --> $DIR/borrowck-pat-at-and-box.rs:38:9
| |
LL | let ref a @ box ref mut b = Box::new(nc()); LL | let ref a @ box ref mut b = Box::new(nc());
| -----^^^^^^^--------- | -----^^^^^^^---------
@ -17,7 +17,7 @@ LL | let ref a @ box ref mut b = Box::new(nc());
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-at-and-box.rs:41:9 --> $DIR/borrowck-pat-at-and-box.rs:40:9
| |
LL | let ref a @ box ref mut b = Box::new(NC); LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^--------- | -----^^^^^^^---------
@ -26,7 +26,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-at-and-box.rs:43:9 --> $DIR/borrowck-pat-at-and-box.rs:42:9
| |
LL | let ref a @ box ref mut b = Box::new(NC); LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^--------- | -----^^^^^^^---------
@ -35,7 +35,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-at-and-box.rs:46:9 --> $DIR/borrowck-pat-at-and-box.rs:45:9
| |
LL | let ref a @ box ref mut b = Box::new(NC); LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^--------- | -----^^^^^^^---------
@ -44,7 +44,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:52:9 --> $DIR/borrowck-pat-at-and-box.rs:51:9
| |
LL | let ref mut a @ box ref b = Box::new(NC); LL | let ref mut a @ box ref b = Box::new(NC);
| ---------^^^^^^^----- | ---------^^^^^^^-----
@ -53,7 +53,7 @@ LL | let ref mut a @ box ref b = Box::new(NC);
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:66:9 --> $DIR/borrowck-pat-at-and-box.rs:65:9
| |
LL | ref mut a @ box ref b => { LL | ref mut a @ box ref b => {
| ---------^^^^^^^----- | ---------^^^^^^^-----
@ -62,7 +62,7 @@ LL | ref mut a @ box ref b => {
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:58:11 --> $DIR/borrowck-pat-at-and-box.rs:57:11
| |
LL | fn f5(ref mut a @ box ref b: Box<NC>) { LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ---------^^^^^^^----- | ---------^^^^^^^-----
@ -71,7 +71,7 @@ LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-at-and-box.rs:21:18 --> $DIR/borrowck-pat-at-and-box.rs:20:18
| |
LL | let a @ box &b = Box::new(&C); LL | let a @ box &b = Box::new(&C);
| ---------^ ------------ move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait | ---------^ ------------ move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait
@ -80,7 +80,7 @@ LL | let a @ box &b = Box::new(&C);
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-at-and-box.rs:24:17 --> $DIR/borrowck-pat-at-and-box.rs:23:17
| |
LL | let a @ box b = Box::new(C); LL | let a @ box b = Box::new(C);
| --------^ ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait | --------^ ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
@ -89,7 +89,7 @@ LL | let a @ box b = Box::new(C);
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-at-and-box.rs:34:17 --> $DIR/borrowck-pat-at-and-box.rs:33:17
| |
LL | match Box::new(C) { LL | match Box::new(C) {
| ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait | ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
@ -100,7 +100,7 @@ LL | a @ box b => {}
| value moved here | value moved here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-at-and-box.rs:46:21 --> $DIR/borrowck-pat-at-and-box.rs:45:21
| |
LL | let ref a @ box ref mut b = Box::new(NC); LL | let ref a @ box ref mut b = Box::new(NC);
| ------------^^^^^^^^^ | ------------^^^^^^^^^
@ -112,7 +112,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:52:25 --> $DIR/borrowck-pat-at-and-box.rs:51:25
| |
LL | let ref mut a @ box ref b = Box::new(NC); LL | let ref mut a @ box ref b = Box::new(NC);
| ----------------^^^^^ | ----------------^^^^^
@ -124,7 +124,7 @@ LL | *a = Box::new(NC);
| -- mutable borrow later used here | -- mutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:66:25 --> $DIR/borrowck-pat-at-and-box.rs:65:25
| |
LL | ref mut a @ box ref b => { LL | ref mut a @ box ref b => {
| ----------------^^^^^ | ----------------^^^^^
@ -136,7 +136,7 @@ LL | *a = Box::new(NC);
| -- mutable borrow later used here | -- mutable borrow later used here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-at-and-box.rs:27:20 --> $DIR/borrowck-pat-at-and-box.rs:26:20
| |
LL | fn f1(a @ box &b: Box<&C>) {} LL | fn f1(a @ box &b: Box<&C>) {}
| ---------^ | ---------^
@ -146,7 +146,7 @@ LL | fn f1(a @ box &b: Box<&C>) {}
| move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait | move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-at-and-box.rs:30:19 --> $DIR/borrowck-pat-at-and-box.rs:29:19
| |
LL | fn f2(a @ box b: Box<C>) {} LL | fn f2(a @ box b: Box<C>) {}
| --------^ | --------^
@ -156,7 +156,7 @@ LL | fn f2(a @ box b: Box<C>) {}
| move occurs because value has type `Box<C>`, which does not implement the `Copy` trait | move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-at-and-box.rs:58:27 --> $DIR/borrowck-pat-at-and-box.rs:57:27
| |
LL | fn f5(ref mut a @ box ref b: Box<NC>) { LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ----------------^^^^^ | ----------------^^^^^

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.rs
View file

@ -2,7 +2,6 @@
// Currently this logic exists in THIR match checking as opposed to borrowck. // Currently this logic exists in THIR match checking as opposed to borrowck.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;

2
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
View file

@ -1,5 +1,5 @@
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse-promotion.rs:9:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse-promotion.rs:8:9
| |
LL | let a @ ref b = U; LL | let a @ ref b = U;
| -^^^----- | -^^^-----

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.rs
View file

@ -1,7 +1,6 @@
// Test that `by_move_binding @ pat_with_by_ref_bindings` is prevented. // Test that `by_move_binding @ pat_with_by_ref_bindings` is prevented.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;

96
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr
View file

@ -1,5 +1,5 @@
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:29:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:28:9
| |
LL | let a @ ref b = U; LL | let a @ ref b = U;
| -^^^----- | -^^^-----
@ -9,7 +9,7 @@ LL | let a @ ref b = U;
| move occurs because `a` has type `U` which does not implement the `Copy` trait | move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:9
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -^^^^^^^^^^^^---------^^^^^^-----^ | -^^^^^^^^^^^^---------^^^^^^-----^
@ -20,7 +20,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait | move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:14 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:14
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -----^^^--------- | -----^^^---------
@ -30,7 +30,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `b` has type `U` which does not implement the `Copy` trait | move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:33
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -^^^----- | -^^^-----
@ -40,7 +40,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `d` has type `U` which does not implement the `Copy` trait | move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:37:9
| |
LL | let a @ [ref mut b, ref c] = [U, U]; LL | let a @ [ref mut b, ref c] = [U, U];
| -^^^^---------^^-----^ | -^^^^---------^^-----^
@ -51,7 +51,7 @@ LL | let a @ [ref mut b, ref c] = [U, U];
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait | move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:40:9
| |
LL | let a @ ref b = u(); LL | let a @ ref b = u();
| -^^^----- | -^^^-----
@ -61,7 +61,7 @@ LL | let a @ ref b = u();
| move occurs because `a` has type `U` which does not implement the `Copy` trait | move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:9
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -^^^^^^^^^^^^---------^^^^^^-----^ | -^^^^^^^^^^^^---------^^^^^^-----^
@ -72,7 +72,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait | move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:14 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:14
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -----^^^--------- | -----^^^---------
@ -82,7 +82,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `b` has type `U` which does not implement the `Copy` trait | move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:33
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -^^^----- | -^^^-----
@ -92,7 +92,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `d` has type `U` which does not implement the `Copy` trait | move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:50:9
| |
LL | let a @ [ref mut b, ref c] = [u(), u()]; LL | let a @ [ref mut b, ref c] = [u(), u()];
| -^^^^---------^^-----^ | -^^^^---------^^-----^
@ -103,7 +103,7 @@ LL | let a @ [ref mut b, ref c] = [u(), u()];
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait | move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:56:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:55:9
| |
LL | a @ Some(ref b) => {} LL | a @ Some(ref b) => {}
| -^^^^^^^^-----^ | -^^^^^^^^-----^
@ -113,7 +113,7 @@ LL | a @ Some(ref b) => {}
| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:9
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^ | -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
@ -124,7 +124,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:19 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:19
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -----^^^--------- | -----^^^---------
@ -134,7 +134,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait | move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:38
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^----- | -^^^-----
@ -144,7 +144,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait | move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:70:9
| |
LL | mut a @ Some([ref b, ref mut c]) => {} LL | mut a @ Some([ref b, ref mut c]) => {}
| -----^^^^^^^^^-----^^---------^^ | -----^^^^^^^^^-----^^---------^^
@ -155,7 +155,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:76:9
| |
LL | a @ Some(ref b) => {} LL | a @ Some(ref b) => {}
| -^^^^^^^^-----^ | -^^^^^^^^-----^
@ -165,7 +165,7 @@ LL | a @ Some(ref b) => {}
| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:9
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^ | -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
@ -176,7 +176,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:19 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:19
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -----^^^--------- | -----^^^---------
@ -186,7 +186,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait | move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:38
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^----- | -^^^-----
@ -196,7 +196,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait | move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:9 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:92:9
| |
LL | mut a @ Some([ref b, ref mut c]) => {} LL | mut a @ Some([ref b, ref mut c]) => {}
| -----^^^^^^^^^-----^^---------^^ | -----^^^^^^^^^-----^^---------^^
@ -207,7 +207,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait | move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:11 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:13:11
| |
LL | fn f1(a @ ref b: U) {} LL | fn f1(a @ ref b: U) {}
| -^^^----- | -^^^-----
@ -217,7 +217,7 @@ LL | fn f1(a @ ref b: U) {}
| move occurs because `a` has type `U` which does not implement the `Copy` trait | move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:11 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:11
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -----^^^^^^^^-----^^^^^^^^^^-----^ | -----^^^^^^^^-----^^^^^^^^^^-----^
@ -228,7 +228,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait | move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:20 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:20
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -^^^----- | -^^^-----
@ -238,7 +238,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait | move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:31
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -----^^^----- | -----^^^-----
@ -248,7 +248,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait | move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:11 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:24:11
| |
LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {} LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| -^^^^---------^^-----^ | -^^^^---------^^-----^
@ -259,7 +259,7 @@ LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait | move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:22 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:22
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| --------^^^^^^^^^ | --------^^^^^^^^^
@ -270,7 +270,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:33
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| ------------------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | ------------------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@ -279,7 +279,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:37 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:37
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U); LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| ----^^^^^ | ----^^^^^
@ -290,7 +290,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:25 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:37:25
| |
LL | let a @ [ref mut b, ref c] = [U, U]; LL | let a @ [ref mut b, ref c] = [U, U];
| ----------------^^^^^- ------ move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait | ----------------^^^^^- ------ move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
@ -299,7 +299,7 @@ LL | let a @ [ref mut b, ref c] = [U, U];
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:13 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:40:13
| |
LL | let a @ ref b = u(); LL | let a @ ref b = u();
| ----^^^^^ --- move occurs because value has type `U`, which does not implement the `Copy` trait | ----^^^^^ --- move occurs because value has type `U`, which does not implement the `Copy` trait
@ -308,7 +308,7 @@ LL | let a @ ref b = u();
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:22 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:22
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| --------^^^^^^^^^ | --------^^^^^^^^^
@ -319,7 +319,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:33
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| ------------------------^^^^^^^^^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | ------------------------^^^^^^^^^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@ -328,7 +328,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:37 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:37
| |
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u()); LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| ----^^^^^ | ----^^^^^
@ -339,7 +339,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:25 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:50:25
| |
LL | let a @ [ref mut b, ref c] = [u(), u()]; LL | let a @ [ref mut b, ref c] = [u(), u()];
| ----------------^^^^^- ---------- move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait | ----------------^^^^^- ---------- move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
@ -348,7 +348,7 @@ LL | let a @ [ref mut b, ref c] = [u(), u()];
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:27 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:27
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| --------^^^^^^^^^ | --------^^^^^^^^^
@ -363,7 +363,7 @@ LL | a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
| ^^^ | ^^^
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:38
| |
LL | match Some((U, U)) { LL | match Some((U, U)) {
| ------------ move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait | ------------ move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
@ -374,7 +374,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:42 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:42
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| ----^^^^^ | ----^^^^^
@ -389,7 +389,7 @@ LL | a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
| ^^^ | ^^^
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:30 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:70:30
| |
LL | match Some([U, U]) { LL | match Some([U, U]) {
| ------------ move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait | ------------ move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
@ -400,7 +400,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:18 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:76:18
| |
LL | match Some(u()) { LL | match Some(u()) {
| --------- move occurs because value has type `Option<U>`, which does not implement the `Copy` trait | --------- move occurs because value has type `Option<U>`, which does not implement the `Copy` trait
@ -411,7 +411,7 @@ LL | a @ Some(ref b) => {}
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:27 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:27
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| --------^^^^^^^^^ | --------^^^^^^^^^
@ -426,7 +426,7 @@ LL | a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
| ^^^ | ^^^
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:38
| |
LL | match Some((u(), u())) { LL | match Some((u(), u())) {
| ---------------- move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait | ---------------- move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
@ -437,7 +437,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:42 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:42
| |
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {} LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| ----^^^^^ | ----^^^^^
@ -452,7 +452,7 @@ LL | a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
| ^^^ | ^^^
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:30 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:92:30
| |
LL | match Some([u(), u()]) { LL | match Some([u(), u()]) {
| ---------------- move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait | ---------------- move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
@ -463,7 +463,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:15 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:13:15
| |
LL | fn f1(a @ ref b: U) {} LL | fn f1(a @ ref b: U) {}
| ----^^^^^ | ----^^^^^
@ -473,7 +473,7 @@ LL | fn f1(a @ ref b: U) {}
| move occurs because value has type `U`, which does not implement the `Copy` trait | move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:24 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:24
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| ----^^^^^ | ----^^^^^
@ -484,7 +484,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:31
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| --------------------^^^^^^^^^^^^^- | --------------------^^^^^^^^^^^^^-
@ -494,7 +494,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:39 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:39
| |
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {} LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| --------^^^^^ | --------^^^^^
@ -505,7 +505,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
= note: move occurs because value has type `U`, which does not implement the `Copy` trait = note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:27 --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:24:27
| |
LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {} LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| ----------------^^^^^- | ----------------^^^^^-

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.rs
View file

@ -1,7 +1,6 @@
// Test that `ref mut? @ pat_with_by_move_bindings` is prevented. // Test that `ref mut? @ pat_with_by_move_bindings` is prevented.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;

50
src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.stderr
View file

@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:23:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:22:9
| |
LL | let ref a @ b = U; LL | let ref a @ b = U;
| -----^^^- | -----^^^-
@ -8,7 +8,7 @@ LL | let ref a @ b = U;
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:25:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:24:9
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U); LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@ -18,7 +18,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:25:18 --> $DIR/borrowck-pat-by-move-and-ref.rs:24:18
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U); LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^----- | -----^^^-----
@ -27,7 +27,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `b`, here | value borrowed, by `b`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:25:33 --> $DIR/borrowck-pat-by-move-and-ref.rs:24:33
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U); LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^- | -----^^^-
@ -36,7 +36,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `d`, here | value borrowed, by `d`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:29:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:28:9
| |
LL | let ref mut a @ [b, mut c] = [U, U]; LL | let ref mut a @ [b, mut c] = [U, U];
| ---------^^^^-^^-----^ | ---------^^^^-^^-----^
@ -46,7 +46,7 @@ LL | let ref mut a @ [b, mut c] = [U, U];
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:31:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:30:9
| |
LL | let ref a @ b = u(); LL | let ref a @ b = u();
| -----^^^- | -----^^^-
@ -55,7 +55,7 @@ LL | let ref a @ b = u();
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:33:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:32:9
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u()); LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@ -65,7 +65,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:33:18 --> $DIR/borrowck-pat-by-move-and-ref.rs:32:18
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u()); LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^----- | -----^^^-----
@ -74,7 +74,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `b`, here | value borrowed, by `b`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:33:33 --> $DIR/borrowck-pat-by-move-and-ref.rs:32:33
| |
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u()); LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^- | -----^^^-
@ -83,7 +83,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `d`, here | value borrowed, by `d`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:37:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:36:9
| |
LL | let ref mut a @ [b, mut c] = [u(), u()]; LL | let ref mut a @ [b, mut c] = [u(), u()];
| ---------^^^^-^^-----^ | ---------^^^^-^^-----^
@ -93,7 +93,7 @@ LL | let ref mut a @ [b, mut c] = [u(), u()];
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:41:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:40:9
| |
LL | ref a @ Some(b) => {} LL | ref a @ Some(b) => {}
| -----^^^^^^^^-^ | -----^^^^^^^^-^
@ -102,7 +102,7 @@ LL | ref a @ Some(b) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:46:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:45:9
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^ | -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
@ -112,7 +112,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:46:23 --> $DIR/borrowck-pat-by-move-and-ref.rs:45:23
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^----- | -----^^^-----
@ -121,7 +121,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `b`, here | value borrowed, by `b`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:46:38 --> $DIR/borrowck-pat-by-move-and-ref.rs:45:38
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^- | -----^^^-
@ -130,7 +130,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `d`, here | value borrowed, by `d`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:53:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:52:9
| |
LL | ref mut a @ Some([b, mut c]) => {} LL | ref mut a @ Some([b, mut c]) => {}
| ---------^^^^^^^^^-^^-----^^ | ---------^^^^^^^^^-^^-----^^
@ -140,7 +140,7 @@ LL | ref mut a @ Some([b, mut c]) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:58:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:57:9
| |
LL | ref a @ Some(b) => {} LL | ref a @ Some(b) => {}
| -----^^^^^^^^-^ | -----^^^^^^^^-^
@ -149,7 +149,7 @@ LL | ref a @ Some(b) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:63:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:62:9
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^ | -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
@ -159,7 +159,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:63:23 --> $DIR/borrowck-pat-by-move-and-ref.rs:62:23
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^----- | -----^^^-----
@ -168,7 +168,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `b`, here | value borrowed, by `b`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:63:38 --> $DIR/borrowck-pat-by-move-and-ref.rs:62:38
| |
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {} LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^- | -----^^^-
@ -177,7 +177,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `d`, here | value borrowed, by `d`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:70:9 --> $DIR/borrowck-pat-by-move-and-ref.rs:69:9
| |
LL | ref mut a @ Some([b, mut c]) => {} LL | ref mut a @ Some([b, mut c]) => {}
| ---------^^^^^^^^^-^^-----^^ | ---------^^^^^^^^^-^^-----^^
@ -187,7 +187,7 @@ LL | ref mut a @ Some([b, mut c]) => {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:14:11 --> $DIR/borrowck-pat-by-move-and-ref.rs:13:11
| |
LL | fn f1(ref a @ b: U) {} LL | fn f1(ref a @ b: U) {}
| -----^^^- | -----^^^-
@ -196,7 +196,7 @@ LL | fn f1(ref a @ b: U) {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:16:11 --> $DIR/borrowck-pat-by-move-and-ref.rs:15:11
| |
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {} LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^ | -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@ -206,7 +206,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:16:20 --> $DIR/borrowck-pat-by-move-and-ref.rs:15:20
| |
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {} LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^----- | -----^^^-----
@ -215,7 +215,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `b`, here | value borrowed, by `b`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:16:35 --> $DIR/borrowck-pat-by-move-and-ref.rs:15:35
| |
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {} LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^- | -----^^^-
@ -224,7 +224,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `d`, here | value borrowed, by `d`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-by-move-and-ref.rs:20:11 --> $DIR/borrowck-pat-by-move-and-ref.rs:19:11
| |
LL | fn f3(ref mut a @ [b, mut c]: [U; 2]) {} LL | fn f3(ref mut a @ [b, mut c]: [U; 2]) {}
| ---------^^^^-^^-----^ | ---------^^^^-^^-----^

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.rs
View file

@ -1,5 +1,4 @@
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
enum Option<T> { enum Option<T> {
None, None,

94
src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr
View file

@ -1,5 +1,5 @@
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:9
| |
LL | ref mut z @ &mut Some(ref a) => { LL | ref mut z @ &mut Some(ref a) => {
| ---------^^^^^^^^^^^^^-----^ | ---------^^^^^^^^^^^^^-----^
@ -8,7 +8,7 @@ LL | ref mut z @ &mut Some(ref a) => {
| mutable borrow, by `z`, occurs here | mutable borrow, by `z`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:34:9
| |
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| ---------^^^^-----------------^ | ---------^^^^-----------------^
@ -18,7 +18,7 @@ LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:22 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:34:22
| |
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| -----^^^--------- | -----^^^---------
@ -27,7 +27,7 @@ LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| immutable borrow, by `b`, occurs here | immutable borrow, by `b`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value 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:38:9
| |
LL | let ref a @ ref mut b = U; LL | let ref a @ ref mut b = U;
| -----^^^--------- | -----^^^---------
@ -36,7 +36,7 @@ LL | let ref a @ ref mut b = U;
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value 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:40:9
| |
LL | let ref mut a @ ref b = U; LL | let ref mut a @ ref b = U;
| ---------^^^----- | ---------^^^-----
@ -45,7 +45,7 @@ LL | let ref mut a @ ref b = U;
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:43:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:42:9
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^ | -----^^^^---------^^---------^
@ -55,7 +55,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:45:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:44:9
| |
LL | let ref mut a @ (ref b, ref c) = (U, U); LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^ | ---------^^^^-----^^-----^
@ -65,7 +65,7 @@ LL | let ref mut a @ (ref b, ref c) = (U, U);
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:47:9
| |
LL | let ref mut a @ ref b = u(); LL | let ref mut a @ ref b = u();
| ---------^^^----- | ---------^^^-----
@ -74,7 +74,7 @@ LL | let ref mut a @ ref b = u();
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:52:9
| |
LL | let ref a @ ref mut b = u(); LL | let ref a @ ref mut b = u();
| -----^^^--------- | -----^^^---------
@ -83,7 +83,7 @@ LL | let ref a @ ref mut b = u();
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:59:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:58:9
| |
LL | let ref mut a @ ref b = U; LL | let ref mut a @ ref b = U;
| ---------^^^----- | ---------^^^-----
@ -92,7 +92,7 @@ LL | let ref mut a @ ref b = U;
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:63:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:62:9
| |
LL | let ref a @ ref mut b = U; LL | let ref a @ ref mut b = U;
| -----^^^--------- | -----^^^---------
@ -101,7 +101,7 @@ LL | let ref a @ ref mut b = U;
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:68:9
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => { LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^-----^ | ---------^^^^^^-----^
@ -110,7 +110,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:68:33
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => { LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^^-----^ | ---------^^^^^^^-----^
@ -119,7 +119,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:9
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => { LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^---------^ | -----^^^^^^---------^
@ -128,7 +128,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:33
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => { LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^^---------^ | -----^^^^^^^---------^
@ -137,7 +137,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:9
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^---------^ | -----^^^^^^---------^
@ -146,7 +146,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:33
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^^---------^ | -----^^^^^^^---------^
@ -155,7 +155,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:9
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {} LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^-----^ | ---------^^^^^^-----^
@ -164,7 +164,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:33
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {} LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^^-----^ | ---------^^^^^^^-----^
@ -173,7 +173,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:9
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^---------^ | -----^^^^^^---------^
@ -182,7 +182,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:33
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^^---------^ | -----^^^^^^^---------^
@ -191,7 +191,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:9
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^-----^ | ---------^^^^^^-----^
@ -200,7 +200,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:33 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:33
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^^-----^ | ---------^^^^^^^-----^
@ -209,7 +209,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:119:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:118:9
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^ | -----^^^^---------^^---------^
@ -219,7 +219,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:9
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^ | -----^^^^---------^^---------^
@ -229,7 +229,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:9
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^ | -----^^^^---------^^---------^
@ -239,7 +239,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:136:9 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:135:9
| |
LL | let ref mut a @ (ref b, ref c) = (U, U); LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^ | ---------^^^^-----^^-----^
@ -249,7 +249,7 @@ LL | let ref mut a @ (ref b, ref c) = (U, U);
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:25:11 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:24:11
| |
LL | fn f1(ref a @ ref mut b: U) {} LL | fn f1(ref a @ ref mut b: U) {}
| -----^^^--------- | -----^^^---------
@ -258,7 +258,7 @@ LL | fn f1(ref a @ ref mut b: U) {}
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable error: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:27:11 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:26:11
| |
LL | fn f2(ref mut a @ ref b: U) {} LL | fn f2(ref mut a @ ref b: U) {}
| ---------^^^----- | ---------^^^-----
@ -267,7 +267,7 @@ LL | fn f2(ref mut a @ ref b: U) {}
| mutable borrow, by `a`, occurs here | mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:29:11 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:28:11
| |
LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {} LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
| -----^^^^^^^^^^^----------------^^^^^^^^ | -----^^^^^^^^^^^----------------^^^^^^^^
@ -276,7 +276,7 @@ LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable error: cannot borrow value 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:30:22
| |
LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {} LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| -----^^^------------- | -----^^^-------------
@ -286,7 +286,7 @@ LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| immutable borrow, by `a`, occurs here | immutable borrow, by `a`, occurs here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:30 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:30:30
| |
LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {} LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| ---------^^^- | ---------^^^-
@ -295,7 +295,7 @@ LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| value borrowed, by `b`, here | value borrowed, by `b`, here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:31 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:31
| |
LL | ref mut z @ &mut Some(ref a) => { LL | ref mut z @ &mut Some(ref a) => {
| ----------------------^^^^^- | ----------------------^^^^^-
@ -307,7 +307,7 @@ LL | **z = None;
| ---------- mutable borrow later used here | ---------- mutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:21 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:47:21
| |
LL | let ref mut a @ ref b = u(); LL | let ref mut a @ ref b = u();
| ------------^^^^^ | ------------^^^^^
@ -319,7 +319,7 @@ LL | *a = u();
| -------- mutable borrow later used here | -------- mutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:17 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:52:17
| |
LL | let ref a @ ref mut b = u(); LL | let ref a @ ref mut b = u();
| --------^^^^^^^^^ | --------^^^^^^^^^
@ -331,7 +331,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:20 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:20
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => { LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----------^^^^^^^^^- | -----------^^^^^^^^^-
@ -343,7 +343,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:45 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:45
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => { LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| ------------^^^^^^^^^- | ------------^^^^^^^^^-
@ -355,7 +355,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0594]: cannot assign to `*b`, as it is immutable for the pattern guard error[E0594]: cannot assign to `*b`, as it is immutable for the pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:61 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:61
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| ^^^^^^ cannot assign | ^^^^^^ cannot assign
@ -363,7 +363,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
= note: variables bound in patterns are immutable until the end of the pattern guard = 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 error[E0594]: cannot assign to `*a`, as it is immutable for the pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:61 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:61
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {} LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ^^^^^^^^^^^ cannot assign | ^^^^^^^^^^^ cannot assign
@ -371,7 +371,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
= note: variables bound in patterns are immutable until the end of the pattern guard = note: variables bound in patterns are immutable until the end of the pattern guard
error[E0507]: cannot move out of `b` in pattern guard error[E0507]: cannot move out of `b` in pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:66
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait | ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
@ -379,7 +379,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard = 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 error[E0507]: cannot move out of `b` in pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:66
| |
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {} LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait | ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
@ -387,7 +387,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard = 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 error[E0507]: cannot move out of `a` in pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:66
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} 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<U, U>`, which does not implement the `Copy` trait | ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait
@ -395,7 +395,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard = 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 error[E0507]: cannot move out of `a` in pattern guard
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:66
| |
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {} 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<U, U>`, which does not implement the `Copy` trait | ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait
@ -403,7 +403,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard = note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:18 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:18
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------ | ---------^^^^^^^^^------------
@ -415,7 +415,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:29 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:29
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^- | --------------------^^^^^^^^^-
@ -427,7 +427,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:18 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:18
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------ | ---------^^^^^^^^^------------
@ -439,7 +439,7 @@ LL | drop(a);
| - immutable borrow later used here | - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
--> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:29 --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:29
| |
LL | let ref a @ (ref mut b, ref mut c) = (U, U); LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^- | --------------------^^^^^^^^^-

1
src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.rs
View file

@ -1,7 +1,6 @@
// Test that `ref mut x @ ref mut y` and varieties of that are not allowed. // Test that `ref mut x @ ref mut y` and varieties of that are not allowed.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;

68
src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.stderr
View file

@ -1,5 +1,5 @@
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:28:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:27:9
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ---------^^^--------- | ---------^^^---------
@ -8,7 +8,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:32:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:31:9
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ---------^^^--------- | ---------^^^---------
@ -17,7 +17,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:35:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:34:9
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ---------^^^--------- | ---------^^^---------
@ -26,7 +26,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:38:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:37:9
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ---------^^^--------- | ---------^^^---------
@ -35,7 +35,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:42:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:41:9
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ---------^^^--------- | ---------^^^---------
@ -44,7 +44,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:46:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:45:9
| |
LL | let ref mut a @ ( LL | let ref mut a @ (
| ^-------- | ^--------
@ -66,7 +66,7 @@ LL | | ) = (U, [U, U, U]);
| |_____^ | |_____^
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:56:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:55:9
| |
LL | let ref mut a @ ( LL | let ref mut a @ (
| ^-------- | ^--------
@ -88,7 +88,7 @@ LL | | ) = (u(), [u(), u(), u()]);
| |_________^ | |_________^
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:66:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:65:9
| |
LL | let a @ (ref mut b, ref mut c) = (U, U); LL | let a @ (ref mut b, ref mut c) = (U, U);
| -^^^^---------^^---------^ | -^^^^---------^^---------^
@ -99,7 +99,7 @@ LL | let a @ (ref mut b, ref mut c) = (U, U);
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait | move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:70:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:69:9
| |
LL | let a @ (b, [c, d]) = &mut val; // Same as ^-- LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| -^^^^-^^^-^^-^^ | -^^^^-^^^-^^-^^
@ -111,7 +111,7 @@ LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| move occurs because `a` has type `&mut (U, [U; 2])` which does not implement the `Copy` trait | move occurs because `a` has type `&mut (U, [U; 2])` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:74:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:73:9
| |
LL | let a @ &mut ref mut b = &mut U; LL | let a @ &mut ref mut b = &mut U;
| -^^^^^^^^--------- | -^^^^^^^^---------
@ -121,7 +121,7 @@ LL | let a @ &mut ref mut b = &mut U;
| move occurs because `a` has type `&mut U` which does not implement the `Copy` trait | move occurs because `a` has type `&mut U` which does not implement the `Copy` trait
error: borrow of moved value error: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:77:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:76:9
| |
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U); LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| -^^^^^^^^^---------^^---------^ | -^^^^^^^^^---------^^---------^
@ -132,7 +132,7 @@ LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| move occurs because `a` has type `&mut (U, U)` which does not implement the `Copy` trait | move occurs because `a` has type `&mut (U, U)` which does not implement the `Copy` trait
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:82:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:81:9
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^ | ---------^^^^^^---------^
@ -141,7 +141,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:82:37 --> $DIR/borrowck-pat-ref-mut-twice.rs:81:37
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^ | ---------^^^^^^^---------^
@ -150,7 +150,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:88:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:87:9
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^ | ---------^^^^^^---------^
@ -159,7 +159,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:88:37 --> $DIR/borrowck-pat-ref-mut-twice.rs:87:37
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^ | ---------^^^^^^^---------^
@ -168,7 +168,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:95:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:94:9
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^ | ---------^^^^^^---------^
@ -177,7 +177,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:95:37 --> $DIR/borrowck-pat-ref-mut-twice.rs:94:37
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^ | ---------^^^^^^^---------^
@ -186,7 +186,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:107:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:106:9
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^ | ---------^^^^^^---------^
@ -195,7 +195,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:107:37 --> $DIR/borrowck-pat-ref-mut-twice.rs:106:37
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^ | ---------^^^^^^^---------^
@ -204,7 +204,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:11:11 --> $DIR/borrowck-pat-ref-mut-twice.rs:10:11
| |
LL | fn f1(ref mut a @ ref mut b: U) {} LL | fn f1(ref mut a @ ref mut b: U) {}
| ---------^^^--------- | ---------^^^---------
@ -213,7 +213,7 @@ LL | fn f1(ref mut a @ ref mut b: U) {}
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:13:11 --> $DIR/borrowck-pat-ref-mut-twice.rs:12:11
| |
LL | fn f2(ref mut a @ ref mut b: U) {} LL | fn f2(ref mut a @ ref mut b: U) {}
| ---------^^^--------- | ---------^^^---------
@ -222,7 +222,7 @@ LL | fn f2(ref mut a @ ref mut b: U) {}
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:16:9 --> $DIR/borrowck-pat-ref-mut-twice.rs:15:9
| |
LL | ref mut a @ [ LL | ref mut a @ [
| ^-------- | ^--------
@ -240,7 +240,7 @@ LL | | ] : [[U; 4]; 5]
| |_________^ | |_________^
error: cannot borrow value as mutable more than once at a time error: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:24:22 --> $DIR/borrowck-pat-ref-mut-twice.rs:23:22
| |
LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {} LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| ---------^^^------------- | ---------^^^-------------
@ -250,7 +250,7 @@ LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| first mutable borrow, by `a`, occurs here | first mutable borrow, by `a`, occurs here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/borrowck-pat-ref-mut-twice.rs:24:34 --> $DIR/borrowck-pat-ref-mut-twice.rs:23:34
| |
LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {} LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| ---------^^^- | ---------^^^-
@ -259,7 +259,7 @@ LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| value borrowed, by `b`, here | value borrowed, by `b`, here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:28:21 --> $DIR/borrowck-pat-ref-mut-twice.rs:27:21
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^ | ------------^^^^^^^^^
@ -271,7 +271,7 @@ LL | drop(a);
| - first borrow later used here | - first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:38:21 --> $DIR/borrowck-pat-ref-mut-twice.rs:37:21
| |
LL | let ref mut a @ ref mut b = U; LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^ | ------------^^^^^^^^^
@ -283,7 +283,7 @@ LL | *a = U;
| ------ first borrow later used here | ------ first borrow later used here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:66:25 --> $DIR/borrowck-pat-ref-mut-twice.rs:65:25
| |
LL | let a @ (ref mut b, ref mut c) = (U, U); LL | let a @ (ref mut b, ref mut c) = (U, U);
| ----------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait | ----------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@ -292,7 +292,7 @@ LL | let a @ (ref mut b, ref mut c) = (U, U);
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:70:21 --> $DIR/borrowck-pat-ref-mut-twice.rs:69:21
| |
LL | let a @ (b, [c, d]) = &mut val; // Same as ^-- LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| ------------^-- -------- move occurs because value has type `&mut (U, [U; 2])`, which does not implement the `Copy` trait | ------------^-- -------- move occurs because value has type `&mut (U, [U; 2])`, which does not implement the `Copy` trait
@ -301,7 +301,7 @@ LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:74:18 --> $DIR/borrowck-pat-ref-mut-twice.rs:73:18
| |
LL | let a @ &mut ref mut b = &mut U; LL | let a @ &mut ref mut b = &mut U;
| ---------^^^^^^^^^ ------ move occurs because value has type `&mut U`, which does not implement the `Copy` trait | ---------^^^^^^^^^ ------ move occurs because value has type `&mut U`, which does not implement the `Copy` trait
@ -310,7 +310,7 @@ LL | let a @ &mut ref mut b = &mut U;
| value moved here | value moved here
error[E0382]: borrow of moved value error[E0382]: borrow of moved value
--> $DIR/borrowck-pat-ref-mut-twice.rs:77:30 --> $DIR/borrowck-pat-ref-mut-twice.rs:76:30
| |
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U); LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| ---------------------^^^^^^^^^- ----------- move occurs because value has type `&mut (U, U)`, which does not implement the `Copy` trait | ---------------------^^^^^^^^^- ----------- move occurs because value has type `&mut (U, U)`, which does not implement the `Copy` trait
@ -319,7 +319,7 @@ LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| value moved here | value moved here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:95:24 --> $DIR/borrowck-pat-ref-mut-twice.rs:94:24
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^- | ---------------^^^^^^^^^-
@ -331,7 +331,7 @@ LL | *a = Err(U);
| ----------- first borrow later used here | ----------- first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:95:53 --> $DIR/borrowck-pat-ref-mut-twice.rs:94:53
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^- | ----------------^^^^^^^^^-
@ -343,7 +343,7 @@ LL | *a = Err(U);
| ----------- first borrow later used here | ----------- first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:107:24 --> $DIR/borrowck-pat-ref-mut-twice.rs:106:24
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^- | ---------------^^^^^^^^^-
@ -355,7 +355,7 @@ LL | drop(a);
| - first borrow later used here | - first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time error[E0499]: cannot borrow value as mutable more than once at a time
--> $DIR/borrowck-pat-ref-mut-twice.rs:107:53 --> $DIR/borrowck-pat-ref-mut-twice.rs:106:53
| |
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => { LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^- | ----------------^^^^^^^^^-

1
src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.rs
View file

@ -1,7 +1,6 @@
// Test that mixing `Copy` and non-`Copy` types in `@` patterns is forbidden. // Test that mixing `Copy` and non-`Copy` types in `@` patterns is forbidden.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
struct C; struct C;

6
src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
View file

@ -1,5 +1,5 @@
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/copy-and-move-mixed.rs:12:19 --> $DIR/copy-and-move-mixed.rs:11:19
| |
LL | let a @ NC(b, c) = NC(C, C); 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 | ----------^- -------- move occurs because value has type `NC<C, C>`, which does not implement the `Copy` trait
@ -8,7 +8,7 @@ LL | let a @ NC(b, c) = NC(C, C);
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/copy-and-move-mixed.rs:15:19 --> $DIR/copy-and-move-mixed.rs:14:19
| |
LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C)); LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| ----------^^^^^^^^^^^^- --------------- move occurs because value has type `NC<C, NC<C, C>>`, which does not implement the `Copy` trait | ----------^^^^^^^^^^^^- --------------- move occurs because value has type `NC<C, NC<C, C>>`, which does not implement the `Copy` trait
@ -17,7 +17,7 @@ LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| value moved here | value moved here
error[E0382]: use of moved value error[E0382]: use of moved value
--> $DIR/copy-and-move-mixed.rs:15:29 --> $DIR/copy-and-move-mixed.rs:14:29
| |
LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C)); LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| ----------^- | ----------^-

1
src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.rs
View file

@ -8,7 +8,6 @@
// this would create problems for the generalization aforementioned. // this would create problems for the generalization aforementioned.
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct NotCopy; struct NotCopy;

12
src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.stderr
View file

@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/default-binding-modes-both-sides-independent.rs:28:9 --> $DIR/default-binding-modes-both-sides-independent.rs:27:9
| |
LL | let ref a @ b = NotCopy; LL | let ref a @ b = NotCopy;
| -----^^^- | -----^^^-
@ -8,7 +8,7 @@ LL | let ref a @ b = NotCopy;
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/default-binding-modes-both-sides-independent.rs:31:9 --> $DIR/default-binding-modes-both-sides-independent.rs:30:9
| |
LL | let ref mut a @ b = NotCopy; LL | let ref mut a @ b = NotCopy;
| ---------^^^- | ---------^^^-
@ -17,7 +17,7 @@ LL | let ref mut a @ b = NotCopy;
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/default-binding-modes-both-sides-independent.rs:36:12 --> $DIR/default-binding-modes-both-sides-independent.rs:35:12
| |
LL | Ok(ref a @ b) | Err(b @ ref a) => { LL | Ok(ref a @ b) | Err(b @ ref a) => {
| -----^^^- | -----^^^-
@ -26,7 +26,7 @@ LL | Ok(ref a @ b) | Err(b @ ref a) => {
| value borrowed, by `a`, here | value borrowed, by `a`, here
error: borrow of moved value error: borrow of moved value
--> $DIR/default-binding-modes-both-sides-independent.rs:36:29 --> $DIR/default-binding-modes-both-sides-independent.rs:35:29
| |
LL | Ok(ref a @ b) | Err(b @ ref a) => { LL | Ok(ref a @ b) | Err(b @ ref a) => {
| -^^^----- | -^^^-----
@ -36,7 +36,7 @@ LL | Ok(ref a @ b) | Err(b @ ref a) => {
| move occurs because `b` has type `NotCopy` which does not implement the `Copy` trait | move occurs because `b` has type `NotCopy` which does not implement the `Copy` trait
error: cannot move out of value because it is borrowed error: cannot move out of value because it is borrowed
--> $DIR/default-binding-modes-both-sides-independent.rs:44:9 --> $DIR/default-binding-modes-both-sides-independent.rs:43:9
| |
LL | ref a @ b => { LL | ref a @ b => {
| -----^^^- | -----^^^-
@ -45,7 +45,7 @@ LL | ref a @ b => {
| value borrowed, by `a`, here | value borrowed, by `a`, here
error[E0505]: cannot move out of value because it is borrowed error[E0505]: cannot move out of value because it is borrowed
--> $DIR/default-binding-modes-both-sides-independent.rs:31:21 --> $DIR/default-binding-modes-both-sides-independent.rs:30:21
| |
LL | let ref mut a @ b = NotCopy; LL | let ref mut a @ b = NotCopy;
| ------------^ | ------------^

2
src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs
View file

@ -1,7 +1,5 @@
// check-pass // check-pass
#![feature(move_ref_pattern)]
fn main() {} fn main() {}
struct U; struct U;

2
src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs
View file

@ -1,5 +1,3 @@
#![feature(move_ref_pattern)]
fn main() {} fn main() {}
struct U; struct U;

36
src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr
View file

@ -1,5 +1,5 @@
error[E0505]: cannot move out of `arr[..]` because it is borrowed error[E0505]: cannot move out of `arr[..]` because it is borrowed
--> $DIR/borrowck-move-ref-pattern.rs:10:24 --> $DIR/borrowck-move-ref-pattern.rs:8:24
| |
LL | let hold_all = &arr; LL | let hold_all = &arr;
| ---- borrow of `arr` occurs here | ---- borrow of `arr` occurs here
@ -10,7 +10,7 @@ LL | drop(hold_all);
| -------- borrow later used here | -------- borrow later used here
error[E0384]: cannot assign twice to immutable variable `_x1` error[E0384]: cannot assign twice to immutable variable `_x1`
--> $DIR/borrowck-move-ref-pattern.rs:11:5 --> $DIR/borrowck-move-ref-pattern.rs:9:5
| |
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| --- | ---
@ -21,7 +21,7 @@ LL | _x1 = U;
| ^^^^^^^ cannot assign twice to immutable variable | ^^^^^^^ cannot assign twice to immutable variable
error[E0505]: cannot move out of `arr[..]` because it is borrowed error[E0505]: cannot move out of `arr[..]` because it is borrowed
--> $DIR/borrowck-move-ref-pattern.rs:13:10 --> $DIR/borrowck-move-ref-pattern.rs:11:10
| |
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ------------ borrow of `arr[..]` occurs here | ------------ borrow of `arr[..]` occurs here
@ -32,7 +32,7 @@ LL | drop(_x0_hold);
| -------- borrow later used here | -------- borrow later used here
error[E0502]: cannot borrow `arr[..]` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `arr[..]` as mutable because it is also borrowed as immutable
--> $DIR/borrowck-move-ref-pattern.rs:15:16 --> $DIR/borrowck-move-ref-pattern.rs:13:16
| |
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- immutable borrow occurs here | ---------------- immutable borrow occurs here
@ -44,7 +44,7 @@ LL | drop(xs_hold);
| ------- immutable borrow later used here | ------- immutable borrow later used here
error[E0505]: cannot move out of `arr[..]` because it is borrowed error[E0505]: cannot move out of `arr[..]` because it is borrowed
--> $DIR/borrowck-move-ref-pattern.rs:15:29 --> $DIR/borrowck-move-ref-pattern.rs:13:29
| |
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- borrow of `arr[..]` occurs here | ---------------- borrow of `arr[..]` occurs here
@ -56,7 +56,7 @@ LL | drop(xs_hold);
| ------- borrow later used here | ------- borrow later used here
error[E0505]: cannot move out of `arr[..]` because it is borrowed error[E0505]: cannot move out of `arr[..]` because it is borrowed
--> $DIR/borrowck-move-ref-pattern.rs:15:34 --> $DIR/borrowck-move-ref-pattern.rs:13:34
| |
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr; LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- borrow of `arr[..]` occurs here | ---------------- borrow of `arr[..]` occurs here
@ -68,7 +68,7 @@ LL | drop(xs_hold);
| ------- borrow later used here | ------- borrow later used here
error[E0384]: cannot assign twice to immutable variable `_x1` error[E0384]: cannot assign twice to immutable variable `_x1`
--> $DIR/borrowck-move-ref-pattern.rs:25:5 --> $DIR/borrowck-move-ref-pattern.rs:23:5
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| --- | ---
@ -79,7 +79,7 @@ LL | _x1 = U;
| ^^^^^^^ cannot assign twice to immutable variable | ^^^^^^^ cannot assign twice to immutable variable
error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
--> $DIR/borrowck-move-ref-pattern.rs:26:20 --> $DIR/borrowck-move-ref-pattern.rs:24:20
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- immutable borrow occurs here | ------- immutable borrow occurs here
@ -91,7 +91,7 @@ LL | *_x0 = U;
| -------- immutable borrow later used here | -------- immutable borrow later used here
error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
--> $DIR/borrowck-move-ref-pattern.rs:27:10 --> $DIR/borrowck-move-ref-pattern.rs:25:10
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- immutable borrow occurs here | ------- immutable borrow occurs here
@ -102,7 +102,7 @@ LL | *_x0 = U;
| -------- immutable borrow later used here | -------- immutable borrow later used here
error[E0594]: cannot assign to `*_x0` which is behind a `&` reference error[E0594]: cannot assign to `*_x0` which is behind a `&` reference
--> $DIR/borrowck-move-ref-pattern.rs:28:5 --> $DIR/borrowck-move-ref-pattern.rs:26:5
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- help: consider changing this to be a mutable reference: `ref mut _x0` | ------- help: consider changing this to be a mutable reference: `ref mut _x0`
@ -111,7 +111,7 @@ LL | *_x0 = U;
| ^^^^^^^^ `_x0` is a `&` reference, so the data it refers to cannot be written | ^^^^^^^^ `_x0` is a `&` reference, so the data it refers to cannot be written
error[E0594]: cannot assign to `*_x2` which is behind a `&` reference error[E0594]: cannot assign to `*_x2` which is behind a `&` reference
--> $DIR/borrowck-move-ref-pattern.rs:29:5 --> $DIR/borrowck-move-ref-pattern.rs:27:5
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- help: consider changing this to be a mutable reference: `ref mut _x2` | ------- help: consider changing this to be a mutable reference: `ref mut _x2`
@ -120,7 +120,7 @@ LL | *_x2 = U;
| ^^^^^^^^ `_x2` is a `&` reference, so the data it refers to cannot be written | ^^^^^^^^ `_x2` is a `&` reference, so the data it refers to cannot be written
error[E0382]: use of moved value: `tup.1` error[E0382]: use of moved value: `tup.1`
--> $DIR/borrowck-move-ref-pattern.rs:30:10 --> $DIR/borrowck-move-ref-pattern.rs:28:10
| |
LL | let (ref _x0, _x1, ref _x2, ..) = tup; LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| --- value moved here | --- value moved here
@ -131,7 +131,7 @@ LL | drop(tup.1);
= note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait = note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value: `tup.1` error[E0382]: borrow of moved value: `tup.1`
--> $DIR/borrowck-move-ref-pattern.rs:31:20 --> $DIR/borrowck-move-ref-pattern.rs:29:20
| |
LL | drop(tup.1); LL | drop(tup.1);
| ----- value moved here | ----- value moved here
@ -141,7 +141,7 @@ LL | let _x1_hold = &tup.1;
= note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait = 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 error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
--> $DIR/borrowck-move-ref-pattern.rs:33:20 --> $DIR/borrowck-move-ref-pattern.rs:31:20
| |
LL | let (.., ref mut _x3) = tup; LL | let (.., ref mut _x3) = tup;
| ----------- mutable borrow occurs here | ----------- mutable borrow occurs here
@ -152,7 +152,7 @@ LL | drop(_x3);
| --- mutable borrow later used here | --- mutable borrow later used here
error[E0499]: cannot borrow `tup.3` as mutable more than once at a time error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
--> $DIR/borrowck-move-ref-pattern.rs:34:20 --> $DIR/borrowck-move-ref-pattern.rs:32:20
| |
LL | let (.., ref mut _x3) = tup; LL | let (.., ref mut _x3) = tup;
| ----------- first mutable borrow occurs here | ----------- first mutable borrow occurs here
@ -164,7 +164,7 @@ LL | drop(_x3);
| --- first borrow later used here | --- first borrow later used here
error[E0499]: cannot borrow `tup.3` as mutable more than once at a time error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
--> $DIR/borrowck-move-ref-pattern.rs:35:14 --> $DIR/borrowck-move-ref-pattern.rs:33:14
| |
LL | let (.., ref mut _x3) = tup; LL | let (.., ref mut _x3) = tup;
| ----------- first mutable borrow occurs here | ----------- first mutable borrow occurs here
@ -176,7 +176,7 @@ LL | drop(_x3);
| --- first borrow later used here | --- first borrow later used here
error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
--> $DIR/borrowck-move-ref-pattern.rs:36:14 --> $DIR/borrowck-move-ref-pattern.rs:34:14
| |
LL | let (.., ref mut _x3) = tup; LL | let (.., ref mut _x3) = tup;
| ----------- mutable borrow occurs here | ----------- mutable borrow occurs here
@ -187,7 +187,7 @@ LL | drop(_x3);
| --- mutable borrow later used here | --- mutable borrow later used here
error[E0382]: use of moved value: `tup` error[E0382]: use of moved value: `tup`
--> $DIR/borrowck-move-ref-pattern.rs:45:14 --> $DIR/borrowck-move-ref-pattern.rs:43:14
| |
LL | let mut tup = (U, U, U); LL | let mut tup = (U, U, U);
| ------- move occurs because `tup` has type `(U, U, U)`, which does not implement the `Copy` trait | ------- move occurs because `tup` has type `(U, U, U)`, which does not implement the `Copy` trait

1
src/test/ui/pattern/move-ref-patterns/by-move-sub-pat-unreachable.rs
View file

@ -4,7 +4,6 @@
// check-pass // check-pass
#![feature(move_ref_pattern)]
#![feature(bindings_after_at)] #![feature(bindings_after_at)]
fn main() { fn main() {

23
src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.rs
View file

@ -1,23 +0,0 @@
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
}

66
src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.stderr
View file

@ -1,66 +0,0 @@
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: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
= 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: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
= 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: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
= 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: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
= 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 `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 `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`.

2
src/test/ui/pattern/move-ref-patterns/issue-53840.rs
View file

@ -1,7 +1,5 @@
// check-pass // check-pass
#![feature(move_ref_pattern)]
enum E { enum E {
Foo(String, String, String), Foo(String, String, String),
} }

2
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.rs
View file

@ -1,5 +1,3 @@
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct S; // Not `Copy`. struct S; // Not `Copy`.

54
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.stderr
View file

@ -1,5 +1,5 @@
error[E0382]: borrow of moved value: `tup0` error[E0382]: borrow of moved value: `tup0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:33:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:31:10
| |
LL | let mut tup0 = (S, S); LL | let mut tup0 = (S, S);
| -------- move occurs because `tup0` has type `(S, S)`, which does not implement the `Copy` trait | -------- move occurs because `tup0` has type `(S, S)`, which does not implement the `Copy` trait
@ -14,7 +14,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1` error[E0382]: borrow of moved value: `tup1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:34:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:32:10
| |
LL | let mut tup1 = (S, S, S); LL | let mut tup1 = (S, S, S);
| -------- move occurs because `tup1` has type `(S, S, S)`, which does not implement the `Copy` trait | -------- move occurs because `tup1` has type `(S, S, S)`, which does not implement the `Copy` trait
@ -29,7 +29,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2` error[E0382]: borrow of moved value: `tup2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:35:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:33:10
| |
LL | let tup2 = (S, S); LL | let tup2 = (S, S);
| ---- move occurs because `tup2` has type `(S, S)`, which does not implement the `Copy` trait | ---- move occurs because `tup2` has type `(S, S)`, which does not implement the `Copy` trait
@ -44,7 +44,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3` error[E0382]: borrow of moved value: `tup3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:36:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:34:10
| |
LL | let tup3 = (S, S, S); LL | let tup3 = (S, S, S);
| ---- move occurs because `tup3` has type `(S, S, S)`, which does not implement the `Copy` trait | ---- move occurs because `tup3` has type `(S, S, S)`, which does not implement the `Copy` trait
@ -59,7 +59,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4` error[E0382]: borrow of moved value: `tup4`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:41:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:39:10
| |
LL | let tup4 = (S, S); LL | let tup4 = (S, S);
| ---- move occurs because `tup4` has type `(S, S)`, which does not implement the `Copy` trait | ---- move occurs because `tup4` has type `(S, S)`, which does not implement the `Copy` trait
@ -74,7 +74,7 @@ LL | drop(&tup4.0);
| ^^^^^^^ value borrowed here after move | ^^^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0` error[E0382]: borrow of moved value: `arr0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:43:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:41:10
| |
LL | let mut arr0 = [S, S, S]; LL | let mut arr0 = [S, S, S];
| -------- move occurs because `arr0` has type `[S; 3]`, which does not implement the `Copy` trait | -------- move occurs because `arr0` has type `[S; 3]`, which does not implement the `Copy` trait
@ -89,7 +89,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1` error[E0382]: borrow of moved value: `arr1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:44:36 --> $DIR/move-ref-patterns-closure-captures-inside.rs:42:36
| |
LL | let mut arr1 = [S, S, S, S, S]; LL | let mut arr1 = [S, S, S, S, S];
| -------- move occurs because `arr1` has type `[S; 5]`, which does not implement the `Copy` trait | -------- move occurs because `arr1` has type `[S; 5]`, which does not implement the `Copy` trait
@ -104,7 +104,7 @@ LL | let [_, mov1, mov2, mov3, _] = &arr1;
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2` error[E0382]: borrow of moved value: `arr2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:45:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:43:10
| |
LL | let arr2 = [S, S, S]; LL | let arr2 = [S, S, S];
| ---- move occurs because `arr2` has type `[S; 3]`, which does not implement the `Copy` trait | ---- move occurs because `arr2` has type `[S; 3]`, which does not implement the `Copy` trait
@ -119,7 +119,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3` error[E0382]: borrow of moved value: `arr3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:46:36 --> $DIR/move-ref-patterns-closure-captures-inside.rs:44:36
| |
LL | let arr3 = [S, S, S, S, S]; LL | let arr3 = [S, S, S, S, S];
| ---- move occurs because `arr3` has type `[S; 5]`, which does not implement the `Copy` trait | ---- move occurs because `arr3` has type `[S; 5]`, which does not implement the `Copy` trait
@ -134,7 +134,7 @@ LL | let [_, mov1, mov2, mov3, _] = &arr3;
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup0` error[E0382]: borrow of moved value: `tup0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:77:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:75:10
| |
LL | let mut tup0: Option<(S, S)> = None; LL | let mut tup0: Option<(S, S)> = None;
| -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait | -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -148,7 +148,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1` error[E0382]: borrow of moved value: `tup1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:78:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:76:10
| |
LL | let mut tup1: Option<(S, S, S)> = None; LL | let mut tup1: Option<(S, S, S)> = None;
| -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait | -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@ -163,7 +163,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2` error[E0382]: borrow of moved value: `tup2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:79:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:77:10
| |
LL | let tup2: Option<(S, S)> = None; LL | let tup2: Option<(S, S)> = None;
| ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -178,7 +178,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3` error[E0382]: borrow of moved value: `tup3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:80:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:78:10
| |
LL | let tup3: Option<(S, S, S)> = None; LL | let tup3: Option<(S, S, S)> = None;
| ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@ -193,7 +193,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4` error[E0382]: borrow of moved value: `tup4`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:81:21 --> $DIR/move-ref-patterns-closure-captures-inside.rs:79:21
| |
LL | let tup4: Option<(S, S)> = None; LL | let tup4: Option<(S, S)> = None;
| ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -208,7 +208,7 @@ LL | m!((ref x, _) = &tup4);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0` error[E0382]: borrow of moved value: `arr0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:82:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:80:10
| |
LL | let mut arr0: Option<[S; 3]> = None; LL | let mut arr0: Option<[S; 3]> = None;
| -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait | -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@ -223,7 +223,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1` error[E0382]: borrow of moved value: `arr1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:83:35 --> $DIR/move-ref-patterns-closure-captures-inside.rs:81:35
| |
LL | let mut arr1: Option<[S; 5]> = None; LL | let mut arr1: Option<[S; 5]> = None;
| -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait | -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@ -238,7 +238,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr1);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2` error[E0382]: borrow of moved value: `arr2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:84:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:82:10
| |
LL | let arr2: Option<[S; 3]> = None; LL | let arr2: Option<[S; 3]> = None;
| ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait | ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@ -253,7 +253,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3` error[E0382]: borrow of moved value: `arr3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:85:35 --> $DIR/move-ref-patterns-closure-captures-inside.rs:83:35
| |
LL | let arr3: Option<[S; 5]> = None; LL | let arr3: Option<[S; 5]> = None;
| ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait | ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@ -267,7 +267,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr3);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup0` error[E0382]: borrow of moved value: `tup0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:113:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:111:10
| |
LL | let mut tup0: Option<(S, S)> = None; LL | let mut tup0: Option<(S, S)> = None;
| -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait | -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -281,7 +281,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1` error[E0382]: borrow of moved value: `tup1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:114:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:112:10
| |
LL | let mut tup1: Option<(S, S, S)> = None; LL | let mut tup1: Option<(S, S, S)> = None;
| -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait | -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@ -296,7 +296,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2` error[E0382]: borrow of moved value: `tup2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:115:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:113:10
| |
LL | let tup2: Option<(S, S)> = None; LL | let tup2: Option<(S, S)> = None;
| ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -311,7 +311,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3` error[E0382]: borrow of moved value: `tup3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:116:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:114:10
| |
LL | let tup3: Option<(S, S, S)> = None; LL | let tup3: Option<(S, S, S)> = None;
| ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@ -326,7 +326,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4` error[E0382]: borrow of moved value: `tup4`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:117:21 --> $DIR/move-ref-patterns-closure-captures-inside.rs:115:21
| |
LL | let tup4: Option<(S, S)> = None; LL | let tup4: Option<(S, S)> = None;
| ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait | ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@ -341,7 +341,7 @@ LL | m!((ref x, _) = &tup4);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0` error[E0382]: borrow of moved value: `arr0`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:118:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:116:10
| |
LL | let mut arr0: Option<[S; 3]> = None; LL | let mut arr0: Option<[S; 3]> = None;
| -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait | -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@ -356,7 +356,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1` error[E0382]: borrow of moved value: `arr1`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:119:35 --> $DIR/move-ref-patterns-closure-captures-inside.rs:117:35
| |
LL | let mut arr1: Option<[S; 5]> = None; LL | let mut arr1: Option<[S; 5]> = None;
| -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait | -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@ -371,7 +371,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr1);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2` error[E0382]: borrow of moved value: `arr2`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:120:10 --> $DIR/move-ref-patterns-closure-captures-inside.rs:118:10
| |
LL | let arr2: Option<[S; 3]> = None; LL | let arr2: Option<[S; 3]> = None;
| ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait | ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@ -386,7 +386,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move | ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3` error[E0382]: borrow of moved value: `arr3`
--> $DIR/move-ref-patterns-closure-captures-inside.rs:121:35 --> $DIR/move-ref-patterns-closure-captures-inside.rs:119:35
| |
LL | let arr3: Option<[S; 5]> = None; LL | let arr3: Option<[S; 5]> = None;
| ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait | ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait

2
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-pass.rs
View file

@ -1,7 +1,5 @@
// check-pass // check-pass
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;
fn accept_fn_once(_: impl FnOnce()) {} fn accept_fn_once(_: impl FnOnce()) {}

2
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.rs
View file

@ -1,5 +1,3 @@
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;
fn accept_fn_once(_: &impl FnOnce()) {} fn accept_fn_once(_: &impl FnOnce()) {}

6
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.stderr
View file

@ -1,5 +1,5 @@
error[E0525]: expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce` 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 --> $DIR/move-ref-patterns-closure-captures.rs:9:14
| |
LL | let c1 = || { LL | let c1 = || {
| ^^ this closure implements `FnOnce`, not `FnMut` | ^^ this closure implements `FnOnce`, not `FnMut`
@ -11,7 +11,7 @@ LL | accept_fn_mut(&c1);
| ------------- the requirement to implement `FnMut` derives from here | ------------- the requirement to implement `FnMut` derives from here
error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce` 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 --> $DIR/move-ref-patterns-closure-captures.rs:9:14
| |
LL | let c1 = || { LL | let c1 = || {
| ^^ this closure implements `FnOnce`, not `Fn` | ^^ this closure implements `FnOnce`, not `Fn`
@ -23,7 +23,7 @@ LL | accept_fn(&c1);
| --------- the requirement to implement `Fn` derives from here | --------- the requirement to implement `Fn` derives from here
error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut` 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 --> $DIR/move-ref-patterns-closure-captures.rs:20:14
| |
LL | let c2 = || { LL | let c2 = || {
| ^^ this closure implements `FnMut`, not `Fn` | ^^ this closure implements `FnMut`, not `Fn`

2
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.rs
View file

@ -1,5 +1,3 @@
#![feature(move_ref_pattern)]
fn main() { fn main() {
struct U; struct U;

4
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
View file

@ -1,5 +1,5 @@
error[E0507]: cannot move out of a shared reference error[E0507]: cannot move out of a shared reference
--> $DIR/move-ref-patterns-default-binding-modes.rs:10:22 --> $DIR/move-ref-patterns-default-binding-modes.rs:8:22
| |
LL | let (a, mut b) = &p; LL | let (a, mut b) = &p;
| ----- ^^ | ----- ^^
@ -8,7 +8,7 @@ LL | let (a, mut b) = &p;
| move occurs because `b` has type `U`, which does not implement the `Copy` trait | move occurs because `b` has type `U`, which does not implement the `Copy` trait
error[E0507]: cannot move out of a mutable reference error[E0507]: cannot move out of a mutable reference
--> $DIR/move-ref-patterns-default-binding-modes.rs:14:22 --> $DIR/move-ref-patterns-default-binding-modes.rs:12:22
| |
LL | let (a, mut b) = &mut p; LL | let (a, mut b) = &mut p;
| ----- ^^^^^^ | ----- ^^^^^^

2
src/test/ui/pattern/move-ref-patterns/move-ref-patterns-dynamic-semantics.rs
View file

@ -3,8 +3,6 @@
// This test checks the dynamic semantics and drop order of pattern matching // 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. // where a product pattern has both a by-move and by-ref binding.
#![feature(move_ref_pattern)]
use std::cell::RefCell; use std::cell::RefCell;
use std::rc::Rc; use std::rc::Rc;

2
src/test/ui/rfc-2005-default-binding-mode/for.rs
View file

@ -1,5 +1,3 @@
#![feature(move_ref_pattern)]
struct Foo {} struct Foo {}
pub fn main() { pub fn main() {

2
src/test/ui/rfc-2005-default-binding-mode/for.stderr
View file

@ -1,5 +1,5 @@
error[E0507]: cannot move out of a shared reference error[E0507]: cannot move out of a shared reference
--> $DIR/for.rs:8:23 --> $DIR/for.rs:6:23
| |
LL | for (n, mut m) in &tups { LL | for (n, mut m) in &tups {
| ----- ^^^^^ | ----- ^^^^^