rust/tests/ui/suggestions/borrow-for-loop-head.stderr

error[E0505]: cannot move out of `a` because it is borrowed
  --> $DIR/borrow-for-loop-head.rs:4:18
   |
LL |     let a = vec![1, 2, 3];
   |         - binding `a` declared here
LL |     for i in &a {
   |              -- borrow of `a` occurs here
LL |         for j in a {
   |                  ^ move out of `a` occurs here

error[E0382]: use of moved value: `a`
  --> $DIR/borrow-for-loop-head.rs:4:18
   |
LL |     let a = vec![1, 2, 3];
   |         - move occurs because `a` has type `Vec<i32>`, which does not implement the `Copy` trait
LL |     for i in &a {
   |     ----------- inside of this loop
LL |         for j in a {
   |                  ^ `a` moved due to this implicit call to `.into_iter()`, in previous iteration of loop
   |
note: `into_iter` takes ownership of the receiver `self`, which moves `a`
  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
help: consider iterating over a slice of the `Vec<i32>`'s content to avoid moving into the `for` loop
   |
LL |         for j in &a {
   |                  +

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0382, E0505.
For more information about an error, try `rustc --explain E0382`.
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00			error[E0505]: cannot move out of `a` because it is borrowed
			`--> $DIR/borrow-for-loop-head.rs:4:18`
			`\|`
Tweak E0597 CC #99430 2023-01-14 21:06:44 -06:00			`LL \| let a = vec![1, 2, 3];`
			\| - binding `a` declared here
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00			`LL \| for i in &a {`
update tests for migrate mode by default 2019-04-22 02:40:08 -05:00			\| -- borrow of `a` occurs here
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00			`LL \| for j in a {`
			\| ^ move out of `a` occurs here

			error[E0382]: use of moved value: `a`
			`--> $DIR/borrow-for-loop-head.rs:4:18`
			`\|`
update tests for migrate mode by default 2019-04-22 02:40:08 -05:00			`LL \| let a = vec![1, 2, 3];`
pretty: trim paths of unique symbols If a symbol name can only be imported from one place for a type, and as long as it was not glob-imported anywhere in the current crate, we can trim its printed path and print only the name. This has wide implications on error messages with types, for example, shortening `std::vec::Vec` to just `Vec`, as long as there is no other `Vec` importable anywhere. This adds a new '-Z trim-diagnostic-paths=false' option to control this feature. On the good path, with no diagnosis printed, we should try to avoid issuing this query, so we need to prevent trimmed_def_paths query on several cases. This change also relies on a previous commit that differentiates between `Debug` and `Display` on various rustc types, where the latter is trimmed and presented to the user and the former is not. 2020-09-02 02:40:56 -05:00			\| - move occurs because `a` has type `Vec<i32>`, which does not implement the `Copy` trait
update tests for migrate mode by default 2019-04-22 02:40:08 -05:00			`LL \| for i in &a {`
Suggest `.clone()` or `ref binding` on E0382 2022-11-02 23:22:24 -05:00			`\| ----------- inside of this loop`
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00			`LL \| for j in a {`
Tweak move error Point at method definition that causes type to be consumed. Fix #94056. 2022-03-01 22:30:16 -06:00			\| ^ `a` moved due to this implicit call to `.into_iter()`, in previous iteration of loop
Explain method-call move errors in loops PR #73708 added a more detailed explanation of move errors that occur due to a call to a method that takes `self`. This PR extends that logic to work when a move error occurs due to a method call in the previous iteration of a loop. 2020-12-22 21:15:40 -06:00			`\|`
Clarify what "this" means 2022-12-12 06:07:09 -06:00			note: `into_iter` takes ownership of the receiver `self`, which moves `a`
Explain method-call move errors in loops PR #73708 added a more detailed explanation of move errors that occur due to a call to a method that takes `self`. This PR extends that logic to work when a move error occurs due to a method call in the previous iteration of a loop. 2020-12-22 21:15:40 -06:00			`--> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL`
Tweak move error Point at method definition that causes type to be consumed. Fix #94056. 2022-03-01 22:30:16 -06:00			help: consider iterating over a slice of the `Vec<i32>`'s content to avoid moving into the `for` loop
			`\|`
			`LL \| for j in &a {`
			`\| +`
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00
			`error: aborting due to 2 previous errors`

hide `--explain` hint if error has no extended info 2019-04-17 12:26:38 -05:00			`Some errors have detailed explanations: E0382, E0505.`
When moving out of a for loop head, suggest borrowing it When encountering code like the following, suggest borrowing the for loop head to avoid moving it into the for loop pattern: ``` fn main() { let a = vec![1, 2, 3]; for i in &a { for j in a { println!("{} * {} = {}", i, j, i * j); } } } ``` 2019-03-14 18:09:47 -05:00			For more information about an error, try `rustc --explain E0382`.