Inherited use constness and assoc change predicate

compiler/rustc_middle/src/ty/assoc.rs

@@ -16,6 +16,15 @@ pub enum AssocItemContainer {
 }
 
 impl AssocItemContainer {
+    /// Asserts that this is the `DefId` of an associated item declared
+    /// in an impl, and returns the trait `DefId`.
+    pub fn assert_impl(&self) -> DefId {
+        match *self {
+            ImplContainer(id) => id,
+            _ => bug!("associated item has wrong container type: {:?}", self),
+        }
+    }
+
     /// Asserts that this is the `DefId` of an associated item declared
     /// in a trait, and returns the trait `DefId`.
     pub fn assert_trait(&self) -> DefId {

compiler/rustc_typeck/src/check/compare_method.rs

@@ -1292,7 +1292,24 @@ pub fn check_type_bounds<'tcx>(
     };
 
     tcx.infer_ctxt().enter(move |infcx| {
-        let inh = Inherited::new(infcx, impl_ty.def_id.expect_local());
+        // if the item is inside a const impl, we transform the predicates to be const.
+        let constness = tcx.impl_constness(impl_ty.container.assert_impl());
+        let pred_map = match constness {
+            hir::Constness::NotConst => |p, _| p,
+            hir::Constness::Const => |p: ty::Predicate<'tcx>, tcx: TyCtxt<'tcx>| {
+                p.kind()
+                    .map_bound(|kind| match kind {
+                        ty::PredicateKind::Trait(mut tp) => {
+                            tp.constness = hir::Constness::Const;
+                            ty::PredicateKind::Trait(tp)
+                        }
+                        kind => kind,
+                    })
+                    .to_predicate(tcx)
+            },
+        };
+
+        let inh = Inherited::with_constness(infcx, impl_ty.def_id.expect_local(), constness);
         let infcx = &inh.infcx;
         let mut selcx = traits::SelectionContext::new(&infcx);
 
@@ -1310,7 +1327,7 @@ pub fn check_type_bounds<'tcx>(
             .explicit_item_bounds(trait_ty.def_id)
             .iter()
             .map(|&(bound, span)| {
-                let concrete_ty_bound = bound.subst(tcx, rebased_substs);
+                let concrete_ty_bound = pred_map(bound.subst(tcx, rebased_substs), tcx);
                 debug!("check_type_bounds: concrete_ty_bound = {:?}", concrete_ty_bound);
 
                 traits::Obligation::new(mk_cause(span), param_env, concrete_ty_bound)
@@ -1328,7 +1345,10 @@ pub fn check_type_bounds<'tcx>(
             debug!("compare_projection_bounds: normalized predicate = {:?}", normalized_predicate);
             obligation.predicate = normalized_predicate;
 
-            inh.register_predicates(obligations);
+            inh.register_predicates(obligations.into_iter().map(|mut o| {
+                o.predicate = pred_map(o.predicate, tcx);
+                o
+            }));
             inh.register_predicate(obligation);
         }
 

compiler/rustc_typeck/src/check/inherited.rs

@@ -9,7 +9,7 @@ use rustc_hir::HirIdMap;
 use rustc_infer::infer;
 use rustc_infer::infer::{InferCtxt, InferOk, TyCtxtInferExt};
 use rustc_middle::ty::fold::TypeFoldable;
-use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt};
+use rustc_middle::ty::{self, OpaqueTypeKey, ToPredicate, Ty, TyCtxt};
 use rustc_span::{self, Span};
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::opaque_types::OpaqueTypeDecl;
@@ -68,6 +68,9 @@ pub struct Inherited<'a, 'tcx> {
     /// opaque type.
     pub(super) opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
 
+    /// Reports whether this is in a const context.
+    pub(super) constness: hir::Constness,
+
     pub(super) body_id: Option<hir::BodyId>,
 }
 
@@ -109,6 +112,12 @@ impl<'tcx> InheritedBuilder<'tcx> {
 
 impl Inherited<'a, 'tcx> {
     pub(super) fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
+        let tcx = infcx.tcx;
+        let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
+        Self::with_constness(infcx, def_id, tcx.hir().get(item_id).constness())
+    }
+
+    pub(super) fn with_constness(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId, constness: hir::Constness) -> Self {
         let tcx = infcx.tcx;
         let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
         let body_id = tcx.hir().maybe_body_owned_by(item_id);
@@ -126,12 +135,29 @@ impl Inherited<'a, 'tcx> {
             deferred_generator_interiors: RefCell::new(Vec::new()),
             opaque_types: RefCell::new(Default::default()),
             opaque_types_vars: RefCell::new(Default::default()),
+            constness,
             body_id,
         }
     }
 
-    pub(super) fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
+    #[instrument(level = "debug", skip(self))]
+    fn transform_predicate(&self, p: &mut ty::Predicate<'tcx>) {
+        // Don't transform non-const bounds into const bounds,
+        // but transform const bounds to non-const when we are
+        // not in a const context.
+        if let hir::Constness::NotConst = self.constness {
+            let kind = p.kind();
+            if let ty::PredicateKind::Trait(pred) = kind.as_ref().skip_binder() {
+                let mut pred = *pred;
+                pred.constness = hir::Constness::NotConst;
+                *p = kind.rebind(ty::PredicateKind::Trait(pred)).to_predicate(self.tcx);
+            }
+        }
+    }
+
+    pub(super) fn register_predicate(&self, mut obligation: traits::PredicateObligation<'tcx>) {
         debug!("register_predicate({:?})", obligation);
+        self.transform_predicate(&mut obligation.predicate);
         if obligation.has_escaping_bound_vars() {
             span_bug!(obligation.cause.span, "escaping bound vars in predicate {:?}", obligation);
         }