Note the type when unable to drop values in compile time

Author: fee1-dead

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -1009,7 +1009,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
  if needs_non_const_drop {
  self.check_op_spanned(
- ops::LiveDrop { dropped_at: Some(terminator.source_info.span) },
+ ops::LiveDrop {
+ dropped_at: Some(terminator.source_info.span),
+ dropped_ty: ty_of_dropped_place,
+ },
  err_span,
  );
  }

compiler/rustc_const_eval/src/transform/check_consts/ops.rs

@@ -422,10 +422,11 @@ impl<'tcx> NonConstOp<'tcx> for InlineAsm {
 }
 
 #[derive(Debug)]
-pub struct LiveDrop {
+pub struct LiveDrop<'tcx> {
  pub dropped_at: Option<Span>,
+ pub dropped_ty: Ty<'tcx>,
 }
-impl<'tcx> NonConstOp<'tcx> for LiveDrop {
+impl<'tcx> NonConstOp<'tcx> for LiveDrop<'tcx> {
  fn build_error(
  &self,
  ccx: &ConstCx<'_, 'tcx>,
@@ -435,9 +436,13 @@ impl<'tcx> NonConstOp<'tcx> for LiveDrop {
  ccx.tcx.sess,
  span,
  E0493,
- "destructors cannot be evaluated at compile-time"
+ "destructor of `{}` cannot be evaluated at compile-time",
+ self.dropped_ty,
+ );
+ err.span_label(
+ span,
+ format!("the destructor for this type cannot be evaluated in {}s", ccx.const_kind()),
  );
- err.span_label(span, format!("{}s cannot evaluate destructors", ccx.const_kind()));
  if let Some(span) = self.dropped_at {
  err.span_label(span, "value is dropped here");
  }

compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs

@@ -1,6 +1,6 @@
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{self, BasicBlock, Location};
-use rustc_middle::ty::TyCtxt;
+use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_span::{symbol::sym, Span};
 
 use super::check::Qualifs;
@@ -58,9 +58,9 @@ impl<'mir, 'tcx> std::ops::Deref for CheckLiveDrops<'mir, 'tcx> {
  }
 }
 
-impl CheckLiveDrops<'_, '_> {
- fn check_live_drop(&self, span: Span) {
- ops::LiveDrop { dropped_at: None }.build_error(self.ccx, span).emit();
+impl<'tcx> CheckLiveDrops<'_, 'tcx> {
+ fn check_live_drop(&self, span: Span, dropped_ty: Ty<'tcx>) {
+ ops::LiveDrop { dropped_at: None, dropped_ty }.build_error(self.ccx, span).emit();
  }
 }
 
@@ -90,7 +90,7 @@ impl<'tcx> Visitor<'tcx> for CheckLiveDrops<'_, 'tcx> {
  }
 
  if dropped_place.is_indirect() {
- self.check_live_drop(terminator.source_info.span);
+ self.check_live_drop(terminator.source_info.span, dropped_ty);
  return;
  }
 
@@ -101,7 +101,7 @@ impl<'tcx> Visitor<'tcx> for CheckLiveDrops<'_, 'tcx> {
  if self.qualifs.needs_non_const_drop(self.ccx, dropped_place.local, location) {
  // Use the span where the dropped local was declared for the error.
  let span = self.body.local_decls[dropped_place.local].source_info.span;
- self.check_live_drop(span);
+ self.check_live_drop(span, dropped_ty);
  }
  }
 

src/test/ui/check-static-values-constraints.rs

@@ -63,7 +63,7 @@ static STATIC8: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
 // This example should fail because field1 in the base struct is not safe
 static STATIC9: SafeStruct = SafeStruct{field1: SafeEnum::Variant1,
  ..SafeStruct{field1: SafeEnum::Variant3(WithDtor),
-//~^ ERROR destructors cannot be evaluated at compile-time
+//~^ ERROR destructor of
  field2: SafeEnum::Variant1}};
 
 struct UnsafeStruct;

src/test/ui/check-static-values-constraints.stderr

@@ -1,4 +1,4 @@
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `SafeStruct` cannot be evaluated at compile-time
  --> $DIR/check-static-values-constraints.rs:65:43
  |
 LL | ..SafeStruct{field1: SafeEnum::Variant3(WithDtor),
@@ -7,7 +7,7 @@ LL | |
 LL | | field2: SafeEnum::Variant1}};
  | | ^- value is dropped here
  | |________________________________________________________________________________|
- | statics cannot evaluate destructors
+ | the destructor for this type cannot be evaluated in statics
 
 error[E0010]: allocations are not allowed in statics
  --> $DIR/check-static-values-constraints.rs:79:33

src/test/ui/consts/const-eval/const_let.rs

@@ -14,16 +14,16 @@ const X2: FakeNeedsDrop = { let x; x = FakeNeedsDrop; x };
 
 // error
 const Y: FakeNeedsDrop = { let mut x = FakeNeedsDrop; x = FakeNeedsDrop; x };
-//~^ ERROR destructors cannot be evaluated at compile-time
+//~^ ERROR destructor of
 
 // error
 const Y2: FakeNeedsDrop = { let mut x; x = FakeNeedsDrop; x = FakeNeedsDrop; x };
-//~^ ERROR destructors cannot be evaluated at compile-time
+//~^ ERROR destructor of
 
 // error
 const Z: () = { let mut x = None; x = Some(FakeNeedsDrop); };
-//~^ ERROR destructors cannot be evaluated at compile-time
+//~^ ERROR destructor of
 
 // error
 const Z2: () = { let mut x; x = None; x = Some(FakeNeedsDrop); };
-//~^ ERROR destructors cannot be evaluated at compile-time
+//~^ ERROR destructor of

src/test/ui/consts/const-eval/const_let.stderr

@@ -1,34 +1,34 @@
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `FakeNeedsDrop` cannot be evaluated at compile-time
  --> $DIR/const_let.rs:16:32
  |
 LL | const Y: FakeNeedsDrop = { let mut x = FakeNeedsDrop; x = FakeNeedsDrop; x };
  | ^^^^^ - value is dropped here
  | |
- | constants cannot evaluate destructors
+ | the destructor for this type cannot be evaluated in constants
 
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `FakeNeedsDrop` cannot be evaluated at compile-time
  --> $DIR/const_let.rs:20:33
  |
 LL | const Y2: FakeNeedsDrop = { let mut x; x = FakeNeedsDrop; x = FakeNeedsDrop; x };
  | ^^^^^ - value is dropped here
  | |
- | constants cannot evaluate destructors
+ | the destructor for this type cannot be evaluated in constants
 
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `Option<FakeNeedsDrop>` cannot be evaluated at compile-time
  --> $DIR/const_let.rs:24:21
  |
 LL | const Z: () = { let mut x = None; x = Some(FakeNeedsDrop); };
  | ^^^^^ - value is dropped here
  | |
- | constants cannot evaluate destructors
+ | the destructor for this type cannot be evaluated in constants
 
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `Option<FakeNeedsDrop>` cannot be evaluated at compile-time
  --> $DIR/const_let.rs:28:22
  |
 LL | const Z2: () = { let mut x; x = None; x = Some(FakeNeedsDrop); };
  | ^^^^^ - value is dropped here
  | |
- | constants cannot evaluate destructors
+ | the destructor for this type cannot be evaluated in constants
 
 error: aborting due to 4 previous errors
 

src/test/ui/consts/const-eval/issue-65394.rs

@@ -4,7 +4,7 @@
 // We will likely have to change this behavior before we allow `&mut` in a `const`.
 
 const _: Vec<i32> = {
- let mut x = Vec::<i32>::new(); //~ ERROR destructors cannot be evaluated at compile-time
+ let mut x = Vec::<i32>::new(); //~ ERROR destructor of
  let r = &mut x; //~ ERROR mutable references are not allowed in constants
  let y = x;
  y

src/test/ui/consts/const-eval/issue-65394.stderr

@@ -7,11 +7,11 @@ LL | let r = &mut x;
  = note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
  = help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
 
-error[E0493]: destructors cannot be evaluated at compile-time
+error[E0493]: destructor of `Vec<i32>` cannot be evaluated at compile-time
  --> $DIR/issue-65394.rs:7:9
  |
 LL | let mut x = Vec::<i32>::new();
- | ^^^^^ constants cannot evaluate destructors
+ | ^^^^^ the destructor for this type cannot be evaluated in constants
 ...
 LL | };
  | - value is dropped here

src/test/ui/consts/const-eval/livedrop.rs

@@ -1,6 +1,6 @@
 const _: Option<Vec<i32>> = {
  let mut never_returned = Some(Vec::new());
- let mut always_returned = None; //~ ERROR destructors cannot be evaluated at compile-time
+ let mut always_returned = None; //~ ERROR destructor of
 
  let mut i = 0;
  loop {