Test interaction between RFC 2229 migration and use closures

Author: spastorino

tests/ui/ergonomic-clones/closure/rfc2229-migration.fixed

@@ -0,0 +1,35 @@
+//@ run-rustfix
+//@ edition:2018
+//@ check-pass
+#![feature(ergonomic_clones)]
+#![warn(rust_2021_compatibility)]
+#![allow(incomplete_features)]
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+macro_rules! m {
+    (@ $body:expr) => {{
+        let f = use || $body;
+        //~^ WARNING: drop order
+        f();
+    }};
+    ($body:block) => {{
+        m!(@ $body);
+    }};
+}
+
+fn main() {
+    let a = (Foo(0), Foo(1));
+    m!({
+        let _ = &a;
+        //~^ HELP: add a dummy
+        let x = a.0;
+        println!("{:?}", x);
+    });
+}

tests/ui/ergonomic-clones/closure/rfc2229-migration.rs

@@ -0,0 +1,34 @@
+//@ run-rustfix
+//@ edition:2018
+//@ check-pass
+#![feature(ergonomic_clones)]
+#![warn(rust_2021_compatibility)]
+#![allow(incomplete_features)]
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+macro_rules! m {
+    (@ $body:expr) => {{
+        let f = use || $body;
+        //~^ WARNING: drop order
+        f();
+    }};
+    ($body:block) => {{
+        m!(@ $body);
+    }};
+}
+
+fn main() {
+    let a = (Foo(0), Foo(1));
+    m!({
+        //~^ HELP: add a dummy
+        let x = a.0;
+        println!("{:?}", x);
+    });
+}

tests/ui/ergonomic-clones/closure/rfc2229-migration.stderr

@@ -0,0 +1,33 @@
+warning: changes to closure capture in Rust 2021 will affect drop order
+  --> $DIR/rfc2229-migration.rs:18:17
+   |
+LL |           let f = use || $body;
+   |                   ^^^^^^
+...
+LL |       }};
+   |       - in Rust 2018, `a` is dropped here, but in Rust 2021, only `a.0` will be dropped here as part of the closure
+...
+LL | /     m!({
+LL | |
+LL | |         let x = a.0;
+   | |                 --- in Rust 2018, this closure captures all of `a`, but in Rust 2021, it will only capture `a.0`
+LL | |         println!("{:?}", x);
+LL | |     });
+   | |______- in this macro invocation
+   |
+   = 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/rfc2229-migration.rs:5:9
+   |
+LL | #![warn(rust_2021_compatibility)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[warn(rust_2021_incompatible_closure_captures)]` implied by `#[warn(rust_2021_compatibility)]`
+   = note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: add a dummy let to cause `a` to be fully captured
+   |
+LL ~     m!({
+LL +         let _ = &a;
+   |
+
+warning: 1 warning emitted
+