bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rework diagnostic reporting to be more structured

Browse source
This commit is contained in:
Niko Matsakis 2021-11-04 17:44:29 -04:00
parent 9c84ac86d1
commit 76bc02715e
10 changed files with 164 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

185
compiler/rustc_typeck/src/check/upvar.rs
View file

@ -88,19 +88,53 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// name (i.e: a.b.c) /// name (i.e: a.b.c)
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum CapturesInfo { enum CapturesInfo {
/// We previously captured all of `x`, but now we capture some sub-path.
CapturingLess { source_expr: Option<hir::HirId>, var_name: String }, CapturingLess { source_expr: Option<hir::HirId>, var_name: String },
//CapturingNothing {
// // where the variable appears in the closure (but is not captured)
// use_span: Span,
//},
} }
/// Intermediate format to store information needed to generate migration lint. The tuple /// Reasons that we might issue a migration warning.
/// contains the hir_id pointing to the use that resulted in the #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
/// corresponding place being captured, a String which contains the captured value's struct MigrationWarningReason {
/// name (i.e: a.b.c) and a String which contains the reason why migration is needed for that /// When we used to capture `x` in its entirety, we implemented the auto-trait(s)
/// capture /// in this vec, but now we don't.
type MigrationNeededForCapture = (Option<hir::HirId>, String, String); auto_traits: Vec<&'static str>,
/// When we used to capture `x` in its entirety, we would execute some destructors
/// at a different time.
drop_order: bool,
}
impl MigrationWarningReason {
fn migration_message(&self) -> String {
let base = "changes to closure capture in Rust 2021 will affect";
if !self.auto_traits.is_empty() && self.drop_order {
format!("{} drop order and which traits the closure implements", base)
} else if self.drop_order {
format!("{} drop order", base)
} else {
format!("{} which traits the closure implements", base)
}
}
}
/// Intermediate format to store information needed to generate a note in the migration lint.
struct MigrationLintNote {
captures_info: CapturesInfo,
/// reasons why migration is needed for this capture
reason: MigrationWarningReason,
}
/// Intermediate format to store the hir id of the root variable and a HashSet containing /// Intermediate format to store the hir id of the root variable and a HashSet containing
/// information on why the root variable should be fully captured /// information on why the root variable should be fully captured
type MigrationDiagnosticInfo = (hir::HirId, Vec<MigrationNeededForCapture>); struct NeededMigration {
var_hir_id: hir::HirId,
diagnostics_info: Vec<MigrationLintNote>,
}
struct InferBorrowKindVisitor<'a, 'tcx> { struct InferBorrowKindVisitor<'a, 'tcx> {
fcx: &'a FnCtxt<'a, 'tcx>, fcx: &'a FnCtxt<'a, 'tcx>,
@ -710,47 +744,50 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
closure_head_span, closure_head_span,
|lint| { |lint| {
let mut diagnostics_builder = lint.build( let mut diagnostics_builder = lint.build(
format!( &reasons.migration_message(),
"changes to closure capture in Rust 2021 will affect {}",
reasons
)
.as_str(),
); );
for (var_hir_id, diagnostics_info) in need_migrations.iter() { for NeededMigration { var_hir_id, diagnostics_info } in &need_migrations {
// Labels all the usage of the captured variable and why they are responsible // Labels all the usage of the captured variable and why they are responsible
// for migration being needed // for migration being needed
for (captured_hir_id, captured_name, reasons) in diagnostics_info.iter() { for lint_note in diagnostics_info.iter() {
if let Some(captured_hir_id) = captured_hir_id { match &lint_note.captures_info {
let cause_span = self.tcx.hir().span(*captured_hir_id); CapturesInfo::CapturingLess { source_expr: Some(capture_expr_id), var_name: captured_name } => {
diagnostics_builder.span_label(cause_span, format!("in Rust 2018, this closure captures all of `{}`, but in Rust 2021, it will only capture `{}`", let cause_span = self.tcx.hir().span(*capture_expr_id);
self.tcx.hir().name(*var_hir_id), diagnostics_builder.span_label(cause_span, format!("in Rust 2018, this closure captures all of `{}`, but in Rust 2021, it will only capture `{}`",
captured_name, self.tcx.hir().name(*var_hir_id),
)); captured_name,
));
}
_ => { }
} }
// Add a label pointing to where a captured variable affected by drop order // Add a label pointing to where a captured variable affected by drop order
// is dropped // is dropped
if reasons.contains("drop order") { if lint_note.reason.drop_order {
let drop_location_span = drop_location_span(self.tcx, &closure_hir_id); let drop_location_span = drop_location_span(self.tcx, &closure_hir_id);
diagnostics_builder.span_label(drop_location_span, format!("in Rust 2018, `{}` is dropped here, but in Rust 2021, only `{}` will be dropped here as part of the closure", match &lint_note.captures_info {
self.tcx.hir().name(*var_hir_id), CapturesInfo::CapturingLess { var_name: captured_name, .. } => {
captured_name, diagnostics_builder.span_label(drop_location_span, format!("in Rust 2018, `{}` is dropped here, but in Rust 2021, only `{}` will be dropped here as part of the closure",
)); self.tcx.hir().name(*var_hir_id),
captured_name,
));
}
}
} }
// Add a label explaining why a closure no longer implements a trait // Add a label explaining why a closure no longer implements a trait
if reasons.contains("trait implementation") { for &missing_trait in &lint_note.reason.auto_traits {
let missing_trait = &reasons[..reasons.find("trait implementation").unwrap() - 1]; // not capturing something anymore cannot cause a trait to fail to be implemented:
match &lint_note.captures_info {
diagnostics_builder.span_label(closure_head_span, format!("in Rust 2018, this closure implements {} as `{}` implements {}, but in Rust 2021, this closure will no longer implement {} as `{}` does not implement {}", CapturesInfo::CapturingLess { var_name: captured_name, .. } => {
missing_trait, diagnostics_builder.span_label(closure_head_span, format!("in Rust 2018, this closure implements {missing_trait} as `{x}` implements {missing_trait}, but in Rust 2021, this closure will no longer implement {missing_trait} as `{p}` does not implement {missing_trait}",
self.tcx.hir().name(*var_hir_id), missing_trait = missing_trait,
missing_trait, x = self.tcx.hir().name(*var_hir_id),
missing_trait, p = captured_name,
captured_name, ));
missing_trait, }
)); }
} }
} }
} }
@ -843,25 +880,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// Combines all the reasons for 2229 migrations /// Combines all the reasons for 2229 migrations
fn compute_2229_migrations_reasons( fn compute_2229_migrations_reasons(
&self, &self,
auto_trait_reasons: FxHashSet<&str>, auto_trait_reasons: FxHashSet<&'static str>,
drop_reason: bool, drop_order: bool,
) -> String { ) -> MigrationWarningReason {
let mut reasons = String::new(); let mut reasons = MigrationWarningReason::default();
if !auto_trait_reasons.is_empty() { for auto_trait in auto_trait_reasons {
reasons = format!( reasons.auto_traits.push(auto_trait);
"{} trait implementation for closure",
auto_trait_reasons.clone().into_iter().collect::<Vec<&str>>().join(", ")
);
} }
if !auto_trait_reasons.is_empty() && drop_reason { reasons.drop_order = drop_order;
reasons = format!("{} and ", reasons);
}
if drop_reason {
reasons = format!("{}drop order", reasons);
}
reasons reasons
} }
@ -877,7 +905,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>, min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
var_hir_id: hir::HirId, var_hir_id: hir::HirId,
closure_clause: hir::CaptureBy, closure_clause: hir::CaptureBy,
) -> Option<FxHashMap<CapturesInfo, FxHashSet<&str>>> { ) -> Option<FxHashMap<CapturesInfo, FxHashSet<&'static str>>> {
let auto_traits_def_id = vec![ let auto_traits_def_id = vec![
self.tcx.lang_items().clone_trait(), self.tcx.lang_items().clone_trait(),
self.tcx.lang_items().sync_trait(), self.tcx.lang_items().sync_trait(),
@ -1022,7 +1050,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match closure_clause { match closure_clause {
// Only migrate if closure is a move closure // Only migrate if closure is a move closure
hir::CaptureBy::Value => return Some(FxHashSet::default()), hir::CaptureBy::Value => {
let diagnostics_info = FxHashSet::default();
//diagnostics_info.insert(CapturesInfo::CapturingNothing);
//let upvars = self.tcx.upvars_mentioned(closure_def_id).expect("must be an upvar");
//let _span = upvars[&var_hir_id];
return Some(diagnostics_info);
}
hir::CaptureBy::Ref => {} hir::CaptureBy::Ref => {}
} }
@ -1095,9 +1129,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
closure_span: Span, closure_span: Span,
closure_clause: hir::CaptureBy, closure_clause: hir::CaptureBy,
min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>, min_captures: Option<&ty::RootVariableMinCaptureList<'tcx>>,
) -> (Vec<MigrationDiagnosticInfo>, String) { ) -> (Vec<NeededMigration>, MigrationWarningReason) {
let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) else { let Some(upvars) = self.tcx.upvars_mentioned(closure_def_id) else {
return (Vec::new(), String::new()); return (Vec::new(), MigrationWarningReason::default());
}; };
let mut need_migrations = Vec::new(); let mut need_migrations = Vec::new();
@ -1106,7 +1140,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Perform auto-trait analysis // Perform auto-trait analysis
for (&var_hir_id, _) in upvars.iter() { for (&var_hir_id, _) in upvars.iter() {
let mut responsible_captured_hir_ids = Vec::new(); let mut diagnostics_info = Vec::new();
let auto_trait_diagnostic = if let Some(diagnostics_info) = let auto_trait_diagnostic = if let Some(diagnostics_info) =
self.compute_2229_migrations_for_trait(min_captures, var_hir_id, closure_clause) self.compute_2229_migrations_for_trait(min_captures, var_hir_id, closure_clause)
@ -1138,38 +1172,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut capture_diagnostic = capture_diagnostic.into_iter().collect::<Vec<_>>(); let mut capture_diagnostic = capture_diagnostic.into_iter().collect::<Vec<_>>();
capture_diagnostic.sort(); capture_diagnostic.sort();
for captured_info in capture_diagnostic.iter() { for captures_info in capture_diagnostic {
// Get the auto trait reasons of why migration is needed because of that capture, if there are any // Get the auto trait reasons of why migration is needed because of that capture, if there are any
let capture_trait_reasons = let capture_trait_reasons =
if let Some(reasons) = auto_trait_diagnostic.get(captured_info) { if let Some(reasons) = auto_trait_diagnostic.get(&captures_info) {
reasons.clone() reasons.clone()
} else { } else {
FxHashSet::default() FxHashSet::default()
}; };
// Check if migration is needed because of drop reorder as a result of that capture // Check if migration is needed because of drop reorder as a result of that capture
let capture_drop_reorder_reason = drop_reorder_diagnostic.contains(captured_info); let capture_drop_reorder_reason = drop_reorder_diagnostic.contains(&captures_info);
// Combine all the reasons of why the root variable should be captured as a result of // Combine all the reasons of why the root variable should be captured as a result of
// auto trait implementation issues // auto trait implementation issues
auto_trait_migration_reasons.extend(capture_trait_reasons.clone()); auto_trait_migration_reasons.extend(capture_trait_reasons.clone());
match captured_info { diagnostics_info.push(MigrationLintNote {
CapturesInfo::CapturingLess { source_expr, var_name } => { captures_info,
responsible_captured_hir_ids.push(( reason: self.compute_2229_migrations_reasons(
*source_expr, capture_trait_reasons,
var_name.clone(), capture_drop_reorder_reason,
self.compute_2229_migrations_reasons( ),
capture_trait_reasons, });
capture_drop_reorder_reason,
),
));
}
}
} }
if !capture_diagnostic.is_empty() { if !diagnostics_info.is_empty() {
need_migrations.push((var_hir_id, responsible_captured_hir_ids)); need_migrations.push(NeededMigration { var_hir_id, diagnostics_info });
} }
} }
( (
@ -2130,10 +2159,12 @@ fn should_do_rust_2021_incompatible_closure_captures_analysis(
/// - s2: Comma separated names of the variables being migrated. /// - s2: Comma separated names of the variables being migrated.
fn migration_suggestion_for_2229( fn migration_suggestion_for_2229(
tcx: TyCtxt<'_>, tcx: TyCtxt<'_>,
need_migrations: &Vec<MigrationDiagnosticInfo>, need_migrations: &Vec<NeededMigration>,
) -> (String, String) { ) -> (String, String) {
let need_migrations_variables = let need_migrations_variables = need_migrations
need_migrations.iter().map(|(v, _)| var_name(tcx, *v)).collect::<Vec<_>>(); .iter()
.map(|NeededMigration { var_hir_id: v, .. }| var_name(tcx, *v))
.collect::<Vec<_>>();
let migration_ref_concat = let migration_ref_concat =
need_migrations_variables.iter().map(|v| format!("&{}", v)).collect::<Vec<_>>().join(", "); need_migrations_variables.iter().map(|v| format!("&{}", v)).collect::<Vec<_>>().join(", ");

9
src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.fixed
View file

@ -20,7 +20,7 @@ fn test_send_trait() {
let mut f = 10; let mut f = 10;
let fptr = SendPointer(&mut f as *mut i32); let fptr = SendPointer(&mut f as *mut i32);
thread::spawn(move || { let _ = &fptr; unsafe { thread::spawn(move || { let _ = &fptr; unsafe {
//~^ ERROR: `Send` trait implementation for closure //~^ ERROR: changes to closure capture
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0` does not implement `Send` //~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr` to be fully captured //~| HELP: add a dummy let to cause `fptr` to be fully captured
@ -40,8 +40,9 @@ fn test_sync_trait() {
let f = CustomInt(&mut f as *mut i32); let f = CustomInt(&mut f as *mut i32);
let fptr = SyncPointer(f); let fptr = SyncPointer(f);
thread::spawn(move || { let _ = &fptr; unsafe { thread::spawn(move || { let _ = &fptr; unsafe {
//~^ ERROR: `Sync`, `Send` trait implementation for closure //~^ ERROR: changes to closure capture
//~| NOTE: in Rust 2018, this closure implements `Sync`, `Send` as `fptr` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr.0.0` does not implement `Sync`, `Send` //~| NOTE: in Rust 2018, this closure implements `Sync` as `fptr` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr.0.0` does not implement `Sync`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr` to be fully captured //~| HELP: add a dummy let to cause `fptr` to be fully captured
*fptr.0.0 = 20; *fptr.0.0 = 20;
@ -65,7 +66,7 @@ fn test_clone_trait() {
let f = U(S(Foo(0)), T(0)); let f = U(S(Foo(0)), T(0));
let c = || { let c = || {
let _ = &f; let _ = &f;
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f` to be fully captured //~| HELP: add a dummy let to cause `f` to be fully captured

9
src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.rs
View file

@ -20,7 +20,7 @@ fn test_send_trait() {
let mut f = 10; let mut f = 10;
let fptr = SendPointer(&mut f as *mut i32); let fptr = SendPointer(&mut f as *mut i32);
thread::spawn(move || unsafe { thread::spawn(move || unsafe {
//~^ ERROR: `Send` trait implementation for closure //~^ ERROR: changes to closure capture
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0` does not implement `Send` //~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr` to be fully captured //~| HELP: add a dummy let to cause `fptr` to be fully captured
@ -40,8 +40,9 @@ fn test_sync_trait() {
let f = CustomInt(&mut f as *mut i32); let f = CustomInt(&mut f as *mut i32);
let fptr = SyncPointer(f); let fptr = SyncPointer(f);
thread::spawn(move || unsafe { thread::spawn(move || unsafe {
//~^ ERROR: `Sync`, `Send` trait implementation for closure //~^ ERROR: changes to closure capture
//~| NOTE: in Rust 2018, this closure implements `Sync`, `Send` as `fptr` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr.0.0` does not implement `Sync`, `Send` //~| NOTE: in Rust 2018, this closure implements `Sync` as `fptr` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr.0.0` does not implement `Sync`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr` to be fully captured //~| HELP: add a dummy let to cause `fptr` to be fully captured
*fptr.0.0 = 20; *fptr.0.0 = 20;
@ -64,7 +65,7 @@ impl Clone for U {
fn test_clone_trait() { fn test_clone_trait() {
let f = U(S(Foo(0)), T(0)); let f = U(S(Foo(0)), T(0));
let c = || { let c = || {
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f` to be fully captured //~| HELP: add a dummy let to cause `f` to be fully captured

15
src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.stderr
View file

@ -1,4 +1,4 @@
error: changes to closure capture in Rust 2021 will affect `Send` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/auto_traits.rs:22:19 --> $DIR/auto_traits.rs:22:19
| |
LL | thread::spawn(move || unsafe { LL | thread::spawn(move || unsafe {
@ -23,11 +23,14 @@ LL |
LL | *fptr.0 = 20; LL | *fptr.0 = 20;
... ...
error: changes to closure capture in Rust 2021 will affect `Sync`, `Send` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/auto_traits.rs:42:19 --> $DIR/auto_traits.rs:42:19
| |
LL | thread::spawn(move || unsafe { LL | thread::spawn(move || unsafe {
| ^^^^^^^^^^^^^^ in Rust 2018, this closure implements `Sync`, `Send` as `fptr` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr.0.0` does not implement `Sync`, `Send` | ^^^^^^^^^^^^^^
| |
| in Rust 2018, this closure implements `Sync` as `fptr` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr.0.0` does not implement `Sync`
| in Rust 2018, this closure implements `Send` as `fptr` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr.0.0` does not implement `Send`
... ...
LL | *fptr.0.0 = 20; LL | *fptr.0.0 = 20;
| --------- in Rust 2018, this closure captures all of `fptr`, but in Rust 2021, it will only capture `fptr.0.0` | --------- in Rust 2018, this closure captures all of `fptr`, but in Rust 2021, it will only capture `fptr.0.0`
@ -40,11 +43,11 @@ LL |
LL | LL |
LL | LL |
LL | LL |
LL | *fptr.0.0 = 20; LL |
... ...
error: changes to closure capture in Rust 2021 will affect `Clone` trait implementation for closure and drop order error: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
--> $DIR/auto_traits.rs:66:13 --> $DIR/auto_traits.rs:67:13
| |
LL | let c = || { LL | let c = || {
| ^^ in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone` | ^^ in Rust 2018, this closure implements `Clone` as `f` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f.1` does not implement `Clone`

5
src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.fixed
View file

@ -19,8 +19,9 @@ where
let f = panic::AssertUnwindSafe(f); let f = panic::AssertUnwindSafe(f);
let result = panic::catch_unwind(move || { let result = panic::catch_unwind(move || {
let _ = &f; let _ = &f;
//~^ ERROR: `UnwindSafe`, `RefUnwindSafe` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `UnwindSafe`, `RefUnwindSafe` as `f` implements `UnwindSafe`, `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe`, `RefUnwindSafe` as `f.0` does not implement `UnwindSafe`, `RefUnwindSafe` //~| NOTE: in Rust 2018, this closure implements `UnwindSafe` as `f` implements `UnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe` as `f.0` does not implement `UnwindSafe`
//~| NOTE: in Rust 2018, this closure implements `RefUnwindSafe` as `f` implements `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `RefUnwindSafe` as `f.0` does not implement `RefUnwindSafe`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f` to be fully captured //~| HELP: add a dummy let to cause `f` to be fully captured
f.0() f.0()

5
src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.rs
View file

@ -18,8 +18,9 @@ where
{ {
let f = panic::AssertUnwindSafe(f); let f = panic::AssertUnwindSafe(f);
let result = panic::catch_unwind(move || { let result = panic::catch_unwind(move || {
//~^ ERROR: `UnwindSafe`, `RefUnwindSafe` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `UnwindSafe`, `RefUnwindSafe` as `f` implements `UnwindSafe`, `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe`, `RefUnwindSafe` as `f.0` does not implement `UnwindSafe`, `RefUnwindSafe` //~| NOTE: in Rust 2018, this closure implements `UnwindSafe` as `f` implements `UnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe` as `f.0` does not implement `UnwindSafe`
//~| NOTE: in Rust 2018, this closure implements `RefUnwindSafe` as `f` implements `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `RefUnwindSafe` as `f.0` does not implement `RefUnwindSafe`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f` to be fully captured //~| HELP: add a dummy let to cause `f` to be fully captured
f.0() f.0()

7
src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
View file

@ -1,8 +1,11 @@
error: changes to closure capture in Rust 2021 will affect `UnwindSafe`, `RefUnwindSafe` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/mir_calls_to_shims.rs:20:38 --> $DIR/mir_calls_to_shims.rs:20:38
| |
LL | let result = panic::catch_unwind(move || { LL | let result = panic::catch_unwind(move || {
| ^^^^^^^ in Rust 2018, this closure implements `UnwindSafe`, `RefUnwindSafe` as `f` implements `UnwindSafe`, `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe`, `RefUnwindSafe` as `f.0` does not implement `UnwindSafe`, `RefUnwindSafe` | ^^^^^^^
| |
| in Rust 2018, this closure implements `UnwindSafe` as `f` implements `UnwindSafe`, but in Rust 2021, this closure will no longer implement `UnwindSafe` as `f.0` does not implement `UnwindSafe`
| in Rust 2018, this closure implements `RefUnwindSafe` as `f` implements `RefUnwindSafe`, but in Rust 2021, this closure will no longer implement `RefUnwindSafe` as `f.0` does not implement `RefUnwindSafe`
... ...
LL | f.0() LL | f.0()
| --- in Rust 2018, this closure captures all of `f`, but in Rust 2021, it will only capture `f.0` | --- in Rust 2018, this closure captures all of `f`, but in Rust 2021, it will only capture `f.0`

14
src/test/ui/closures/2229_closure_analysis/migrations/multi_diagnostics.fixed
View file

@ -18,7 +18,6 @@ impl Foo {
} }
} }
struct S(Foo); struct S(Foo);
#[derive(Clone)] #[derive(Clone)]
@ -37,7 +36,7 @@ fn test_multi_issues() {
let f2 = U(S(Foo::from("bar")), T(0)); let f2 = U(S(Foo::from("bar")), T(0));
let c = || { let c = || {
let _ = (&f1, &f2); let _ = (&f1, &f2);
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1`, `f2` to be fully captured //~| HELP: add a dummy let to cause `f1`, `f2` to be fully captured
@ -57,7 +56,7 @@ fn test_capturing_all_disjoint_fields_individually() {
let f1 = U(S(Foo::from("foo")), T(0)); let f1 = U(S(Foo::from("foo")), T(0));
let c = || { let c = || {
let _ = &f1; let _ = &f1;
//~^ ERROR: `Clone` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1` to be fully captured //~| HELP: add a dummy let to cause `f1` to be fully captured
@ -83,7 +82,7 @@ fn test_capturing_several_disjoint_fields_individually_1() {
let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar"))); let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar")));
let c = || { let c = || {
let _ = &f1; let _ = &f1;
//~^ ERROR: `Clone` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.2` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.2` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
@ -103,7 +102,7 @@ fn test_capturing_several_disjoint_fields_individually_2() {
let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar"))); let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar")));
let c = || { let c = || {
let _ = &f1; let _ = &f1;
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1` to be fully captured //~| HELP: add a dummy let to cause `f1` to be fully captured
@ -136,8 +135,9 @@ fn test_multi_traits_issues() {
let mut f2 = 10; let mut f2 = 10;
let fptr2 = SendPointer(&mut f2 as *mut i32); let fptr2 = SendPointer(&mut f2 as *mut i32);
thread::spawn(move || { let _ = (&fptr1, &fptr2); unsafe { thread::spawn(move || { let _ = (&fptr1, &fptr2); unsafe {
//~^ ERROR: `Sync`, `Send` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021
//~| NOTE: in Rust 2018, this closure implements `Sync`, `Send` as `fptr1` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr1.0.0` does not implement `Sync`, `Send` //~| NOTE: in Rust 2018, this closure implements `Sync` as `fptr1` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr1.0.0` does not implement `Sync`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr1` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr1.0.0` does not implement `Send`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send` //~| NOTE: in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr1`, `fptr2` to be fully captured //~| HELP: add a dummy let to cause `fptr1`, `fptr2` to be fully captured

14
src/test/ui/closures/2229_closure_analysis/migrations/multi_diagnostics.rs
View file

@ -18,7 +18,6 @@ impl Foo {
} }
} }
struct S(Foo); struct S(Foo);
#[derive(Clone)] #[derive(Clone)]
@ -36,7 +35,7 @@ fn test_multi_issues() {
let f1 = U(S(Foo::from("foo")), T(0)); let f1 = U(S(Foo::from("foo")), T(0));
let f2 = U(S(Foo::from("bar")), T(0)); let f2 = U(S(Foo::from("bar")), T(0));
let c = || { let c = || {
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1`, `f2` to be fully captured //~| HELP: add a dummy let to cause `f1`, `f2` to be fully captured
@ -55,7 +54,7 @@ fn test_multi_issues() {
fn test_capturing_all_disjoint_fields_individually() { fn test_capturing_all_disjoint_fields_individually() {
let f1 = U(S(Foo::from("foo")), T(0)); let f1 = U(S(Foo::from("foo")), T(0));
let c = || { let c = || {
//~^ ERROR: `Clone` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1` to be fully captured //~| HELP: add a dummy let to cause `f1` to be fully captured
@ -80,7 +79,7 @@ impl Clone for U1 {
fn test_capturing_several_disjoint_fields_individually_1() { fn test_capturing_several_disjoint_fields_individually_1() {
let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar"))); let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar")));
let c = || { let c = || {
//~^ ERROR: `Clone` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021 will affect which traits the closure implements [rust_2021_incompatible_closure_captures]
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.2` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.2` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
@ -99,7 +98,7 @@ fn test_capturing_several_disjoint_fields_individually_1() {
fn test_capturing_several_disjoint_fields_individually_2() { fn test_capturing_several_disjoint_fields_individually_2() {
let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar"))); let f1 = U1(S(Foo::from("foo")), T(0), S(Foo::from("bar")));
let c = || { let c = || {
//~^ ERROR: `Clone` trait implementation for closure and drop order //~^ ERROR: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
//~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` //~| NOTE: in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `f1` to be fully captured //~| HELP: add a dummy let to cause `f1` to be fully captured
@ -132,8 +131,9 @@ fn test_multi_traits_issues() {
let mut f2 = 10; let mut f2 = 10;
let fptr2 = SendPointer(&mut f2 as *mut i32); let fptr2 = SendPointer(&mut f2 as *mut i32);
thread::spawn(move || unsafe { thread::spawn(move || unsafe {
//~^ ERROR: `Sync`, `Send` trait implementation for closure //~^ ERROR: changes to closure capture in Rust 2021
//~| NOTE: in Rust 2018, this closure implements `Sync`, `Send` as `fptr1` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr1.0.0` does not implement `Sync`, `Send` //~| NOTE: in Rust 2018, this closure implements `Sync` as `fptr1` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr1.0.0` does not implement `Sync`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr1` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr1.0.0` does not implement `Send`
//~| NOTE: in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send` //~| NOTE: in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send`
//~| NOTE: for more information, see //~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `fptr1`, `fptr2` to be fully captured //~| HELP: add a dummy let to cause `fptr1`, `fptr2` to be fully captured

23
src/test/ui/closures/2229_closure_analysis/migrations/multi_diagnostics.stderr
View file

@ -1,5 +1,5 @@
error: changes to closure capture in Rust 2021 will affect `Clone` trait implementation for closure and drop order error: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
--> $DIR/multi_diagnostics.rs:38:13 --> $DIR/multi_diagnostics.rs:37:13
| |
LL | let c = || { LL | let c = || {
| ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` | ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
@ -25,8 +25,8 @@ LL ~ let c = || {
LL + let _ = (&f1, &f2); LL + let _ = (&f1, &f2);
| |
error: changes to closure capture in Rust 2021 will affect `Clone` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/multi_diagnostics.rs:57:13 --> $DIR/multi_diagnostics.rs:56:13
| |
LL | let c = || { LL | let c = || {
| ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` | ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
@ -41,8 +41,8 @@ LL ~ let c = || {
LL + let _ = &f1; LL + let _ = &f1;
| |
error: changes to closure capture in Rust 2021 will affect `Clone` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/multi_diagnostics.rs:82:13 --> $DIR/multi_diagnostics.rs:81:13
| |
LL | let c = || { LL | let c = || {
| ^^ | ^^
@ -63,8 +63,8 @@ LL ~ let c = || {
LL + let _ = &f1; LL + let _ = &f1;
| |
error: changes to closure capture in Rust 2021 will affect `Clone` trait implementation for closure and drop order error: changes to closure capture in Rust 2021 will affect drop order and which traits the closure implements
--> $DIR/multi_diagnostics.rs:101:13 --> $DIR/multi_diagnostics.rs:100:13
| |
LL | let c = || { LL | let c = || {
| ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone` | ^^ in Rust 2018, this closure implements `Clone` as `f1` implements `Clone`, but in Rust 2021, this closure will no longer implement `Clone` as `f1.0` does not implement `Clone`
@ -88,13 +88,14 @@ LL ~ let c = || {
LL + let _ = &f1; LL + let _ = &f1;
| |
error: changes to closure capture in Rust 2021 will affect `Sync`, `Send` trait implementation for closure error: changes to closure capture in Rust 2021 will affect which traits the closure implements
--> $DIR/multi_diagnostics.rs:134:19 --> $DIR/multi_diagnostics.rs:133:19
| |
LL | thread::spawn(move || unsafe { LL | thread::spawn(move || unsafe {
| ^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^
| | | |
| in Rust 2018, this closure implements `Sync`, `Send` as `fptr1` implements `Sync`, `Send`, but in Rust 2021, this closure will no longer implement `Sync`, `Send` as `fptr1.0.0` does not implement `Sync`, `Send` | in Rust 2018, this closure implements `Sync` as `fptr1` implements `Sync`, but in Rust 2021, this closure will no longer implement `Sync` as `fptr1.0.0` does not implement `Sync`
| in Rust 2018, this closure implements `Send` as `fptr1` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr1.0.0` does not implement `Send`
| in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send` | in Rust 2018, this closure implements `Send` as `fptr2` implements `Send`, but in Rust 2021, this closure will no longer implement `Send` as `fptr2.0` does not implement `Send`
... ...
LL | *fptr1.0.0 = 20; LL | *fptr1.0.0 = 20;