Only offer the [const] Destruct suggestion on a nightly compiler

The suggested bound requires the unstable `const_destruct` feature,
so it is not actionable on a stable compiler.
Add a run-make test that verifies the suggestion is only emitted on nightly.

Author: jakubadamw

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -614,7 +614,10 @@ impl<'tcx> NonConstOp<'tcx> for LiveDrop<'tcx> {
         };
 
         // If the dropped type is a type parameter, suggest adding a `[const] Destruct` bound.
-        if let Param(param_ty) = self.dropped_ty.kind() {
+        // The suggestion is only offered on nightly, since `[const]` bounds are unstable.
+        if let Param(param_ty) = self.dropped_ty.kind()
+            && ccx.tcx.sess.is_nightly_build()
+        {
             let tcx = ccx.tcx;
             let caller = ccx.def_id();
             if let Some(generics) = tcx.hir_node_by_def_id(caller).generics() {

tests/run-make/const-destruct-stable-toolchain/const-drop-nightly.stderr

@@ -0,0 +1,16 @@
+error[E0493]: destructor of `T` cannot be evaluated at compile-time
+  --> const-drop.rs:1:24
+   |
+LL | const fn const_drop<T>(_: T) {}
+   |                        ^      - value is dropped here
+   |                        |
+   |                        the destructor for this type cannot be evaluated in constant functions
+   |
+help: consider restricting type parameter `T` with unstable trait `Destruct`
+   |
+LL | const fn const_drop<T: [const] Destruct>(_: T) {}
+   |                      ++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0493`.

tests/run-make/const-destruct-stable-toolchain/const-drop-stable.stderr

@@ -0,0 +1,11 @@
+error[E0493]: destructor of `T` cannot be evaluated at compile-time
+ --> const-drop.rs:1:24
+  |
+1 | const fn const_drop<T>(_: T) {}
+  |                        ^      - value is dropped here
+  |                        |
+  |                        the destructor for this type cannot be evaluated in constant functions
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0493`.

tests/run-make/const-destruct-stable-toolchain/const-drop.rs

@@ -0,0 +1,3 @@
+const fn const_drop<T>(_: T) {}
+
+fn main() {}

tests/run-make/const-destruct-stable-toolchain/rmake.rs

@@ -0,0 +1,26 @@
+//@ needs-target-std
+//
+// Test that the suggestion to constrain a type parameter that is dropped in a const
+// function with a `[const] Destruct` bound is only offered on nightly, since the bound
+// requires an unstable feature.
+
+use run_make_support::{diff, rustc};
+
+fn main() {
+    let out = rustc()
+        .input("const-drop.rs")
+        .env("RUSTC_BOOTSTRAP", "-1")
+        .run_fail()
+        .assert_stderr_not_contains("consider restricting type parameter `T`")
+        .stderr_utf8();
+    diff().expected_file("const-drop-stable.stderr").actual_text("(rustc)", &out).run();
+    let out = rustc()
+        .input("const-drop.rs")
+        .ui_testing()
+        .run_fail()
+        .assert_stderr_contains(
+            "consider restricting type parameter `T` with unstable trait `Destruct`",
+        )
+        .stderr_utf8();
+    diff().expected_file("const-drop-nightly.stderr").actual_text("(rustc)", &out).run();
+}