New upstream version 1.67.1+dfsg1

[rustc.git] / src / test / ui / closures / 2229_closure_analysis / migrations / significant_drop.stderr

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:25:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.0;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.0`
LL |
LL |         let _t1 = t1.0;
   |                   ---- in Rust 2018, this closure captures all of `t1`, but in Rust 2021, it will only capture `t1.0`
LL |
LL |         let _t2 = t2.0;
   |                   ---- in Rust 2018, this closure captures all of `t2`, but in Rust 2021, it will only capture `t2.0`
...
LL | }
   | -
   | |
   | in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.0` will be dropped here as part of the closure
   | in Rust 2018, `t1` is dropped here, but in Rust 2021, only `t1.0` will be dropped here as part of the closure
   | in Rust 2018, `t2` is dropped here, but in Rust 2021, only `t2.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
note: the lint level is defined here
  --> $DIR/significant_drop.rs:2:9
   |
LL | #![deny(rust_2021_incompatible_closure_captures)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = (&t, &t1, &t2);
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:50:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.0;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.0`
LL |
LL |         let _t1 = t1.0;
   |                   ---- in Rust 2018, this closure captures all of `t1`, but in Rust 2021, it will only capture `t1.0`
...
LL | }
   | -
   | |
   | in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.0` will be dropped here as part of the closure
   | in Rust 2018, `t1` is dropped here, but in Rust 2021, only `t1.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t`, `t1` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = (&t, &t1);
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:71:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.0;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.0`
...
LL | }
   | - in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = &t;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:91:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.0;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.0`
...
LL | }
   | - in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = &t;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:109:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.0;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.0`
...
LL | }
   | - in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = &t;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:125:13
   |
LL |     let c = || {
   |             ^^
...
LL |         let _t = t.1;
   |                  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.1`
...
LL | }
   | - in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.1` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
   |
LL ~     let c = || {
LL +         let _ = &t;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:143:13
   |
LL |     let c = move || {
   |             ^^^^^^^
...
LL |         println!("{:?} {:?}", t1.1, t.1);
   |                               ----  --- in Rust 2018, this closure captures all of `t`, but in Rust 2021, it will only capture `t.1`
   |                               |
   |                               in Rust 2018, this closure captures all of `t1`, but in Rust 2021, it will only capture `t1.1`
...
LL | }
   | -
   | |
   | in Rust 2018, `t1` is dropped here, but in Rust 2021, only `t1.1` will be dropped here as part of the closure
   | in Rust 2018, `t` is dropped here, but in Rust 2021, only `t.1` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t1`, `t` to be fully captured
   |
LL ~     let c = move || {
LL +         let _ = (&t1, &t);
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:163:21
   |
LL |             let c = || {
   |                     ^^
...
LL |                 tuple.0;
   |                 ------- in Rust 2018, this closure captures all of `tuple`, but in Rust 2021, it will only capture `tuple.0`
...
LL |         }
   |         - in Rust 2018, `tuple` is dropped here, but in Rust 2021, only `tuple.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `tuple` to be fully captured
   |
LL ~             let c = || {
LL +                 let _ = &tuple;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:181:17
   |
LL |         let c = || {
   |                 ^^
...
LL |             tuple.0;
   |             ------- in Rust 2018, this closure captures all of `tuple`, but in Rust 2021, it will only capture `tuple.0`
...
LL |     };
   |     - in Rust 2018, `tuple` is dropped here, but in Rust 2021, only `tuple.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `tuple` to be fully captured
   |
LL ~         let c = || {
LL +             let _ = &tuple;
   |

error: changes to closure capture in Rust 2021 will affect drop order
  --> $DIR/significant_drop.rs:201:18
   |
LL |         let _c = || tup.0;
   |                  ^^ ----- in Rust 2018, this closure captures all of `tup`, but in Rust 2021, it will only capture `tup.0`
...
LL | }
   | - in Rust 2018, `tup` is dropped here, but in Rust 2021, only `tup.0` will be dropped here as part of the closure
   |
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `tup` to be fully captured
   |
LL |         let _c = || { let _ = &tup; tup.0 };
   |                     +++++++++++++++       +

error: aborting due to 10 previous errors