rust/tests/ui/closures/2229_closure_analysis/diagnostics/cant-mutate-imm-borrow.stderr

error[E0596]: cannot borrow `*z.0.0` as mutable, as it is behind a `&` reference
  --> $DIR/cant-mutate-imm-borrow.rs:13:17
   |
LL |     let mut c = || {
   |                 ^^ cannot borrow as mutable
LL |
LL |         z.0.0.0 = format!("X1");
   |         ------- mutable borrow occurs due to use of `*z.0.0` in closure

error: aborting due to previous error

For more information about this error, try `rustc --explain E0596`.
2229: Reduce the size of closures with `capture_disjoint_fields` One key observation while going over the closure size profile of rustc was that we are disjointly capturing one or more fields starting at an immutable reference. Disjoint capture over immutable reference doesn't add too much value because the fields can either be borrowed immutably or copied. One possible edge case of the optimization is when a fields of a struct have a longer lifetime than the structure, therefore we can't completely get rid of all the accesses on top of sharef refs, only the rightmost one. Here is a possible example: ```rust struct MyStruct<'a> { a: &'static A, b: B, c: C<'a>, } fn foo<'a, 'b>(m: &'a MyStruct<'b>) -> impl FnMut() + 'static { let c = \|\| drop(&m.a.field_of_a); // Here we really do want to capture `m.a` because that outlives `'static` // If we capture `m`, then the closure no longer outlives `'static' // it is constrained to `'a` } ``` 2021-06-27 20:19:39 -05:00			error[E0596]: cannot borrow `*z.0.0` as mutable, as it is behind a `&` reference
Editon 2021 enables precise capture 2021-06-27 01:22:46 -05:00			`--> $DIR/cant-mutate-imm-borrow.rs:13:17`
Test cases for handling mutable references 2020-12-13 00:29:20 -06:00			`\|`
			`LL \| let mut c = \|\| {`
			`\| ^^ cannot borrow as mutable`
			`LL \|`
			`LL \| z.0.0.0 = format!("X1");`
2229: Reduce the size of closures with `capture_disjoint_fields` One key observation while going over the closure size profile of rustc was that we are disjointly capturing one or more fields starting at an immutable reference. Disjoint capture over immutable reference doesn't add too much value because the fields can either be borrowed immutably or copied. One possible edge case of the optimization is when a fields of a struct have a longer lifetime than the structure, therefore we can't completely get rid of all the accesses on top of sharef refs, only the rightmost one. Here is a possible example: ```rust struct MyStruct<'a> { a: &'static A, b: B, c: C<'a>, } fn foo<'a, 'b>(m: &'a MyStruct<'b>) -> impl FnMut() + 'static { let c = \|\| drop(&m.a.field_of_a); // Here we really do want to capture `m.a` because that outlives `'static` // If we capture `m`, then the closure no longer outlives `'static' // it is constrained to `'a` } ``` 2021-06-27 20:19:39 -05:00			\| ------- mutable borrow occurs due to use of `*z.0.0` in closure
Test cases for handling mutable references 2020-12-13 00:29:20 -06:00
Editon 2021 enables precise capture 2021-06-27 01:22:46 -05:00			`error: aborting due to previous error`
Test cases for handling mutable references 2020-12-13 00:29:20 -06:00
Fix incorrect use mut diagnostics 2020-12-12 23:11:15 -06:00			For more information about this error, try `rustc --explain E0596`.