nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 11:07:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Log closure as well

Browse Source
This commit is contained in:
Aman Arora 2020-11-13 01:51:19 -05:00
parent d0fac05d8f
commit c50e57f946
27 changed files with 746 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
compiler/rustc_typeck/src/check/upvar.rs
View File

@ -166,7 +166,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
"For closure={:?}, capture_information={:#?}", "For closure={:?}, capture_information={:#?}",
closure_def_id, delegate.capture_information closure_def_id, delegate.capture_information
); );
self.log_closure_capture_info(closure_def_id, &delegate.capture_information, span); self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
if let Some(closure_substs) = infer_kind { if let Some(closure_substs) = infer_kind {
// Unify the (as yet unbound) type variable in the closure // Unify the (as yet unbound) type variable in the closure
@ -499,20 +499,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.tcx.has_attr(closure_def_id, sym::rustc_capture_analysis) self.tcx.has_attr(closure_def_id, sym::rustc_capture_analysis)
} }
fn log_closure_capture_info( fn log_capture_analysis_first_pass(
&self, &self,
closure_def_id: rustc_hir::def_id::DefId, closure_def_id: rustc_hir::def_id::DefId,
capture_information: &FxIndexMap<Place<'tcx>, ty::CaptureInfo<'tcx>>, capture_information: &FxIndexMap<Place<'tcx>, ty::CaptureInfo<'tcx>>,
closure_span: Span, closure_span: Span,
) { ) {
if self.should_log_capture_analysis(closure_def_id) { if self.should_log_capture_analysis(closure_def_id) {
let mut diag =
self.tcx.sess.struct_span_err(closure_span, "First Pass analysis includes:");
for (place, capture_info) in capture_information { for (place, capture_info) in capture_information {
let capture_str = construct_capture_info_string(self.tcx, place, capture_info); let capture_str = construct_capture_info_string(self.tcx, place, capture_info);
let output_str = format!("Capturing {}", capture_str); let output_str = format!("Capturing {}", capture_str);
let span = capture_info.expr_id.map_or(closure_span, |e| self.tcx.hir().span(e)); let span = capture_info.expr_id.map_or(closure_span, |e| self.tcx.hir().span(e));
self.tcx.sess.span_err(span, &output_str); diag.span_note(span, &output_str);
} }
diag.emit();
} }
} }
@ -521,6 +524,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Some(min_captures) = if let Some(min_captures) =
self.typeck_results.borrow().closure_min_captures.get(&closure_def_id) self.typeck_results.borrow().closure_min_captures.get(&closure_def_id)
{ {
let mut diag =
self.tcx.sess.struct_span_err(closure_span, "Min Capture analysis includes:");
for (_, min_captures_for_var) in min_captures { for (_, min_captures_for_var) in min_captures {
for capture in min_captures_for_var { for capture in min_captures_for_var {
let place = &capture.place; let place = &capture.place;
@ -532,9 +538,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let span = let span =
capture_info.expr_id.map_or(closure_span, |e| self.tcx.hir().span(e)); capture_info.expr_id.map_or(closure_span, |e| self.tcx.hir().span(e));
self.tcx.sess.span_err(span, &output_str); diag.span_note(span, &output_str);
} }
} }
diag.emit();
} }
} }
} }

11
src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
// Ensure that capture analysis results in arrays being completely captured. // Ensure that capture analysis results in arrays being completely captured.
@ -8,10 +10,13 @@ fn main() {
let mut c = #[rustc_capture_analysis] let mut c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; m[0] += 10;
//~^ ERROR: Capturing m[] -> MutBorrow //~^ NOTE: Capturing m[] -> MutBorrow
//~| ERROR: Min Capture m[] -> MutBorrow //~| NOTE: Min Capture m[] -> MutBorrow
m[1] += 40; m[1] += 40;
}; };

34
src/test/ui/closures/2229_closure_analysis/arrays-completely-captured.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/arrays-completely-captured.rs:9:17 --> $DIR/arrays-completely-captured.rs:11:17
| |
LL | let mut c = #[rustc_capture_analysis] LL | let mut c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing m[] -> MutBorrow error: First Pass analysis includes:
--> $DIR/arrays-completely-captured.rs:12:9 --> $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; LL | m[0] += 10;
| ^ | ^
error: Min Capture m[] -> MutBorrow error: Min Capture analysis includes:
--> $DIR/arrays-completely-captured.rs:12:9 --> $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; LL | m[0] += 10;
| ^ | ^

11
src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
struct Point { struct Point {
@ -14,10 +16,13 @@ fn main() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("{}", p.x);
//~^ ERROR: Capturing p[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture p[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
}; };
// `c` should only capture `p.x`, therefore mutating `p.y` is allowed. // `c` should only capture `p.x`, therefore mutating `p.y` is allowed.

34
src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-struct.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/capture-disjoint-field-struct.rs:15:13 --> $DIR/capture-disjoint-field-struct.rs:17:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing p[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/capture-disjoint-field-struct.rs:18:24 --> $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); LL | println!("{}", p.x);
| ^^^ | ^^^
error: Min Capture p[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/capture-disjoint-field-struct.rs:18:24 --> $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); LL | println!("{}", p.x);
| ^^^ | ^^^

11
src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
fn main() { fn main() {
@ -9,10 +11,13 @@ fn main() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("{}", t.0);
//~^ ERROR: Capturing t[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing t[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture t[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture t[(0, 0)] -> ImmBorrow
}; };
// `c` only captures t.0, therefore mutating t.1 is allowed. // `c` only captures t.0, therefore mutating t.1 is allowed.

34
src/test/ui/closures/2229_closure_analysis/capture-disjoint-field-tuple.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/capture-disjoint-field-tuple.rs:10:13 --> $DIR/capture-disjoint-field-tuple.rs:12:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing t[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/capture-disjoint-field-tuple.rs:13:24 --> $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); LL | println!("{}", t.0);
| ^^^ | ^^^
error: Min Capture t[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/capture-disjoint-field-tuple.rs:13:24 --> $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); LL | println!("{}", t.0);
| ^^^ | ^^^

28
src/test/ui/closures/2229_closure_analysis/capture-enums.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
enum Info { enum Info {
@ -15,18 +17,21 @@ fn multi_variant_enum() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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 { if let Info::Point(_, _, str) = point {
//~^ Capturing point[] -> ImmBorrow //~^ NOTE: Capturing point[] -> ImmBorrow
//~| Capturing point[(2, 0)] -> ByValue //~| NOTE: Capturing point[(2, 0)] -> ByValue
//~| Min Capture point[] -> ByValue //~| NOTE: Min Capture point[] -> ByValue
println!("{}", str); println!("{}", str);
} }
if let Info::Meta(_, v) = meta { if let Info::Meta(_, v) = meta {
//~^ Capturing meta[] -> ImmBorrow //~^ NOTE: Capturing meta[] -> ImmBorrow
//~| Capturing meta[(1, 1)] -> ByValue //~| NOTE: Capturing meta[(1, 1)] -> ByValue
//~| Min Capture meta[] -> ByValue //~| NOTE: Min Capture meta[] -> ByValue
println!("{:?}", v); println!("{:?}", v);
} }
}; };
@ -43,10 +48,13 @@ fn single_variant_enum() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ ERROR: attributes on expressions are experimental
//~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
|| { || {
let SingleVariant::Point(_, _, str) = point; //~^ First Pass analysis includes:
//~^ Capturing point[(2, 0)] -> ByValue //~| Min Capture analysis includes:
//~| Min Capture point[(2, 0)] -> ByValue let SingleVariant::Point(_, _, str) = point;
//~^ NOTE: Capturing point[(2, 0)] -> ByValue
//~| NOTE: Min Capture point[(2, 0)] -> ByValue
println!("{}", str); println!("{}", str);
}; };

104
src/test/ui/closures/2229_closure_analysis/capture-enums.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/capture-enums.rs:16:13 --> $DIR/capture-enums.rs:18:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -8,7 +8,7 @@ LL | let c = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/capture-enums.rs:44:13 --> $DIR/capture-enums.rs:49:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -25,54 +25,98 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing point[] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/capture-enums.rs:19:41 --> $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 { LL | if let Info::Point(_, _, str) = point {
| ^^^^^ | ^^^^^
note: Capturing point[(2, 0)] -> ByValue
error: Capturing point[(2, 0)] -> ByValue --> $DIR/capture-enums.rs:24:41
--> $DIR/capture-enums.rs:19:41
| |
LL | if let Info::Point(_, _, str) = point { LL | if let Info::Point(_, _, str) = point {
| ^^^^^ | ^^^^^
note: Capturing meta[] -> ImmBorrow
error: Capturing meta[] -> ImmBorrow --> $DIR/capture-enums.rs:31:35
--> $DIR/capture-enums.rs:26: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 { LL | if let Info::Meta(_, v) = meta {
| ^^^^ | ^^^^
error: Capturing meta[(1, 1)] -> ByValue error: Min Capture analysis includes:
--> $DIR/capture-enums.rs:26:35 --> $DIR/capture-enums.rs:21:5
| |
LL | if let Info::Meta(_, v) = meta { LL | / || {
| ^^^^ LL | |
LL | |
error: Min Capture point[] -> ByValue LL | | if let Info::Point(_, _, str) = point {
--> $DIR/capture-enums.rs:19:41 ... |
LL | | }
LL | | };
| |_____^
|
note: Min Capture point[] -> ByValue
--> $DIR/capture-enums.rs:24:41
| |
LL | if let Info::Point(_, _, str) = point { LL | if let Info::Point(_, _, str) = point {
| ^^^^^ | ^^^^^
note: Min Capture meta[] -> ByValue
error: Min Capture meta[] -> ByValue --> $DIR/capture-enums.rs:31:35
--> $DIR/capture-enums.rs:26:35
| |
LL | if let Info::Meta(_, v) = meta { LL | if let Info::Meta(_, v) = meta {
| ^^^^ | ^^^^
error: Capturing point[(2, 0)] -> ByValue error: First Pass analysis includes:
--> $DIR/capture-enums.rs:47:43 --> $DIR/capture-enums.rs:52:5
| |
LL | let SingleVariant::Point(_, _, str) = point; LL | / || {
| ^^^^^ LL | |
LL | |
error: Min Capture point[(2, 0)] -> ByValue LL | | let SingleVariant::Point(_, _, str) = point;
--> $DIR/capture-enums.rs:47:43 ... |
LL | | println!("{}", str);
LL | | };
| |_____^
| |
LL | let SingleVariant::Point(_, _, str) = point; note: Capturing point[(2, 0)] -> ByValue
| ^^^^^ --> $DIR/capture-enums.rs:55:47
|
LL | let SingleVariant::Point(_, _, str) = point;
| ^^^^^
error: aborting due to 10 previous errors; 1 warning emitted 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`. For more information about this error, try `rustc --explain E0658`.

37
src/test/ui/closures/2229_closure_analysis/destructure_patterns.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
// Test to ensure Index projections are handled properly during capture analysis // Test to ensure Index projections are handled properly during capture analysis
@ -9,10 +11,13 @@ fn arrays() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; let [a, b, .., e] = arr;
//~^ ERROR: Capturing arr[Index] -> ByValue //~^ NOTE: Capturing arr[Index] -> ByValue
//~| ERROR: Min Capture arr[] -> ByValue //~| NOTE: Min Capture arr[] -> ByValue
assert_eq!(a, "A"); assert_eq!(a, "A");
assert_eq!(b, "B"); assert_eq!(b, "B");
assert_eq!(e, "E"); assert_eq!(e, "E");
@ -32,12 +37,15 @@ fn structs() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; let Point { x: ref mut x, y: _, id: moved_id } = p;
//~^ ERROR: Capturing p[(0, 0)] -> MutBorrow //~^ NOTE: Capturing p[(0, 0)] -> MutBorrow
//~| ERROR: Capturing p[(2, 0)] -> ByValue //~| NOTE: Capturing p[(2, 0)] -> ByValue
//~| ERROR: Min Capture p[(0, 0)] -> MutBorrow //~| NOTE: Min Capture p[(0, 0)] -> MutBorrow
//~| ERROR: Min Capture p[(2, 0)] -> ByValue //~| NOTE: Min Capture p[(2, 0)] -> ByValue
println!("{}, {}", x, moved_id); println!("{}, {}", x, moved_id);
}; };
@ -49,14 +57,17 @@ fn tuples() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; let (ref mut x, ref ref_str, (moved_s, _)) = t;
//~^ ERROR: Capturing t[(0, 0)] -> MutBorrow //~^ NOTE: Capturing t[(0, 0)] -> MutBorrow
//~| ERROR: Capturing t[(1, 0)] -> ImmBorrow //~| NOTE: Capturing t[(1, 0)] -> ImmBorrow
//~| ERROR: Capturing t[(2, 0),(0, 0)] -> ByValue //~| NOTE: Capturing t[(2, 0),(0, 0)] -> ByValue
//~| ERROR: Min Capture t[(0, 0)] -> MutBorrow //~| NOTE: Min Capture t[(0, 0)] -> MutBorrow
//~| ERROR: Min Capture t[(1, 0)] -> ImmBorrow //~| NOTE: Min Capture t[(1, 0)] -> ImmBorrow
//~| ERROR: Min Capture t[(2, 0),(0, 0)] -> ByValue //~| NOTE: Min Capture t[(2, 0),(0, 0)] -> ByValue
println!("{}, {} {}", x, ref_str, moved_s); println!("{}, {} {}", x, ref_str, moved_s);
}; };

166
src/test/ui/closures/2229_closure_analysis/destructure_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/destructure_patterns.rs:10:13 --> $DIR/destructure_patterns.rs:12:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -8,7 +8,7 @@ LL | let c = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/destructure_patterns.rs:33:13 --> $DIR/destructure_patterns.rs:38:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -17,7 +17,7 @@ LL | let c = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/destructure_patterns.rs:50:13 --> $DIR/destructure_patterns.rs:58:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -34,78 +34,144 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing arr[Index] -> ByValue error: First Pass analysis includes:
--> $DIR/destructure_patterns.rs:13:29 --> $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; LL | let [a, b, .., e] = arr;
| ^^^ | ^^^
error: Min Capture arr[] -> ByValue error: Min Capture analysis includes:
--> $DIR/destructure_patterns.rs:13:29 --> $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; LL | let [a, b, .., e] = arr;
| ^^^ | ^^^
error: Capturing p[(0, 0)] -> MutBorrow error: First Pass analysis includes:
--> $DIR/destructure_patterns.rs:36:58 --> $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; LL | let Point { x: ref mut x, y: _, id: moved_id } = p;
| ^ | ^
error: Capturing p[(2, 0)] -> ByValue error: Min Capture analysis includes:
--> $DIR/destructure_patterns.rs:36:58 --> $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; LL | let Point { x: ref mut x, y: _, id: moved_id } = p;
| ^ | ^
error: Min Capture p[(0, 0)] -> MutBorrow error: First Pass analysis includes:
--> $DIR/destructure_patterns.rs:36:58 --> $DIR/destructure_patterns.rs:61:5
| |
LL | let Point { x: ref mut x, y: _, id: moved_id } = p; LL | / || {
| ^ LL | |
LL | |
error: Min Capture p[(2, 0)] -> ByValue LL | | let (ref mut x, ref ref_str, (moved_s, _)) = t;
--> $DIR/destructure_patterns.rs:36:58 ... |
LL | | println!("{}, {} {}", x, ref_str, moved_s);
LL | | };
| |_____^
| |
LL | let Point { x: ref mut x, y: _, id: moved_id } = p; note: Capturing t[(0, 0)] -> MutBorrow
| ^ --> $DIR/destructure_patterns.rs:64:54
|
error: Capturing t[(0, 0)] -> MutBorrow LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
--> $DIR/destructure_patterns.rs:53:54 | ^
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; LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^ | ^
error: Capturing t[(1, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/destructure_patterns.rs:53:54 --> $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; LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^ | ^
error: Capturing t[(2, 0),(0, 0)] -> ByValue error: aborting due to 9 previous errors; 1 warning emitted
--> $DIR/destructure_patterns.rs:53:54
|
LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^
error: Min Capture t[(0, 0)] -> MutBorrow
--> $DIR/destructure_patterns.rs:53:54
|
LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^
error: Min Capture t[(1, 0)] -> ImmBorrow
--> $DIR/destructure_patterns.rs:53:54
|
LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^
error: Min Capture t[(2, 0),(0, 0)] -> ByValue
--> $DIR/destructure_patterns.rs:53:54
|
LL | let (ref mut x, ref ref_str, (moved_s, _)) = t;
| ^
error: aborting due to 15 previous errors; 1 warning emitted
For more information about this error, try `rustc --explain E0658`. For more information about this error, try `rustc --explain E0658`.

11
src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
fn main() { fn main() {
@ -7,9 +9,12 @@ fn main() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("This uses new capture analyysis to capture s={}", s);
//~^ ERROR: Capturing s[] -> ImmBorrow //~^ NOTE: Capturing s[] -> ImmBorrow
//~| ERROR: Min Capture s[] -> ImmBorrow //~| NOTE: Min Capture s[] -> ImmBorrow
}; };
} }

34
src/test/ui/closures/2229_closure_analysis/feature-gate-capture_disjoint_fields.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/feature-gate-capture_disjoint_fields.rs:8:13 --> $DIR/feature-gate-capture_disjoint_fields.rs:10:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing s[] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/feature-gate-capture_disjoint_fields.rs:11:69 --> $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); LL | println!("This uses new capture analyysis to capture s={}", s);
| ^ | ^
error: Min Capture s[] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/feature-gate-capture_disjoint_fields.rs:11:69 --> $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); LL | println!("This uses new capture analyysis to capture s={}", s);
| ^ | ^

10
src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ warning the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
struct Filter { struct Filter {
@ -24,8 +26,10 @@ impl Data {
self.list.retain( self.list.retain(
#[rustc_capture_analysis] #[rustc_capture_analysis]
|v| self.filter.allowed(*v), |v| self.filter.allowed(*v),
//~^ ERROR: Capturing self[Deref,(0, 0)] -> ImmBorrow //~^ ERROR: First Pass analysis includes:
//~| ERROR: Min Capture self[Deref,(0, 0)] -> ImmBorrow //~| ERROR: Min Capture analysis includes:
//~| NOTE: Capturing self[Deref,(0, 0)] -> ImmBorrow
//~| NOTE: Min Capture self[Deref,(0, 0)] -> ImmBorrow
); );
} }
} }

20
src/test/ui/closures/2229_closure_analysis/filter-on-struct-member.stderr
View File

@ -7,14 +7,26 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing self[Deref,(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/filter-on-struct-member.rs:26:17 --> $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), LL | |v| self.filter.allowed(*v),
| ^^^^^^^^^^^ | ^^^^^^^^^^^
error: Min Capture self[Deref,(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/filter-on-struct-member.rs:26:17 --> $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), LL | |v| self.filter.allowed(*v),
| ^^^^^^^^^^^ | ^^^^^^^^^^^

11
src/test/ui/closures/2229_closure_analysis/multilevel-path-1.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ warning the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
#![allow(unused)] #![allow(unused)]
@ -21,10 +23,13 @@ fn main() {
// Note that `wp.x` doesn't start off a variable defined outside the closure. // Note that `wp.x` doesn't start off a variable defined outside the closure.
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; let wp = &w.p;
//~^ ERROR: Capturing w[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing w[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture w[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture w[(0, 0)] -> ImmBorrow
println!("{}", wp.x); println!("{}", wp.x);
}; };

34
src/test/ui/closures/2229_closure_analysis/multilevel-path-1.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/multilevel-path-1.rs:22:13 --> $DIR/multilevel-path-1.rs:24:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing w[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/multilevel-path-1.rs:25:19 --> $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; LL | let wp = &w.p;
| ^^^ | ^^^
error: Min Capture w[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/multilevel-path-1.rs:25:19 --> $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; LL | let wp = &w.p;
| ^^^ | ^^^

11
src/test/ui/closures/2229_closure_analysis/multilevel-path-2.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ warning the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
#![allow(unused)] #![allow(unused)]
@ -18,10 +20,13 @@ fn main() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("{}", w.p.x);
//~^ ERROR: Capturing w[(0, 0),(0, 0)] -> ImmBorrow //~^ NOTE: Capturing w[(0, 0),(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture 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`. // `c` only captures `w.p.x`, therefore it's safe to mutate `w.p.y`.

34
src/test/ui/closures/2229_closure_analysis/multilevel-path-2.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/multilevel-path-2.rs:19:13 --> $DIR/multilevel-path-2.rs:21:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing w[(0, 0),(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/multilevel-path-2.rs:22:24 --> $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); LL | println!("{}", w.p.x);
| ^^^^^ | ^^^^^
error: Min Capture w[(0, 0),(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/multilevel-path-2.rs:22:24 --> $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); LL | println!("{}", w.p.x);
| ^^^^^ | ^^^^^

26
src/test/ui/closures/2229_closure_analysis/nested-closure.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ warning the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
struct Point { struct Point {
@ -20,20 +22,26 @@ fn main() {
let mut c1 = #[rustc_capture_analysis] let mut c1 = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("{}", p.x);
//~^ ERROR: Capturing p[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture p[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
let incr = 10; let incr = 10;
let mut c2 = #[rustc_capture_analysis] let mut c2 = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ ERROR: attributes on expressions are experimental
//~| NOTE: see issue #15701 <https://github.com/rust-lang/rust/issues/15701>
|| p.y += incr; || p.y += incr;
//~^ ERROR: Capturing p[(1, 0)] -> MutBorrow //~^ ERROR: First Pass analysis includes:
//~| ERROR: Capturing incr[] -> ImmBorrow //~| ERROR: Min Capture analysis includes:
//~| ERROR: Min Capture p[(1, 0)] -> MutBorrow //~| NOTE: Capturing p[(1, 0)] -> MutBorrow
//~| ERROR: Min Capture incr[] -> ImmBorrow //~| NOTE: Capturing incr[] -> ImmBorrow
//~| ERROR: Capturing p[(1, 0)] -> MutBorrow //~| NOTE: Min Capture p[(1, 0)] -> MutBorrow
//~| ERROR: 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(); c2();
println!("{}", p.y); println!("{}", p.y);
}; };

78
src/test/ui/closures/2229_closure_analysis/nested-closure.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/nested-closure.rs:21:18 --> $DIR/nested-closure.rs:23:18
| |
LL | let mut c1 = #[rustc_capture_analysis] LL | let mut c1 = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -8,7 +8,7 @@ LL | let mut c1 = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/nested-closure.rs:28:22 --> $DIR/nested-closure.rs:33:22
| |
LL | let mut c2 = #[rustc_capture_analysis] LL | let mut c2 = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -25,54 +25,86 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing p[(1, 0)] -> MutBorrow error: First Pass analysis includes:
--> $DIR/nested-closure.rs:30:12 --> $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; LL | || p.y += incr;
| ^^^ | ^^^
note: Capturing incr[] -> ImmBorrow
error: Capturing incr[] -> ImmBorrow --> $DIR/nested-closure.rs:36:19
--> $DIR/nested-closure.rs:30:19
| |
LL | || p.y += incr; LL | || p.y += incr;
| ^^^^ | ^^^^
error: Min Capture p[(1, 0)] -> MutBorrow error: Min Capture analysis includes:
--> $DIR/nested-closure.rs:30:12 --> $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; LL | || p.y += incr;
| ^^^ | ^^^
note: Min Capture incr[] -> ImmBorrow
error: Min Capture incr[] -> ImmBorrow --> $DIR/nested-closure.rs:36:19
--> $DIR/nested-closure.rs:30:19
| |
LL | || p.y += incr; LL | || p.y += incr;
| ^^^^ | ^^^^
error: Capturing p[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/nested-closure.rs:24:24 --> $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); LL | println!("{}", p.x);
| ^^^ | ^^^
note: Capturing p[(1, 0)] -> MutBorrow
error: Capturing p[(1, 0)] -> MutBorrow --> $DIR/nested-closure.rs:36:12
--> $DIR/nested-closure.rs:30:12
| |
LL | || p.y += incr; LL | || p.y += incr;
| ^^^ | ^^^
error: Min Capture p[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/nested-closure.rs:24:24 --> $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); LL | println!("{}", p.x);
| ^^^ | ^^^
note: Min Capture p[(1, 0)] -> MutBorrow
error: Min Capture p[(1, 0)] -> MutBorrow --> $DIR/nested-closure.rs:36:12
--> $DIR/nested-closure.rs:30:12
| |
LL | || p.y += incr; LL | || p.y += incr;
| ^^^ | ^^^
error: aborting due to 10 previous errors; 1 warning emitted error: aborting due to 6 previous errors; 1 warning emitted
For more information about this error, try `rustc --explain E0658`. For more information about this error, try `rustc --explain E0658`.

11
src/test/ui/closures/2229_closure_analysis/path-with-array-access.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
struct Point { struct Point {
@ -22,9 +24,12 @@ fn main() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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); println!("{}", pent.points[5].x);
//~^ ERROR: Capturing pent[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing pent[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture pent[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture pent[(0, 0)] -> ImmBorrow
}; };
} }

34
src/test/ui/closures/2229_closure_analysis/path-with-array-access.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/path-with-array-access.rs:23:13 --> $DIR/path-with-array-access.rs:25:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,14 +16,38 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing pent[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/path-with-array-access.rs:26:24 --> $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); LL | println!("{}", pent.points[5].x);
| ^^^^^^^^^^^ | ^^^^^^^^^^^
error: Min Capture pent[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/path-with-array-access.rs:26:24 --> $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); LL | println!("{}", pent.points[5].x);
| ^^^^^^^^^^^ | ^^^^^^^^^^^

13
src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.rs
View File

@ -1,7 +1,9 @@
// FIXME(arora-aman) add run-pass once 2229 is implemented // FIXME(arora-aman) add run-pass once 2229 is implemented
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
// Test to ensure that min analysis meets capture kind for all paths captured. // Test to ensure that min analysis meets capture kind for all paths captured.
@ -24,12 +26,15 @@ fn main() {
// //
let mut c = #[rustc_capture_analysis] let mut c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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; p.x += 10;
//~^ ERROR: Capturing p[(0, 0)] -> MutBorrow //~^ NOTE: Capturing p[(0, 0)] -> MutBorrow
//~| ERROR: Min Capture p[] -> MutBorrow //~| NOTE: Min Capture p[] -> MutBorrow
println!("{:?}", p); println!("{:?}", p);
//~^ ERROR: Capturing p[] -> ImmBorrow //~^ NOTE: Capturing p[] -> ImmBorrow
}; };
c(); c();

41
src/test/ui/closures/2229_closure_analysis/simple-struct-min-capture.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/simple-struct-min-capture.rs:25:17 --> $DIR/simple-struct-min-capture.rs:27:17
| |
LL | let mut c = #[rustc_capture_analysis] LL | let mut c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,24 +16,47 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing p[(0, 0)] -> MutBorrow error: First Pass analysis includes:
--> $DIR/simple-struct-min-capture.rs:28:9 --> $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; LL | p.x += 10;
| ^^^ | ^^^
note: Capturing p[] -> ImmBorrow
error: Capturing p[] -> ImmBorrow --> $DIR/simple-struct-min-capture.rs:36:26
--> $DIR/simple-struct-min-capture.rs:31:26
| |
LL | println!("{:?}", p); LL | println!("{:?}", p);
| ^ | ^
error: Min Capture p[] -> MutBorrow error: Min Capture analysis includes:
--> $DIR/simple-struct-min-capture.rs:28:9 --> $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; LL | p.x += 10;
| ^^^ | ^^^
error: aborting due to 4 previous errors; 1 warning emitted error: aborting due to 3 previous errors; 1 warning emitted
For more information about this error, try `rustc --explain E0658`. For more information about this error, try `rustc --explain E0658`.

29
src/test/ui/closures/2229_closure_analysis/wild_patterns.rs
View File

@ -1,5 +1,7 @@
#![feature(capture_disjoint_fields)] #![feature(capture_disjoint_fields)]
//~^ WARNING the feature `capture_disjoint_fields` is incomplete //~^ 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)] #![feature(rustc_attrs)]
// Test to ensure that we can handle cases where // Test to ensure that we can handle cases where
@ -7,7 +9,9 @@
// using a Place expression // using a Place expression
// //
// Note: Currently when feature `capture_disjoint_fields` is enabled // Note: Currently when feature `capture_disjoint_fields` is enabled
// we can't handle such cases. So the test so the test // 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 { struct Point {
x: i32, x: i32,
@ -19,11 +23,14 @@ fn wild_struct() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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 `_` // FIXME(arora-aman): Change `_x` to `_`
let Point { x: _x, y: _ } = p; let Point { x: _x, y: _ } = p;
//~^ ERROR: Capturing p[(0, 0)] -> ImmBorrow //~^ NOTE: Capturing p[(0, 0)] -> ImmBorrow
//~| ERROR: Min Capture p[(0, 0)] -> ImmBorrow //~| NOTE: Min Capture p[(0, 0)] -> ImmBorrow
}; };
c(); c();
@ -34,11 +41,14 @@ fn wild_tuple() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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 `_` // FIXME(arora-aman): Change `_x` to `_`
let (_x, _) = t; let (_x, _) = t;
//~^ ERROR: Capturing t[(0, 0)] -> ByValue //~^ NOTE: Capturing t[(0, 0)] -> ByValue
//~| ERROR: Min Capture t[(0, 0)] -> ByValue //~| NOTE: Min Capture t[(0, 0)] -> ByValue
}; };
c(); c();
@ -49,11 +59,14 @@ fn wild_arr() {
let c = #[rustc_capture_analysis] let c = #[rustc_capture_analysis]
//~^ ERROR: attributes on expressions are experimental //~^ 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 `_` // FIXME(arora-aman): Change `_x` to `_`
let [_x, _] = arr; let [_x, _] = arr;
//~^ ERROR: Capturing arr[Index] -> ByValue //~^ NOTE: Capturing arr[Index] -> ByValue
//~| ERROR: Min Capture arr[] -> ByValue //~| NOTE: Min Capture arr[] -> ByValue
}; };
c(); c();

102
src/test/ui/closures/2229_closure_analysis/wild_patterns.stderr
View File

@ -1,5 +1,5 @@
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/wild_patterns.rs:20:13 --> $DIR/wild_patterns.rs:24:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -8,7 +8,7 @@ LL | let c = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/wild_patterns.rs:35:13 --> $DIR/wild_patterns.rs:42:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -17,7 +17,7 @@ LL | let c = #[rustc_capture_analysis]
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable = help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
error[E0658]: attributes on expressions are experimental error[E0658]: attributes on expressions are experimental
--> $DIR/wild_patterns.rs:50:13 --> $DIR/wild_patterns.rs:60:13
| |
LL | let c = #[rustc_capture_analysis] LL | let c = #[rustc_capture_analysis]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
@ -34,38 +34,110 @@ LL | #![feature(capture_disjoint_fields)]
= note: `#[warn(incomplete_features)]` on by default = note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
error: Capturing p[(0, 0)] -> ImmBorrow error: First Pass analysis includes:
--> $DIR/wild_patterns.rs:24:37 --> $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; LL | let Point { x: _x, y: _ } = p;
| ^ | ^
error: Min Capture p[(0, 0)] -> ImmBorrow error: Min Capture analysis includes:
--> $DIR/wild_patterns.rs:24:37 --> $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; LL | let Point { x: _x, y: _ } = p;
| ^ | ^
error: Capturing t[(0, 0)] -> ByValue error: First Pass analysis includes:
--> $DIR/wild_patterns.rs:39:23 --> $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; LL | let (_x, _) = t;
| ^ | ^
error: Min Capture t[(0, 0)] -> ByValue error: Min Capture analysis includes:
--> $DIR/wild_patterns.rs:39:23 --> $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; LL | let (_x, _) = t;
| ^ | ^
error: Capturing arr[Index] -> ByValue error: First Pass analysis includes:
--> $DIR/wild_patterns.rs:54:23 --> $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; LL | let [_x, _] = arr;
| ^^^ | ^^^
error: Min Capture arr[] -> ByValue error: Min Capture analysis includes:
--> $DIR/wild_patterns.rs:54:23 --> $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; LL | let [_x, _] = arr;
| ^^^ | ^^^