Elaborate structural destruct host effect clauses

ShoyuVanilla · ShoyuVanilla · commit 07af01cb3877 · 2025-08-06T14:55:23.000+09:00
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -400,6 +400,19 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 ty::BoundConstness::Const
             }
         };
+
+        // Only elaborate host-effect destruct obligations when comparing impl method bounds
+        // against the corresponding trait method bounds.
+        let elaborate = matches!(
+            tcx.hir_node_by_def_id(body_id),
+            hir::Node::ImplItem(hir::ImplItem {
+                trait_item_def_id: Some(did),
+                ..
+            }) if *did == callee,
+        );
+        let param_env =
+            if elaborate { param_env.elaborate_host_effect_destruct(tcx) } else { param_env };
+
         let const_conditions =
             ocx.normalize(&ObligationCause::misc(call_span, body_id), param_env, const_conditions);
         ocx.register_obligations(const_conditions.into_iter().map(|(trait_ref, span)| {
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
@@ -922,10 +922,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         ObligationCauseCode::WhereClause(callee_did, pred_span)
                     },
                 );
+
+                // Only elaborate host-effect destruct obligations when comparing impl method
+                // bounds against the corresponding trait method bounds.
+                let elaborate = matches!(
+                    self.tcx.hir_node_by_def_id(self.body_id),
+                    hir::Node::ImplItem(hir::ImplItem {
+                        trait_item_def_id: Some(did),
+                        ..
+                    }) if *did == callee_did,
+                );
+                let param_env = if elaborate {
+                    self.param_env.elaborate_host_effect_destruct(self.tcx)
+                } else {
+                    self.param_env
+                };
+
                 self.register_predicate(Obligation::new(
                     self.tcx,
                     cause,
-                    self.param_env,
+                    param_env,
                     cond.to_host_effect_clause(self.tcx, host),
                 ));
             }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -1011,6 +1011,15 @@ impl<'tcx> ParamEnv<'tcx> {
     pub fn and<T: TypeVisitable<TyCtxt<'tcx>>>(self, value: T) -> ParamEnvAnd<'tcx, T> {
         ParamEnvAnd { param_env: self, value }
     }
+
+    pub fn elaborate_host_effect_destruct(self, tcx: TyCtxt<'tcx>) -> Self {
+        // TODO: Feature gate
+        let caller_bounds = tcx.mk_clauses_from_iter(
+            ty::elaborate::elaborate(tcx, self.caller_bounds.iter())
+                .elaborate_host_effect_destruct(),
+        );
+        ParamEnv { caller_bounds }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
@@ -6,7 +6,7 @@ use crate::data_structures::HashSet;
 use crate::inherent::*;
 use crate::lang_items::TraitSolverLangItem;
 use crate::outlives::{Component, push_outlives_components};
-use crate::{self as ty, Interner, Upcast as _};
+use crate::{self as ty, Interner, Upcast as _, solve};
 
 /// "Elaboration" is the process of identifying all the predicates that
 /// are implied by a source predicate. Currently, this basically means
@@ -20,6 +20,7 @@ pub struct Elaborator<I: Interner, O> {
     visited: HashSet<ty::Binder<I, ty::PredicateKind<I>>>,
     mode: Filter,
     elaborate_sized: ElaborateSized,
+    elaborate_host_effect_destruct: ElaborateHostEffectDestruct,
 }
 
 enum Filter {
@@ -33,6 +34,12 @@ enum ElaborateSized {
     No,
 }
 
+#[derive(Eq, PartialEq)]
+enum ElaborateHostEffectDestruct {
+    Yes,
+    No,
+}
+
 /// Describes how to elaborate an obligation into a sub-obligation.
 pub trait Elaboratable<I: Interner> {
     fn predicate(&self) -> I::Predicate;
@@ -91,6 +98,7 @@ pub fn elaborate<I: Interner, O: Elaboratable<I>>(
         visited: HashSet::default(),
         mode: Filter::All,
         elaborate_sized: ElaborateSized::No,
+        elaborate_host_effect_destruct: ElaborateHostEffectDestruct::No,
     };
     elaborator.extend_deduped(obligations);
     elaborator
@@ -124,6 +132,12 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
         self
     }
 
+    /// Start elaborating `[const] Destruct`. Should only be used in narrowly scoped contexts.
+    pub fn elaborate_host_effect_destruct(mut self) -> Self {
+        self.elaborate_host_effect_destruct = ElaborateHostEffectDestruct::Yes;
+        self
+    }
+
     fn elaborate(&mut self, elaboratable: &O) {
         let cx = self.cx;
 
@@ -179,16 +193,43 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
                     ),
                 };
             }
-            // `T: [const] Trait` implies `T: [const] Supertrait`.
-            ty::ClauseKind::HostEffect(data) => self.extend_deduped(
-                cx.explicit_implied_const_bounds(data.def_id()).iter_identity().map(|trait_ref| {
-                    elaboratable.child(
-                        trait_ref
-                            .to_host_effect_clause(cx, data.constness)
-                            .instantiate_supertrait(cx, bound_clause.rebind(data.trait_ref)),
-                    )
-                }),
-            ),
+            ty::ClauseKind::HostEffect(data) => {
+                // `T: [const] Trait` implies `T: [const] Supertrait`.
+                self.extend_deduped(
+                    cx.explicit_implied_const_bounds(data.def_id()).iter_identity().map(
+                        |trait_ref| {
+                            elaboratable.child(
+                                trait_ref
+                                    .to_host_effect_clause(cx, data.constness)
+                                    .instantiate_supertrait(
+                                        cx,
+                                        bound_clause.rebind(data.trait_ref),
+                                    ),
+                            )
+                        },
+                    ),
+                );
+
+                // Elaborate structurally implied obligations:
+                // e.g., `ADT: [const] Destruct` implies that each public field also implements
+                // `[const] Destruct`.
+                if self.elaborate_host_effect_destruct == ElaborateHostEffectDestruct::Yes {
+                    let destruct_def_id = cx.require_lang_item(TraitSolverLangItem::Destruct);
+                    if data.def_id() == destruct_def_id {
+                        match solve::const_conditions_for_destruct(cx, data.self_ty(), true) {
+                            solve::DestructConstCondition::Structural(trait_refs) => self
+                                .extend_deduped(trait_refs.into_iter().map(|trait_ref| {
+                                    elaboratable.child(
+                                        bound_clause
+                                            .rebind(trait_ref)
+                                            .to_host_effect_clause(cx, data.constness),
+                                    )
+                                })),
+                            _ => {}
+                        }
+                    }
+                }
+            }
             ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(ty_max, r_min)) => {
                 // We know that `T: 'a` for some type `T`. We can
                 // often elaborate this. For example, if we know that
diff --git a/conditionally-const-option-impl-clone b/conditionally-const-option-impl-clone
diff --git a/conditionally-const-trait-structural-destruct-implied-bounds b/conditionally-const-trait-structural-destruct-implied-bounds
diff --git a/tests/ui/traits/const-traits/conditionally-const-option-impl-clone.rs b/tests/ui/traits/const-traits/conditionally-const-option-impl-clone.rs
@@ -0,0 +1,50 @@
+// Demonstrates that `impl<T> const Clone for Option<T>` does not require const_hack bounds.
+// See issue #144207.
+//@ revisions: next old
+//@ [next] compile-flags: -Znext-solver
+//@ check-pass
+
+#![feature(const_trait_impl, const_destruct)]
+
+use std::marker::Destruct;
+
+#[const_trait]
+pub trait CloneLike: Sized {
+    fn clone(&self) -> Self;
+
+    fn clone_from(&mut self, source: &Self)
+    where
+        Self: [const] Destruct,
+    {
+        *self = source.clone()
+    }
+}
+
+pub enum OptionLike<T> {
+    None,
+    Some(T),
+}
+
+impl<T> const CloneLike for OptionLike<T>
+where
+    T: [const] CloneLike,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Self::Some(x) => Self::Some(x.clone()),
+            Self::None => Self::None,
+        }
+    }
+
+    fn clone_from(&mut self, source: &Self)
+    where
+        Self: [const] Destruct,
+    {
+        match (self, source) {
+            (Self::Some(to), Self::Some(from)) => to.clone_from(from),
+            (to, from) => *to = from.clone(),
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.next.stderr b/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.next.stderr
@@ -0,0 +1,62 @@
+error[E0277]: the trait bound `U: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:41:11
+   |
+LL |         u.f();
+   |           ^
+   |
+note: required by a bound in `TraitA::f`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:14:15
+   |
+LL |     fn f(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitA::f`
+
+error[E0277]: the trait bound `T: const Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:49:27
+   |
+LL |     ensure_const_destruct(x.unwrap())
+   |     --------------------- ^^^^^^^^^^
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `ensure_const_destruct`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:9:35
+   |
+LL | const fn ensure_const_destruct<T: const Destruct>(_t: T) {}
+   |                                   ^^^^^^^^^^^^^^ required by this bound in `ensure_const_destruct`
+
+error[E0277]: the trait bound `T: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:64:16
+   |
+LL |         self.0.g()
+   |                ^
+   |
+note: required by a bound in `TraitB::g`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:56:15
+   |
+LL |     fn g(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitB::g`
+
+error[E0277]: the trait bound `T: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:74:40
+   |
+LL |         ManuallyDrop::into_inner(self).f()
+   |                                        ^
+   |
+note: required by a bound in `TraitA::f`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:14:15
+   |
+LL |     fn f(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitA::f`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.old.stderr b/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.old.stderr
@@ -0,0 +1,62 @@
+error[E0277]: the trait bound `U: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:41:11
+   |
+LL |         u.f();
+   |           ^
+   |
+note: required by a bound in `TraitA::f`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:14:15
+   |
+LL |     fn f(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitA::f`
+
+error[E0277]: the trait bound `T: const Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:49:27
+   |
+LL |     ensure_const_destruct(x.unwrap())
+   |     --------------------- ^^^^^^^^^^
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `ensure_const_destruct`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:9:35
+   |
+LL | const fn ensure_const_destruct<T: const Destruct>(_t: T) {}
+   |                                   ^^^^^^^^^^^^^^ required by this bound in `ensure_const_destruct`
+
+error[E0277]: the trait bound `T: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:64:16
+   |
+LL |         self.0.g()
+   |                ^
+   |
+note: required by a bound in `TraitB::g`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:56:15
+   |
+LL |     fn g(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitB::g`
+
+error[E0277]: the trait bound `T: [const] Destruct` is not satisfied
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:74:40
+   |
+LL |         ManuallyDrop::into_inner(self).f()
+   |                                        ^
+   |
+note: required by a bound in `TraitA::f`
+  --> $DIR/conditionally-const-trait-structural-destruct-implied-bounds.rs:14:15
+   |
+LL |     fn f(self)
+   |        - required by a bound in this associated function
+LL |     where
+LL |         Self: [const] Destruct;
+   |               ^^^^^^^^^^^^^^^^ required by this bound in `TraitA::f`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.rs b/tests/ui/traits/const-traits/conditionally-const-trait-structural-destruct-implied-bounds.rs
