File: already-borrowed-as-mutable-if-let-133941.stderr

package info (click to toggle)
rustc 1.89.0%2Bdfsg1-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 906,624 kB
  • sloc: xml: 158,148; python: 34,888; javascript: 19,595; sh: 19,221; ansic: 13,046; cpp: 7,144; asm: 4,376; makefile: 692; lisp: 174; sql: 15
file content (91 lines) | stat: -rw-r--r-- 4,047 bytes parent folder | download | duplicates (11)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:24:9
   |
LL |     while let Some(_) = foo.f() {
   |                         -------
   |                         |
   |                         first mutable borrow occurs here
   |                         a temporary with access to the first borrow is created here ...
LL |
LL |         foo.g();
   |         ^^^ second mutable borrow occurs here
LL |
LL |     }
   |     - ... and the first borrow might be used here, when that temporary is dropped and runs the destructor for type `Option<Bar<'_>>`
   |
help: consider using the `matches!` macro
   |
LL -     while let Some(_) = foo.f() {
LL +     while matches!(foo.f(), Some(_)) {
   |

error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:29:9
   |
LL |     if let Some(_) = foo.f() {
   |                      -------
   |                      |
   |                      first mutable borrow occurs here
   |                      a temporary with access to the first borrow is created here ...
LL |
LL |         foo.g();
   |         ^^^ second mutable borrow occurs here
LL |
LL |     }
   |     - ... and the first borrow might be used here, when that temporary is dropped and runs the destructor for type `Option<Bar<'_>>`
   |
help: consider using the `matches!` macro
   |
LL -     if let Some(_) = foo.f() {
LL +     if matches!(foo.f(), Some(_)) {
   |

error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:33:9
   |
LL |     while let Some(_x) = foo.f() {
   |                          -------
   |                          |
   |                          first mutable borrow occurs here
   |                          a temporary with access to the first borrow is created here ...
LL |         foo.g();
   |         ^^^ second mutable borrow occurs here
LL |
LL |     }
   |     - ... and the first borrow might be used here, when that temporary is dropped and runs the destructor for type `Option<Bar<'_>>`

error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:37:9
   |
LL |     if let Some(_x) = foo.f() {
   |                       -------
   |                       |
   |                       first mutable borrow occurs here
   |                       a temporary with access to the first borrow is created here ...
LL |         foo.g();
   |         ^^^ second mutable borrow occurs here
LL |
LL |     }
   |     - ... and the first borrow might be used here, when that temporary is dropped and runs the destructor for type `Option<Bar<'_>>`

error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:40:45
   |
LL |     while let Some(_x) = {let _x = foo.f(); foo.g(); None::<()>} {
   |                                    ---      ^^^                - first borrow might be used here, when `_x` is dropped and runs the destructor for type `Option<Bar<'_>>`
   |                                    |        |
   |                                    |        second mutable borrow occurs here
   |                                    first mutable borrow occurs here

error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/already-borrowed-as-mutable-if-let-133941.rs:43:42
   |
LL |     if let Some(_x) = {let _x = foo.f(); foo.g(); None::<()>} {
   |                                 ---      ^^^                - first borrow might be used here, when `_x` is dropped and runs the destructor for type `Option<Bar<'_>>`
   |                                 |        |
   |                                 |        second mutable borrow occurs here
   |                                 first mutable borrow occurs here

error: aborting due to 6 previous errors

For more information about this error, try `rustc --explain E0499`.