make Destruct trait coinductive

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -424,7 +424,7 @@ where
 
         ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| {
             ecx.add_goals(
-                GoalSource::AliasBoundConstCondition,
+                GoalSource::ImplWhereBound,
                 const_conditions.into_iter().map(|trait_ref| {
                     goal.with(
                         cx,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -82,13 +82,10 @@ enum CurrentGoalKind {
 impl CurrentGoalKind {
     fn from_query_input<I: Interner>(cx: I, input: QueryInput<I, I::Predicate>) -> CurrentGoalKind {
         match input.goal.predicate.kind().skip_binder() {
-            ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
-                if cx.trait_is_coinductive(pred.trait_ref.def_id) {
-                    CurrentGoalKind::CoinductiveTrait
-                } else {
-                    CurrentGoalKind::Misc
-                }
-            }
+            ty::PredicateKind::Clause(
+                ty::ClauseKind::Trait(ty::TraitClause { trait_ref, .. })
+                | ty::ClauseKind::HostEffect(ty::HostEffectClause { trait_ref, .. }),
+            ) if cx.trait_is_coinductive(trait_ref.def_id) => CurrentGoalKind::CoinductiveTrait,
             ty::PredicateKind::NormalizesTo(_) => {
                 CurrentGoalKind::ProjectionComputeAssocTermCandidate
             }

library/core/src/marker.rs

@@ -1060,6 +1060,7 @@ marker_impls! {
 #[diagnostic::on_unimplemented(message = "can't drop `{Self}`")]
 #[rustc_deny_explicit_impl]
 #[rustc_dyn_incompatible_trait]
+#[rustc_coinductive]
 pub const trait Destruct: PointeeSized {}
 
 /// A marker for tuple types.

tests/ui/consts/const_destruct_coinduction.rs

@@ -0,0 +1,22 @@
+//@ check-pass
+//@ compile-flags: -Znext-solver
+
+#![feature(const_trait_impl)]
+#![feature(const_destruct)]
+
+use std::marker::Destruct;
+
+struct Wrap<T>(*const T);
+
+const impl<T: [const] Destruct> Drop for Wrap<T> {
+    fn drop(&mut self) {}
+}
+
+enum Foo {
+    A,
+    B(Wrap<Self>),
+}
+
+const fn drop_foo(_: Foo) {}
+
+fn main() {}