}, " (into closure)"),
};
+ let extra_move_label = if need_note {
+ format!(" because it has type `{}`, which does not implement the `Copy` trait",
+ moved_lp.ty)
+ } else {
+ String::new()
+ };
// Annotate the use and the move in the span. Watch out for
// the case where the use and the move are the same. This
// means the use is in a loop.
err = if use_span == move_span {
err.span_label(
use_span,
- format!("value moved{} here in previous iteration of loop",
- move_note));
+ format!("value moved{} here in previous iteration of loop{}",
+ move_note,
+ extra_move_label));
err
} else {
err.span_label(use_span, format!("value {} here after move", verb_participle))
- .span_label(move_span, format!("value moved{} here", move_note));
+ .span_label(move_span, format!("value moved{} here{}", move_note, extra_move_label));
err
};
- if need_note {
- err.note(&format!("move occurs because `{}` has type `{}`, \
- which does not implement the `Copy` trait",
- self.loan_path_to_string(moved_lp),
- moved_lp.ty));
- }
-
// Note: we used to suggest adding a `ref binding` or calling
// `clone` but those suggestions have been removed because
// they are often not what you actually want to do, and were
LpDowncast(ref lp_base, variant_def_id) => {
out.push('(');
self.append_autoderefd_loan_path_to_string(&lp_base, out);
- out.push(':');
+ out.push_str(DOWNCAST_PRINTED_OPERATOR);
out.push_str(&self.tcx.item_path_str(variant_def_id));
out.push(')');
}
fn main() {
let x = NoCopy;
let f = move || { let y = x; };
- //~^ value moved (into closure) here
+ //~^ NOTE value moved (into closure) here because it has type `NoCopy`, which does not
let z = x;
//~^ ERROR use of moved value: `x`
- //~| value used here after move
- //~| move occurs because `x` has type `NoCopy`
+ //~| NOTE value used here after move
}
fn f00() {
let x = "hi".to_string();
let _y = Foo { f:x };
- //~^ value moved here
+ //~^ NOTE value moved here because it has type
touch(&x); //~ ERROR use of moved value: `x`
- //~^ value used here after move
- //~| move occurs because `x` has type `std::string::String`
+ //~^ NOTE value used here after move
}
fn f05() {
let x = "hi".to_string();
let _y = Foo { f:(((x))) };
- //~^ value moved here
+ //~^ NOTE value moved here because it has type
touch(&x); //~ ERROR use of moved value: `x`
+ //~^ NOTE value used here after move
}
fn f10() {
fn main() {
let mut x = Int(1);
- x //~ error: use of moved value: `x`
- //~^ value used here after move
+ x
+ //~^ error: use of moved value: `x`
+ //~| note: value used here after move
+=
- x; //~ value moved here
+ x;
+ //~^ note: value moved here because it has type `Int`, which does not implement the `Copy`
let y = Int(2);
- //~^ consider changing this to `mut y`
- y //~ error: cannot borrow immutable local variable `y` as mutable
- //~| cannot borrow
+ //~^ note: consider changing this to `mut y`
+ y
+ //~^ error: cannot borrow immutable local variable `y` as mutable
+ //~| note: cannot borrow mutably
+=
Int(1);
}
fn copy_after_move() {
let a: Box<_> = box A { x: box 0, y: 1 };
let _x = a.x;
- //~^ value moved here
- let _y = a.y; //~ ERROR use of moved
- //~^ move occurs because `a.x` has type `std::boxed::Box<isize>`
- //~| value used here after move
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
+ let _y = a.y; //~ ERROR use of moved value
+ //~^ NOTE value used here after move
}
fn move_after_move() {
let a: Box<_> = box B { x: box 0, y: box 1 };
let _x = a.x;
- //~^ value moved here
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
let _y = a.y; //~ ERROR use of moved
- //~^ move occurs because `a.x` has type `std::boxed::Box<isize>`
- //~| value used here after move
+ //~^ NOTE value used here after move
}
fn borrow_after_move() {
let a: Box<_> = box A { x: box 0, y: 1 };
let _x = a.x;
- //~^ value moved here
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
let _y = &a.y; //~ ERROR use of moved
- //~^ move occurs because `a.x` has type `std::boxed::Box<isize>`
- //~| value used here after move
+ //~^ NOTE value used here after move
}
fn move_after_borrow() {
let _x = &a.x;
let _y = a.y;
//~^ ERROR cannot move
- //~| move out of
+ //~| NOTE move out of
}
fn copy_after_mut_borrow() {
let _x = &mut a.x;
let _y = a.y;
//~^ ERROR cannot move
- //~| move out of
+ //~| NOTE move out of
}
fn borrow_after_mut_borrow() {
let mut a: Box<_> = box A { x: box 0, y: 1 };
let _x = &mut a.x;
let _y = &a.y; //~ ERROR cannot borrow
- //~^ immutable borrow occurs here (via `a.y`)
+ //~^ NOTE immutable borrow occurs here (via `a.y`)
}
fn mut_borrow_after_borrow() {
let mut a: Box<_> = box A { x: box 0, y: 1 };
let _x = &a.x;
let _y = &mut a.y; //~ ERROR cannot borrow
- //~^ mutable borrow occurs here (via `a.y`)
+ //~^ NOTE mutable borrow occurs here (via `a.y`)
}
fn copy_after_move_nested() {
let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
let _x = a.x.x;
- //~^ value moved here
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
let _y = a.y; //~ ERROR use of collaterally moved
- //~| value used here after move
+ //~^ NOTE value used here after move
}
fn move_after_move_nested() {
let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
let _x = a.x.x;
- //~^ value moved here
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
let _y = a.y; //~ ERROR use of collaterally moved
- //~| value used here after move
+ //~^ NOTE value used here after move
}
fn borrow_after_move_nested() {
let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
let _x = a.x.x;
- //~^ value moved here
+ //~^ NOTE value moved here because it has type `std::boxed::Box<isize>`, which does not
let _y = &a.y; //~ ERROR use of collaterally moved
- //~| value used here after move
+ //~^ NOTE value used here after move
}
fn move_after_borrow_nested() {
let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
let _x = &a.x.x;
- //~^ borrow of `a.x.x` occurs here
+ //~^ NOTE borrow of `a.x.x` occurs here
let _y = a.y;
//~^ ERROR cannot move
- //~| move out of
+ //~| NOTE move out of
}
fn copy_after_mut_borrow_nested() {
let _x = &mut a.x.x;
let _y = a.y;
//~^ ERROR cannot move
- //~| move out of
+ //~| NOTE move out of
}
fn borrow_after_mut_borrow_nested() {
let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
let _x = &mut a.x.x;
- //~^ mutable borrow occurs here
+ //~^ NOTE mutable borrow occurs here
let _y = &a.y; //~ ERROR cannot borrow
- //~^ immutable borrow occurs here
+ //~^ NOTE immutable borrow occurs here
}
fn mut_borrow_after_borrow_nested() {
let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
let _x = &a.x.x;
- //~^ immutable borrow occurs here
+ //~^ NOTE immutable borrow occurs here
let _y = &mut a.y; //~ ERROR cannot borrow
- //~^ mutable borrow occurs here
+ //~^ NOTE mutable borrow occurs here
}
fn main() {
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn main(){
+ let maybe = Some(vec![true, true]);
+
+ loop {
+ if let Some(thing) = maybe {
+ }
+ }
+}
--- /dev/null
+error[E0382]: use of partially moved value: `maybe`
+ --> $DIR/issue-41962.rs:15:30
+ |
+15 | if let Some(thing) = maybe {
+ | ----- ^^^^^ value used here after move
+ | |
+ | value moved here because it has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait
+
+error[E0382]: use of moved value: `(maybe as std::prelude::v1::Some).0`
+ --> $DIR/issue-41962.rs:15:21
+ |
+15 | if let Some(thing) = maybe {
+ | ^^^^^ value moved here in previous iteration of loop because it has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait
+
+error: aborting due to 2 previous errors
+
let y = match x {
Foo {f} => {}
+ //~^ NOTE value moved here because it has type `std::string::String`, which does not
};
touch(&x); //~ ERROR use of partially moved value: `x`
- //~^ value used here after move
- //~| move occurs because `x.f` has type `std::string::String`
+ //~^ NOTE value used here after move
}
fn main() {}
projects / rust.git / commitdiff