Auto merge of #78801 - sexxi-goose:min_capture, r=nikomatsakis

RFC-2229: Implement Precise Capture Analysis

### This PR introduces
- Feature gate for RFC-2229 (incomplete) `capture_disjoint_field`
- Rustc Attribute to print out the capture analysis `rustc_capture_analysis`
- Precise capture analysis

### Description of the analysis
1. If the feature gate is not set then all variables that are not local to the closure will be added to the list of captures. (This is for backcompat)
2. The rest of the analysis is based entirely on how the captured `Place`s are used within the closure. Precise information (i.e. projections) about the `Place` is maintained throughout.
3. To reduce the amount of information we need to keep track of, we do a minimization step. In this step, we determine a list such that no Place within this list represents an ancestor path to another entry in the list.  Check rust-lang/project-rfc-2229#9 for more detailed examples.
4. To keep the compiler functional as before we implement a Bridge between the results of this new analysis to existing data structures used for closure captures. Note the new capture analysis results are only part of MaybeTypeckTables that is the information is only available during typeck-ing.

### Known issues
- Statements like `let _ = x` will make the compiler ICE when used within a closure with the feature enabled. More generally speaking the issue is caused by `let` statements that create no bindings and are init'ed using a Place expression.

### Testing
We removed the code that would handle the case where the feature gate is not set, to enable the feature as default and did a bors try and perf run. More information here: #78762

### Thanks
This has been slowly in the works for a while now.
I want to call out `@Azhng` `@ChrisPardy` `@null-sleep` `@jenniferwills` `@logmosier` `@roxelo` for working on this and the previous PRs that led up to this, `@nikomatsakis` for guiding us.

Closes rust-lang/project-rfc-2229#7
Closes rust-lang/project-rfc-2229#9
Closes rust-lang/project-rfc-2229#6
Closes rust-lang/project-rfc-2229#19

r? `@nikomatsakis`

27 files changed, 1630 insertions, 2 deletions

diff --git a/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.rs b/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.rs
new file mode 100644
index 00000000000..131af6a10c8
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.rs
@@ -0,0 +1,24 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| `#[warn(incomplete_features)]` on by default
+//~| see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+// Ensure that capture analysis results in arrays being completely captured.
+fn main() {
+    let mut m = [1, 2, 3, 4, 5];
+
+    let mut c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        m[0] += 10;
+        //~^ NOTE: Capturing m[] -> MutBorrow
+        //~| NOTE: Min Capture m[] -> MutBorrow
+        m[1] += 40;
+    };
+
+    c();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.stderr b/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.stderr
new file mode 100644
index 00000000000..2a350f30331
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/arrays-completely-captured.rs:11:17
+   |
+LL |     let mut c = #[rustc_capture_analysis]
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/arrays-completely-captured.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/arrays-completely-captured.rs:14:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         m[0] += 10;
+...  |
+LL | |         m[1] += 40;
+LL | |     };
+   | |_____^
+   |
+note: Capturing m[] -> MutBorrow
+  --> $DIR/arrays-completely-captured.rs:17:9
+   |
+LL |         m[0] += 10;
+   |         ^
+
+error: Min Capture analysis includes:
+  --> $DIR/arrays-completely-captured.rs:14:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         m[0] += 10;
+...  |
+LL | |         m[1] += 40;
+LL | |     };
+   | |_____^
+   |
+note: Min Capture m[] -> MutBorrow
+  --> $DIR/arrays-completely-captured.rs:17:9
+   |
+LL |         m[0] += 10;
+   |         ^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.rs b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.rs
new file mode 100644
index 00000000000..ba495508537
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.rs
@@ -0,0 +1,33 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let mut p = Point { x: 10, y: 10 };
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ First Pass analysis includes:
+    //~| Min Capture analysis includes:
+        println!("{}", p.x);
+        //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
+    };
+
+    // `c` should only capture `p.x`, therefore mutating `p.y` is allowed.
+    let py = &mut p.y;
+
+    c();
+    *py = 20;
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.stderr b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.stderr
new file mode 100644
index 00000000000..5fac6963afd
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/capture-disjoint-field-struct.rs:17:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/capture-disjoint-field-struct.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/capture-disjoint-field-struct.rs:20:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", p.x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing p[(0, 0)] -> ImmBorrow
+  --> $DIR/capture-disjoint-field-struct.rs:23:24
+   |
+LL |         println!("{}", p.x);
+   |                        ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/capture-disjoint-field-struct.rs:20:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", p.x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture p[(0, 0)] -> ImmBorrow
+  --> $DIR/capture-disjoint-field-struct.rs:23:24
+   |
+LL |         println!("{}", p.x);
+   |                        ^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.rs b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.rs
new file mode 100644
index 00000000000..c1693fbad79
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.rs
@@ -0,0 +1,28 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+fn main() {
+    let mut t = (10, 10);
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ First Pass analysis includes:
+    //~| Min Capture analysis includes:
+        println!("{}", t.0);
+        //~^ NOTE: Capturing t[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture t[(0, 0)] -> ImmBorrow
+    };
+
+    // `c` only captures t.0, therefore mutating t.1 is allowed.
+    let t1 = &mut t.1;
+
+    c();
+    *t1 = 20;
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.stderr b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.stderr
new file mode 100644
index 00000000000..1bfd63f2ace
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/capture-disjoint-field-tuple.rs:12:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/capture-disjoint-field-tuple.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/capture-disjoint-field-tuple.rs:15:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", t.0);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing t[(0, 0)] -> ImmBorrow
+  --> $DIR/capture-disjoint-field-tuple.rs:18:24
+   |
+LL |         println!("{}", t.0);
+   |                        ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/capture-disjoint-field-tuple.rs:15:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", t.0);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture t[(0, 0)] -> ImmBorrow
+  --> $DIR/capture-disjoint-field-tuple.rs:18:24
+   |
+LL |         println!("{}", t.0);
+   |                        ^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-enums.rs b/src/test/ui/closures/2229_closure_analysis/capture-enums.rs
new file mode 100644
index 00000000000..8fb2f7f16d6
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-enums.rs
@@ -0,0 +1,64 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+enum Info {
+    Point(i32, i32, String),
+    Meta(String, Vec<(i32, i32)>)
+}
+
+fn multi_variant_enum() {
+    let point = Info::Point(10, -10, "1".into());
+
+    let vec = Vec::new();
+    let meta = Info::Meta("meta".into(), vec);
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ First Pass analysis includes:
+    //~| Min Capture analysis includes:
+        if let Info::Point(_, _, str) = point {
+            //~^ NOTE: Capturing point[] -> ImmBorrow
+            //~| NOTE: Capturing point[(2, 0)] -> ByValue
+            //~| NOTE: Min Capture point[] -> ByValue
+            println!("{}", str);
+        }
+
+        if let Info::Meta(_, v) = meta {
+            //~^ NOTE: Capturing meta[] -> ImmBorrow
+            //~| NOTE: Capturing meta[(1, 1)] -> ByValue
+            //~| NOTE: Min Capture meta[] -> ByValue
+            println!("{:?}", v);
+        }
+    };
+
+    c();
+}
+
+enum SingleVariant {
+    Point(i32, i32, String),
+}
+
+fn single_variant_enum() {
+    let point = SingleVariant::Point(10, -10, "1".into());
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ First Pass analysis includes:
+    //~| Min Capture analysis includes:
+        let SingleVariant::Point(_, _, str) = point;
+        //~^ NOTE: Capturing point[(2, 0)] -> ByValue
+        //~| NOTE: Min Capture point[(2, 0)] -> ByValue
+        println!("{}", str);
+    };
+
+    c();
+}
+
+fn main() {}
diff --git a/src/test/ui/closures/2229_closure_analysis/capture-enums.stderr b/src/test/ui/closures/2229_closure_analysis/capture-enums.stderr
new file mode 100644
index 00000000000..ebe1dcb9884
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/capture-enums.stderr
@@ -0,0 +1,122 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/capture-enums.rs:18:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/capture-enums.rs:49:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/capture-enums.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/capture-enums.rs:21:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         if let Info::Point(_, _, str) = point {
+...  |
+LL | |         }
+LL | |     };
+   | |_____^
+   |
+note: Capturing point[] -> ImmBorrow
+  --> $DIR/capture-enums.rs:24:41
+   |
+LL |         if let Info::Point(_, _, str) = point {
+   |                                         ^^^^^
+note: Capturing point[(2, 0)] -> ByValue
+  --> $DIR/capture-enums.rs:24:41
+   |
+LL |         if let Info::Point(_, _, str) = point {
+   |                                         ^^^^^
+note: Capturing meta[] -> ImmBorrow
+  --> $DIR/capture-enums.rs:31:35
+   |
+LL |         if let Info::Meta(_, v) = meta {
+   |                                   ^^^^
+note: Capturing meta[(1, 1)] -> ByValue
+  --> $DIR/capture-enums.rs:31:35
+   |
+LL |         if let Info::Meta(_, v) = meta {
+   |                                   ^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/capture-enums.rs:21:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         if let Info::Point(_, _, str) = point {
+...  |
+LL | |         }
+LL | |     };
+   | |_____^
+   |
+note: Min Capture point[] -> ByValue
+  --> $DIR/capture-enums.rs:24:41
+   |
+LL |         if let Info::Point(_, _, str) = point {
+   |                                         ^^^^^
+note: Min Capture meta[] -> ByValue
+  --> $DIR/capture-enums.rs:31:35
+   |
+LL |         if let Info::Meta(_, v) = meta {
+   |                                   ^^^^
+
+error: First Pass analysis includes:
+  --> $DIR/capture-enums.rs:52:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let SingleVariant::Point(_, _, str) = point;
+...  |
+LL | |         println!("{}", str);
+LL | |     };
+   | |_____^
+   |
+note: Capturing point[(2, 0)] -> ByValue
+  --> $DIR/capture-enums.rs:55:47
+   |
+LL |         let SingleVariant::Point(_, _, str) = point;
+   |                                               ^^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/capture-enums.rs:52:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let SingleVariant::Point(_, _, str) = point;
+...  |
+LL | |         println!("{}", str);
+LL | |     };
+   | |_____^
+   |
+note: Min Capture point[(2, 0)] -> ByValue
+  --> $DIR/capture-enums.rs:55:47
+   |
+LL |         let SingleVariant::Point(_, _, str) = point;
+   |                                               ^^^^^
+
+error: aborting due to 6 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/destructure_patterns.rs b/src/test/ui/closures/2229_closure_analysis/destructure_patterns.rs
new file mode 100644
index 00000000000..080ca0405b4
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/destructure_patterns.rs
@@ -0,0 +1,77 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+// Test to ensure Index projections are handled properly during capture analysis
+// The array should be moved in entirety, even though only some elements are used.
+fn arrays() {
+    let arr: [String; 5] = [format!("A"), format!("B"), format!("C"), format!("D"), format!("E")];
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        let [a, b, .., e] = arr;
+        //~^ NOTE: Capturing arr[Index] -> ByValue
+        //~| NOTE: Min Capture arr[] -> ByValue
+        assert_eq!(a, "A");
+        assert_eq!(b, "B");
+        assert_eq!(e, "E");
+    };
+
+    c();
+}
+
+struct Point {
+    x: i32,
+    y: i32,
+    id: String,
+}
+
+fn structs() {
+    let mut p = Point { x: 10, y: 10, id: String::new() };
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        let Point { x: ref mut x, y: _, id: moved_id } = p;
+        //~^ NOTE: Capturing p[(0, 0)] -> MutBorrow
+        //~| NOTE: Capturing p[(2, 0)] -> ByValue
+        //~| NOTE: Min Capture p[(0, 0)] -> MutBorrow
+        //~| NOTE: Min Capture p[(2, 0)] -> ByValue
+
+        println!("{}, {}", x, moved_id);
+    };
+    c();
+}
+
+fn tuples() {
+    let mut t = (10, String::new(), (String::new(), 42));
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        let (ref mut x, ref ref_str, (moved_s, _)) = t;
+        //~^ NOTE: Capturing t[(0, 0)] -> MutBorrow
+        //~| NOTE: Capturing t[(1, 0)] -> ImmBorrow
+        //~| NOTE: Capturing t[(2, 0),(0, 0)] -> ByValue
+        //~| NOTE: Min Capture t[(0, 0)] -> MutBorrow
+        //~| NOTE: Min Capture t[(1, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture t[(2, 0),(0, 0)] -> ByValue
+
+        println!("{}, {} {}", x, ref_str, moved_s);
+    };
+    c();
+}
+
+fn main() {}
diff --git a/src/test/ui/closures/2229_closure_analysis/destructure_patterns.stderr b/src/test/ui/closures/2229_closure_analysis/destructure_patterns.stderr
new file mode 100644
index 00000000000..06ccc2d7a88
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/destructure_patterns.stderr
@@ -0,0 +1,177 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/destructure_patterns.rs:12:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/destructure_patterns.rs:38:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/destructure_patterns.rs:58:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/destructure_patterns.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/destructure_patterns.rs:15:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let [a, b, .., e] = arr;
+...  |
+LL | |         assert_eq!(e, "E");
+LL | |     };
+   | |_____^
+   |
+note: Capturing arr[Index] -> ByValue
+  --> $DIR/destructure_patterns.rs:18:29
+   |
+LL |         let [a, b, .., e] = arr;
+   |                             ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/destructure_patterns.rs:15:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let [a, b, .., e] = arr;
+...  |
+LL | |         assert_eq!(e, "E");
+LL | |     };
+   | |_____^
+   |
+note: Min Capture arr[] -> ByValue
+  --> $DIR/destructure_patterns.rs:18:29
+   |
+LL |         let [a, b, .., e] = arr;
+   |                             ^^^
+
+error: First Pass analysis includes:
+  --> $DIR/destructure_patterns.rs:41:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+...  |
+LL | |         println!("{}, {}", x, moved_id);
+LL | |     };
+   | |_____^
+   |
+note: Capturing p[(0, 0)] -> MutBorrow
+  --> $DIR/destructure_patterns.rs:44:58
+   |
+LL |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+   |                                                          ^
+note: Capturing p[(2, 0)] -> ByValue
+  --> $DIR/destructure_patterns.rs:44:58
+   |
+LL |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+   |                                                          ^
+
+error: Min Capture analysis includes:
+  --> $DIR/destructure_patterns.rs:41:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+...  |
+LL | |         println!("{}, {}", x, moved_id);
+LL | |     };
+   | |_____^
+   |
+note: Min Capture p[(0, 0)] -> MutBorrow
+  --> $DIR/destructure_patterns.rs:44:58
+   |
+LL |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+   |                                                          ^
+note: Min Capture p[(2, 0)] -> ByValue
+  --> $DIR/destructure_patterns.rs:44:58
+   |
+LL |         let Point { x: ref mut x, y: _, id: moved_id } = p;
+   |                                                          ^
+
+error: First Pass analysis includes:
+  --> $DIR/destructure_patterns.rs:61:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+...  |
+LL | |         println!("{}, {} {}", x, ref_str, moved_s);
+LL | |     };
+   | |_____^
+   |
+note: Capturing t[(0, 0)] -> MutBorrow
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+note: Capturing t[(1, 0)] -> ImmBorrow
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+note: Capturing t[(2, 0),(0, 0)] -> ByValue
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+
+error: Min Capture analysis includes:
+  --> $DIR/destructure_patterns.rs:61:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+...  |
+LL | |         println!("{}, {} {}", x, ref_str, moved_s);
+LL | |     };
+   | |_____^
+   |
+note: Min Capture t[(0, 0)] -> MutBorrow
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+note: Min Capture t[(1, 0)] -> ImmBorrow
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+note: Min Capture t[(2, 0),(0, 0)] -> ByValue
+  --> $DIR/destructure_patterns.rs:64:54
+   |
+LL |         let (ref mut x, ref ref_str, (moved_s, _)) = t;
+   |                                                      ^
+
+error: aborting due to 9 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.rs b/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.rs
new file mode 100644
index 00000000000..a3222635b62
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.rs
@@ -0,0 +1,20 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+fn main() {
+    let s = format!("s");
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        println!("This uses new capture analyysis to capture s={}", s);
+        //~^ NOTE: Capturing s[] -> ImmBorrow
+        //~| NOTE: Min Capture s[] -> ImmBorrow
+    };
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.stderr b/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.stderr
new file mode 100644
index 00000000000..a031360ed34
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:10:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:13:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("This uses new capture analyysis to capture s={}", s);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing s[] -> ImmBorrow
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:16:69
+   |
+LL |         println!("This uses new capture analyysis to capture s={}", s);
+   |                                                                     ^
+
+error: Min Capture analysis includes:
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:13:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("This uses new capture analyysis to capture s={}", s);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture s[] -> ImmBorrow
+  --> $DIR/feature-gate-capture_disjoint_fields.rs:16:69
+   |
+LL |         println!("This uses new capture analyysis to capture s={}", s);
+   |                                                                     ^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.rs b/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.rs
new file mode 100644
index 00000000000..9466e103897
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.rs
@@ -0,0 +1,45 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+struct Filter {
+    div: i32,
+}
+impl Filter {
+    fn allowed(&self, x: i32) -> bool {
+        x % self.div == 1
+    }
+}
+
+struct Data {
+    filter: Filter,
+    list: Vec<i32>,
+}
+impl Data {
+    fn update(&mut self) {
+        // The closure passed to filter only captures self.filter,
+        // therefore mutating self.list is allowed.
+        self.list.retain(
+            #[rustc_capture_analysis]
+            |v| self.filter.allowed(*v),
+            //~^ ERROR: First Pass analysis includes:
+            //~| ERROR: Min Capture analysis includes:
+            //~| NOTE: Capturing self[Deref,(0, 0)] -> ImmBorrow
+            //~| NOTE: Min Capture self[Deref,(0, 0)] -> ImmBorrow
+        );
+    }
+}
+
+fn main() {
+    let mut d = Data { filter: Filter { div: 3 }, list: Vec::new() };
+
+    for i in 1..10 {
+        d.list.push(i);
+    }
+
+    d.update();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.stderr b/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.stderr
new file mode 100644
index 00000000000..e9420fe5a0c
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.stderr
@@ -0,0 +1,35 @@
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/filter-on-struct-member.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/filter-on-struct-member.rs:28:13
+   |
+LL |             |v| self.filter.allowed(*v),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: Capturing self[Deref,(0, 0)] -> ImmBorrow
+  --> $DIR/filter-on-struct-member.rs:28:17
+   |
+LL |             |v| self.filter.allowed(*v),
+   |                 ^^^^^^^^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/filter-on-struct-member.rs:28:13
+   |
+LL |             |v| self.filter.allowed(*v),
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: Min Capture self[Deref,(0, 0)] -> ImmBorrow
+  --> $DIR/filter-on-struct-member.rs:28:17
+   |
+LL |             |v| self.filter.allowed(*v),
+   |                 ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
diff --git a/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.rs b/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.rs
new file mode 100644
index 00000000000..7d2d4c104d4
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.rs
@@ -0,0 +1,41 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+#![allow(unused)]
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+struct Wrapper {
+    p: Point,
+}
+
+fn main() {
+    let mut w = Wrapper { p: Point { x: 10, y: 10 } };
+
+    // Only paths that appears within the closure that directly start off
+    // a variable defined outside the closure are captured.
+    //
+    // Therefore `w.p` is captured
+    // Note that `wp.x` doesn't start off a variable defined outside the closure.
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        let wp = &w.p;
+        //~^ NOTE: Capturing w[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture w[(0, 0)] -> ImmBorrow
+        println!("{}", wp.x);
+    };
+
+    // Since `c` captures `w.p` by an ImmBorrow, `w.p.y` can't be mutated.
+    let py = &mut w.p.y;
+    c();
+
+    *py = 20
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.stderr b/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.stderr
new file mode 100644
index 00000000000..1c8db7952af
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/multilevel-path-1.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/multilevel-path-1.rs:24:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/multilevel-path-1.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/multilevel-path-1.rs:27:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let wp = &w.p;
+...  |
+LL | |         println!("{}", wp.x);
+LL | |     };
+   | |_____^
+   |
+note: Capturing w[(0, 0)] -> ImmBorrow
+  --> $DIR/multilevel-path-1.rs:30:19
+   |
+LL |         let wp = &w.p;
+   |                   ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/multilevel-path-1.rs:27:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         let wp = &w.p;
+...  |
+LL | |         println!("{}", wp.x);
+LL | |     };
+   | |_____^
+   |
+note: Min Capture w[(0, 0)] -> ImmBorrow
+  --> $DIR/multilevel-path-1.rs:30:19
+   |
+LL |         let wp = &w.p;
+   |                   ^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.rs b/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.rs
new file mode 100644
index 00000000000..540e70138e5
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.rs
@@ -0,0 +1,37 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+#![allow(unused)]
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+struct Wrapper {
+    p: Point,
+}
+
+fn main() {
+    let mut w = Wrapper { p: Point { x: 10, y: 10 } };
+
+    let c = #[rustc_capture_analysis]
+        //~^ ERROR: attributes on expressions are experimental
+        //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        println!("{}", w.p.x);
+        //~^ NOTE: Capturing w[(0, 0),(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture w[(0, 0),(0, 0)] -> ImmBorrow
+    };
+
+    // `c` only captures `w.p.x`, therefore it's safe to mutate `w.p.y`.
+    let py = &mut w.p.y;
+    c();
+
+    *py = 20
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.stderr b/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.stderr
new file mode 100644
index 00000000000..37287f6b3bc
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/multilevel-path-2.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/multilevel-path-2.rs:21:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/multilevel-path-2.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/multilevel-path-2.rs:24:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", w.p.x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing w[(0, 0),(0, 0)] -> ImmBorrow
+  --> $DIR/multilevel-path-2.rs:27:24
+   |
+LL |         println!("{}", w.p.x);
+   |                        ^^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/multilevel-path-2.rs:24:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", w.p.x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture w[(0, 0),(0, 0)] -> ImmBorrow
+  --> $DIR/multilevel-path-2.rs:27:24
+   |
+LL |         println!("{}", w.p.x);
+   |                        ^^^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/nested-closure.rs b/src/test/ui/closures/2229_closure_analysis/nested-closure.rs
new file mode 100644
index 00000000000..88620550f2e
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/nested-closure.rs
@@ -0,0 +1,56 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+// This testcase ensures that nested closures are handles properly
+// - The nested closure is analyzed first.
+// - The capture kind of the nested closure is accounted for by the enclosing closure
+// - Any captured path by the nested closure that starts off a local variable in the enclosing
+// closure is not listed as a capture of the enclosing closure.
+
+fn main() {
+    let mut p = Point { x: 5, y: 20 };
+
+    let mut c1 = #[rustc_capture_analysis]
+        //~^ ERROR: attributes on expressions are experimental
+        //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        println!("{}", p.x);
+        //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
+        let incr = 10;
+        let mut c2 = #[rustc_capture_analysis]
+        //~^ ERROR: attributes on expressions are experimental
+        //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+        || p.y += incr;
+        //~^ ERROR: First Pass analysis includes:
+        //~| ERROR: Min Capture analysis includes:
+        //~| NOTE: Capturing p[(1, 0)] -> MutBorrow
+        //~| NOTE: Capturing incr[] -> ImmBorrow
+        //~| NOTE: Min Capture p[(1, 0)] -> MutBorrow
+        //~| NOTE: Min Capture incr[] -> ImmBorrow
+        //~| NOTE: Capturing p[(1, 0)] -> MutBorrow
+        //~| NOTE: Min Capture p[(1, 0)] -> MutBorrow
+        c2();
+        println!("{}", p.y);
+    };
+
+    c1();
+
+    let px = &p.x;
+
+    println!("{}", px);
+
+    c1();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/nested-closure.stderr b/src/test/ui/closures/2229_closure_analysis/nested-closure.stderr
new file mode 100644
index 00000000000..21147be3f1d
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/nested-closure.stderr
@@ -0,0 +1,110 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/nested-closure.rs:23:18
+   |
+LL |     let mut c1 = #[rustc_capture_analysis]
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/nested-closure.rs:33:22
+   |
+LL |         let mut c2 = #[rustc_capture_analysis]
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/nested-closure.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/nested-closure.rs:36:9
+   |
+LL |         || p.y += incr;
+   |         ^^^^^^^^^^^^^^
+   |
+note: Capturing p[(1, 0)] -> MutBorrow
+  --> $DIR/nested-closure.rs:36:12
+   |
+LL |         || p.y += incr;
+   |            ^^^
+note: Capturing incr[] -> ImmBorrow
+  --> $DIR/nested-closure.rs:36:19
+   |
+LL |         || p.y += incr;
+   |                   ^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/nested-closure.rs:36:9
+   |
+LL |         || p.y += incr;
+   |         ^^^^^^^^^^^^^^
+   |
+note: Min Capture p[(1, 0)] -> MutBorrow
+  --> $DIR/nested-closure.rs:36:12
+   |
+LL |         || p.y += incr;
+   |            ^^^
+note: Min Capture incr[] -> ImmBorrow
+  --> $DIR/nested-closure.rs:36:19
+   |
+LL |         || p.y += incr;
+   |                   ^^^^
+
+error: First Pass analysis includes:
+  --> $DIR/nested-closure.rs:26:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", p.x);
+...  |
+LL | |         println!("{}", p.y);
+LL | |     };
+   | |_____^
+   |
+note: Capturing p[(0, 0)] -> ImmBorrow
+  --> $DIR/nested-closure.rs:29:24
+   |
+LL |         println!("{}", p.x);
+   |                        ^^^
+note: Capturing p[(1, 0)] -> MutBorrow
+  --> $DIR/nested-closure.rs:36:12
+   |
+LL |         || p.y += incr;
+   |            ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/nested-closure.rs:26:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", p.x);
+...  |
+LL | |         println!("{}", p.y);
+LL | |     };
+   | |_____^
+   |
+note: Min Capture p[(0, 0)] -> ImmBorrow
+  --> $DIR/nested-closure.rs:29:24
+   |
+LL |         println!("{}", p.x);
+   |                        ^^^
+note: Min Capture p[(1, 0)] -> MutBorrow
+  --> $DIR/nested-closure.rs:36:12
+   |
+LL |         || p.y += incr;
+   |            ^^^
+
+error: aborting due to 6 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/path-with-array-access.rs b/src/test/ui/closures/2229_closure_analysis/path-with-array-access.rs
new file mode 100644
index 00000000000..16acd2f3206
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/path-with-array-access.rs
@@ -0,0 +1,35 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+struct Point {
+    x: f32,
+    y: f32,
+}
+
+struct Pentagon {
+    points: [Point; 5],
+}
+
+fn main() {
+    let p1 = Point { x: 10.0, y: 10.0 };
+    let p2 = Point { x: 7.5, y: 12.5 };
+    let p3 = Point { x: 15.0, y: 15.0 };
+    let p4 = Point { x: 12.5, y: 12.5 };
+    let p5 = Point { x: 20.0, y: 10.0 };
+
+    let pent = Pentagon { points: [p1, p2, p3, p4, p5] };
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        println!("{}", pent.points[5].x);
+        //~^ NOTE: Capturing pent[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture pent[(0, 0)] -> ImmBorrow
+    };
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/path-with-array-access.stderr b/src/test/ui/closures/2229_closure_analysis/path-with-array-access.stderr
new file mode 100644
index 00000000000..3c8d07ed9ba
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/path-with-array-access.stderr
@@ -0,0 +1,57 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/path-with-array-access.rs:25:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/path-with-array-access.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/path-with-array-access.rs:28:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", pent.points[5].x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing pent[(0, 0)] -> ImmBorrow
+  --> $DIR/path-with-array-access.rs:31:24
+   |
+LL |         println!("{}", pent.points[5].x);
+   |                        ^^^^^^^^^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/path-with-array-access.rs:28:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         println!("{}", pent.points[5].x);
+LL | |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture pent[(0, 0)] -> ImmBorrow
+  --> $DIR/path-with-array-access.rs:31:24
+   |
+LL |         println!("{}", pent.points[5].x);
+   |                        ^^^^^^^^^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.rs b/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.rs
new file mode 100644
index 00000000000..aaff3531e58
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.rs
@@ -0,0 +1,41 @@
+// FIXME(arora-aman) add run-pass once 2229 is implemented
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+// Test to ensure that min analysis meets capture kind for all paths captured.
+
+#[derive(Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let mut p = Point { x: 10, y: 20 };
+
+    //
+    // Requirements:
+    // p.x -> MutBoorrow
+    // p   -> ImmBorrow
+    //
+    // Requirements met when p is captured via MutBorrow
+    //
+    let mut c = #[rustc_capture_analysis]
+        //~^ ERROR: attributes on expressions are experimental
+        //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        p.x += 10;
+        //~^ NOTE: Capturing p[(0, 0)] -> MutBorrow
+        //~| NOTE: Min Capture p[] -> MutBorrow
+        println!("{:?}", p);
+        //~^ NOTE: Capturing p[] -> ImmBorrow
+    };
+
+    c();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.stderr b/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.stderr
new file mode 100644
index 00000000000..30d3d5f504e
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.stderr
@@ -0,0 +1,62 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/simple-struct-min-capture.rs:27:17
+   |
+LL |     let mut c = #[rustc_capture_analysis]
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/simple-struct-min-capture.rs:3:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/simple-struct-min-capture.rs:30:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         p.x += 10;
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing p[(0, 0)] -> MutBorrow
+  --> $DIR/simple-struct-min-capture.rs:33:9
+   |
+LL |         p.x += 10;
+   |         ^^^
+note: Capturing p[] -> ImmBorrow
+  --> $DIR/simple-struct-min-capture.rs:36:26
+   |
+LL |         println!("{:?}", p);
+   |                          ^
+
+error: Min Capture analysis includes:
+  --> $DIR/simple-struct-min-capture.rs:30:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         p.x += 10;
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture p[] -> MutBorrow
+  --> $DIR/simple-struct-min-capture.rs:33:9
+   |
+LL |         p.x += 10;
+   |         ^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/closures/2229_closure_analysis/wild_patterns.rs b/src/test/ui/closures/2229_closure_analysis/wild_patterns.rs
new file mode 100644
index 00000000000..90b8033d074
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/wild_patterns.rs
@@ -0,0 +1,75 @@
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+//~| NOTE: `#[warn(incomplete_features)]` on by default
+//~| NOTE: see issue #53488 <https://github.com/rust-lang/rust/issues/53488>
+#![feature(rustc_attrs)]
+
+// Test to ensure that we can handle cases where
+// let statements create no bindings are intialized
+// using a Place expression
+//
+// Note: Currently when feature `capture_disjoint_fields` is enabled
+// we can't handle such cases. So the test current use `_x` instead of
+// `_` until the issue is resolved.
+// Check rust-lang/project-rfc-2229#24 for status.
+
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn wild_struct() {
+    let p = Point { x: 10, y: 20 };
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        // FIXME(arora-aman): Change `_x` to `_`
+        let Point { x: _x, y: _ } = p;
+        //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
+        //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
+    };
+
+    c();
+}
+
+fn wild_tuple() {
+    let t = (String::new(), 10);
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        // FIXME(arora-aman): Change `_x` to `_`
+        let (_x, _) = t;
+        //~^ NOTE: Capturing t[(0, 0)] -> ByValue
+        //~| NOTE: Min Capture t[(0, 0)] -> ByValue
+    };
+
+    c();
+}
+
+fn wild_arr() {
+    let arr = [String::new(), String::new()];
+
+    let c = #[rustc_capture_analysis]
+    //~^ ERROR: attributes on expressions are experimental
+    //~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
+    || {
+    //~^ ERROR: First Pass analysis includes:
+    //~| ERROR: Min Capture analysis includes:
+        // FIXME(arora-aman): Change `_x` to `_`
+        let [_x, _] = arr;
+        //~^ NOTE: Capturing arr[Index] -> ByValue
+        //~| NOTE: Min Capture arr[] -> ByValue
+    };
+
+    c();
+}
+
+fn main() {}
diff --git a/src/test/ui/closures/2229_closure_analysis/wild_patterns.stderr b/src/test/ui/closures/2229_closure_analysis/wild_patterns.stderr
new file mode 100644
index 00000000000..36be8431be5
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/wild_patterns.stderr
@@ -0,0 +1,147 @@
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/wild_patterns.rs:24:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/wild_patterns.rs:42:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+error[E0658]: attributes on expressions are experimental
+  --> $DIR/wild_patterns.rs:60:13
+   |
+LL |     let c = #[rustc_capture_analysis]
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
+   = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
+
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/wild_patterns.rs:1:12
+   |
+LL | #![feature(capture_disjoint_fields)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+   = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error: First Pass analysis includes:
+  --> $DIR/wild_patterns.rs:27:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing p[(0, 0)] -> ImmBorrow
+  --> $DIR/wild_patterns.rs:31:37
+   |
+LL |         let Point { x: _x, y: _ } = p;
+   |                                     ^
+
+error: Min Capture analysis includes:
+  --> $DIR/wild_patterns.rs:27:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture p[(0, 0)] -> ImmBorrow
+  --> $DIR/wild_patterns.rs:31:37
+   |
+LL |         let Point { x: _x, y: _ } = p;
+   |                                     ^
+
+error: First Pass analysis includes:
+  --> $DIR/wild_patterns.rs:45:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing t[(0, 0)] -> ByValue
+  --> $DIR/wild_patterns.rs:49:23
+   |
+LL |         let (_x, _) = t;
+   |                       ^
+
+error: Min Capture analysis includes:
+  --> $DIR/wild_patterns.rs:45:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture t[(0, 0)] -> ByValue
+  --> $DIR/wild_patterns.rs:49:23
+   |
+LL |         let (_x, _) = t;
+   |                       ^
+
+error: First Pass analysis includes:
+  --> $DIR/wild_patterns.rs:63:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Capturing arr[Index] -> ByValue
+  --> $DIR/wild_patterns.rs:67:23
+   |
+LL |         let [_x, _] = arr;
+   |                       ^^^
+
+error: Min Capture analysis includes:
+  --> $DIR/wild_patterns.rs:63:5
+   |
+LL | /     || {
+LL | |
+LL | |
+LL | |         // FIXME(arora-aman): Change `_x` to `_`
+...  |
+LL | |
+LL | |     };
+   | |_____^
+   |
+note: Min Capture arr[] -> ByValue
+  --> $DIR/wild_patterns.rs:67:23
+   |
+LL |         let [_x, _] = arr;
+   |                       ^^^
+
+error: aborting due to 9 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/generator/print/generator-print-verbose-2.stderr b/src/test/ui/generator/print/generator-print-verbose-2.stderr
index f23949091d9..d590f876b8e 100644
--- a/src/test/ui/generator/print/generator-print-verbose-2.stderr
+++ b/src/test/ui/generator/print/generator-print-verbose-2.stderr
@@ -8,8 +8,8 @@ LL |     assert_send(|| {
    |     ^^^^^^^^^^^ `Cell<i32>` cannot be shared between threads safely
    |
    = help: the trait `Sync` is not implemented for `Cell<i32>`
-   = note: required because of the requirements on the impl of `Send` for `&'_#3r Cell<i32>`
-   = note: required because it appears within the type `[main::{closure#1} upvar_tys=(&'_#3r Cell<i32>) _#17t]`
+   = note: required because of the requirements on the impl of `Send` for `&'_#4r Cell<i32>`
+   = note: required because it appears within the type `[main::{closure#1} upvar_tys=(&'_#4r Cell<i32>) _#17t]`
 
 error: generator cannot be shared between threads safely
   --> $DIR/generator-print-verbose-2.rs:12:5